pi-quiver 3.1.1 → 3.2.0

package/CHANGELOG.md

@@ -8,6 +8,14 @@ Published to npm as `pi-quiver` (`pi install npm:pi-quiver`). Pushing a
 via OIDC trusted publishing. The release helper at
 `.agents/skills/release/scripts/release.sh` cuts the tag; CI publishes.
 
+## v3.2.0 - 2026-07-12
+
+- Add `fast-mode` extension: opt-in Anthropic fast mode for Claude Opus 4.8 (`speed: "fast"` payload + `fast-mode-2026-02-01` beta header), controlled via `fastMode` settings key, `--fast` flag, and `/fast [on|off|status]`. OFF by default. Preserves OAuth identity betas. Requires pi bundling `@earendil-works/pi-coding-agent` >= 0.80.5 (the `before_provider_headers` hook).
+
+## v3.1.2 - 2026-07-07
+
+- **`fetch` routes GitHub Actions run URLs through `gh`.** `github.com/{owner}/{repo}/actions/runs/{id}` URLs are served by `gh run view {id} --repo {owner}/{repo}` and returned through the existing size gate with a `Source: gh run view ...` header, alongside the existing issue/PR/repo routing. Only the bare run URL routes; deeper paths (`.../runs/{id}/jobs/{jobId}`, `.../actions/workflows/{file}`) fall back to HTTP. Falls back silently when `gh` is absent/unauthenticated/errors; `raw=true` forces the rendered page.
+
 ## v3.1.1 - 2026-07-05
 
 Branding, funding, and gallery preview. No behavior change.

package/README.md

@@ -6,146 +6,89 @@
 
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-donate-yellow?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/jjurasszek)
 
-A small pack of [Pi coding-agent](https://github.com/earendil-works/pi) extensions I keep across every pi profile. First-party-quality tools, published to npm like sibling packages ([`pi-cohort`](https://github.com/jjuraszek/pi-cohort), [`pi-gauntlet`](https://github.com/jjuraszek/pi-gauntlet), [`pi-condense`](https://github.com/jjuraszek/pi-condense)).
+Ground-truth ingestion for the [Pi coding agent](https://github.com/earendil-works/pi): pull real web pages, docs, and local files into context without flooding it.
 
-## Extensions
+## The problem
 
-| Extension | Tool | What it does |
-|---|---|---|
-| `fetch.ts` | `fetch` | Retrieve URLs over HTTP(S). HTML → Markdown (main-content extraction, stripped boilerplate). Binary content saved untouched to a temp file. **Context-safe:** output over 32 KB or 1000 lines is written to a temp file with a preview + file path. Prevents a single fetch from flooding the context window. |
-| `doc_to_md.ts` | `doc_to_md` | Convert a local PDF/DOCX/PPTX to Markdown. High-fidelity via `pymupdf4llm` (run through `uv`, fetched on first use); degraded pure-JS fallback (`unpdf`) when `uv`/Python is unavailable or conversion times out. DOCX/PPTX convert via LibreOffice (`soffice`) to PDF first. Same 32 KB / 1000-line size gate as `fetch`. |
-| `session-name.ts` | `/session-name` | Name work sessions. Manual `/session-name [name]` always works. **OFF by default:** when opted in via `settings.json`, after the first agent turn it asks the current model for a concise session name + short tab label and applies them, and renames the **Ghostty** tab via OSC 2 (only when the active terminal is really Ghostty), re-asserting it each turn so the tab tracks the session name. |
-| `sword-header.ts` | `/builtin-header` | Replace the TUI startup logo with a theme-colored ASCII greatsword (hilt = accent, blade = text). **OFF by default:** only installs the header when opted in via `settings.json`. `/builtin-header` restores the built-in header at runtime. |
-
-## Prerequisites
-
-The npm package's bundled JS deps install automatically on `pi install` - nothing to set up there. A few **runtime system binaries** are optional; each degrades gracefully when absent:
-
-| Prerequisite | Needed by | If absent |
-|---|---|---|
-| `gh` (GitHub CLI, installed + `gh auth login`) | `fetch` GitHub issue/PR/repo routing | Falls back to an HTTP fetch of the rendered page (private repos hit a login wall). |
-| `uv` (+ managed Python 3.14, fetched on first use) | `doc_to_md` high-fidelity PDF conversion | Degrades to the pure-JS `unpdf` fallback (no faithful tables/headings). |
-| LibreOffice (`soffice` on `PATH`) | `doc_to_md` DOCX/PPTX conversion | Office inputs error (no JS fallback for office->PDF); PDFs unaffected. |
-
-None is a hard install-time dependency of the package; they are tools you provide in the environment where pi runs.
-
-### fetch — content routing & context hygiene
-
-`fetch` is the main way an agent pulls external bytes into context. This extension routes responses by type to keep context tight:
-
-**HTML → Markdown:**
-- Mozilla Readability extracts main content, strips navigation/chrome/boilerplate
-- Turndown converts to Markdown with GFM support (pipe tables, fenced code blocks, ATX headings)
-- Page title becomes a top-level `#` heading
-- Download cap: **1 MB**
-
-**Binary (images, PDFs, archives, fonts, audio/video) → temp file:**
-- Streamed untouched to `${TMPDIR}/pi-fetch/<stamp>-<host>-<hash>.<ext>` without decoding
-- Detection: content-type check + NUL-byte sniff in first ≤64 KB (catches mislabeled payloads)
-- Returns: status, content-type, size, file path — **no preview**
-- Download cap: **50 MB**
-
-**Text / Markdown / JSON size gate:**
-- Inline when **≤ 32 KB AND ≤ 1000 lines** (converted output size)
-- Otherwise **spills to file** with:
-  - HTTP status, content-type, charset, byte/line counts
-  - File path (`Saved-To:`)
-  - 60-line preview
-  - Instruction to `grep` (Markdown is grep-able by heading: `^#`) or `read` slices
+Reasoning from a model's training memory instead of the real page, the current docs, or the actual PDF is how agents confidently ship wrong answers about APIs that changed last month. Mature engineering work has to be data-driven - the agent needs to read the real source.
 
-**JSON:** Pretty-printed with 2-space indent before the gate.
+But the moment an agent does that, one `fetch` or PDF read can dump hundreds of kilobytes of boilerplate into context, degrading every turn after it.
 
-**GitHub URLs -> `gh`:** `github.com` issue (`/issues/{n}`), PR (`/pull/{n}`), and repo-root (`/{owner}/{repo}`) URLs are served by running the `gh` CLI (`gh issue|pr view --comments`, `gh repo view`) and returning its output, tagged with a `Source: gh ...` header and run through the same size gate. Requires `gh` (see [Prerequisites](#prerequisites)); if `gh` is missing or the call fails, `fetch` silently falls back to the normal HTTP path. Pass `raw=true` to force the rendered HTML page. All other GitHub paths (`tree`, `blob`, `raw`, `releases`, gists, ...) use the HTTP path unchanged. Routing is also skipped (plain HTTP used) when the request is non-GET, carries a body, or sets custom headers. gh output is bounded by a 10 MB buffer and run through the same size gate (spilled to a file when large), not the 1 MB HTTP download cap.
+## Why pi-quiver exists
 
-**Parameters:**
-- `raw=true`: Skip HTML→Markdown and JSON pretty-printing; return decoded body as-is (still subject to the size gate).
-- `raw=true` also bypasses GitHub `gh` routing (forces the HTTP/rendered path).
+`fetch` and `doc_to_md` bring real web pages, GitHub issues/PRs, and local PDF/DOCX/PPTX files into context - and every result is size-gated by construction: over 32 KB or 1000 lines spills to a temp file with a preview and a grep/read hint, so a single call can never flood the window. Ingestion is what makes data-driven work possible; the gate is what keeps it safe.
 
-**Truncation:** Parsable content over 1 MB is truncated with a `(truncated to 1MB)` note; binary over 50 MB notes `(truncated to 50MB)`.
+`session-name` and `sword-header` are smaller, opt-in ergonomics on top - session labeling and a themed startup header.
 
-**Runtime dependencies:** `jsdom`, `@mozilla/readability`, `turndown`, `turndown-plugin-gfm`. Shipped in the npm package and installed automatically on `pi install` - no manual setup needed.
+## Part of the pi agent toolkit
 
-### doc_to_md — local document → Markdown
+Four independent extensions for the [pi coding agent](https://github.com/earendil-works/pi), each owning one concern of running agents seriously:
 
-`doc_to_md` takes a **local file path** (`.pdf`, `.docx`, `.pptx`) and returns Markdown. For remote documents, `fetch` the URL first (it saves binaries to a temp path), then pass that path here.
+- **pi-quiver** - capabilities (fetch, doc conversion, session tools)
+- [pi-cohort](https://github.com/jjuraszek/pi-cohort) - coordination (delegate to focused child agents)
+- [pi-condense](https://github.com/jjuraszek/pi-condense) - context economy (prune context, keep it recoverable)
+- [pi-gauntlet](https://github.com/jjuraszek/pi-gauntlet) - process (the gated brainstorm->ship workflow)
 
-**Two engines, auto-selected:**
+No code dependency between them. pi-quiver is call-level: it gates the size of what comes *in*. [pi-condense](https://github.com/jjuraszek/pi-condense) is loop-level: it prunes what's already *in context* once a tool call is done. Different problem, same discipline.
 
-- **Primary — `pymupdf4llm`** (high fidelity: headings, tables, reading order). Runs as an arms-length subprocess via `uv run --with pymupdf4llm==<pin> --python 3.14`. `uv` fetches the wheel into its own cache on first use (one-time download); Python 3.14 is fixed. Warmed once per process: the first call probes/installs (generous budget), later calls reuse the warm cache with a shorter per-document budget.
-- **Fallback — `unpdf`** (pure JS, bundled PDF.js). Used when `uv` is not on `PATH`, the warm probe fails, or a conversion times out. Output is plain text with page breaks — **no faithful tables/headings**. Degraded results are marked in the output (`[Note: degraded extraction via unpdf ...]`) and carry a `Fallback-Reason:` line.
+## Mental model
 
-**Office documents (`.docx`, `.pptx`):** converted to PDF by headless LibreOffice (`soffice`, isolated per-call profile), then fed through the same PDF pipeline. `soffice` must be on `PATH` for office inputs — otherwise the tool errors (there is no JS fallback for office→PDF). Spreadsheets and other formats are out of scope (spreadsheets paginate badly via PDF).
+Every extension here is context-safe by construction, not by convention: the size check runs on every call, there's no flag to forget. Two tools bring real sources in (`fetch`, `doc_to_md`); two are opt-in ergonomics (`session-name`, `sword-header`).
 
-**Size gate:** identical to `fetch` — Markdown ≤ 32 KB and ≤ 1000 lines is inlined; larger output spills to `${TMPDIR}/pi-doc-to-md/<stamp>-<basename>-<hash>.md` with a 60-line preview + a grep/read-slice hint.
-
-**Configuration (environment variables):**
-
-| Variable | Default | Meaning |
-|---|---|---|
-| `PI_DOC_TO_MD_PYMUPDF_VERSION` | `1.27.2.3` | `pymupdf4llm` version pin passed to `uv --with` (digits/dots only) |
-| `PI_DOC_TO_MD_WARM_TIMEOUT_MS` | `120000` | Warm/install call budget — covers the cold wheel (+ managed Python) download |
-| `PI_DOC_TO_MD_CONVERT_TIMEOUT_MS` | `60000` | Per-document conversion budget (also bounds the `unpdf` fallback) |
-| `PI_DOC_TO_MD_SOFFICE_TIMEOUT_MS` | `120000` | LibreOffice `.docx`/`.pptx` → PDF budget |
-
-Python is pinned to **3.14** and is not configurable.
-
-**Runtime dependencies:** `unpdf` (shipped in the npm package, installed automatically on `pi install`). `uv` and LibreOffice (`soffice`) are optional system binaries detected at runtime: without `uv`, PDFs still convert via the `unpdf` fallback; without `soffice`, office inputs error while PDFs are unaffected. See [Prerequisites](#prerequisites) for the consolidated list.
-
-**Licensing note:** `pymupdf4llm`/PyMuPDF are **AGPL-3.0**. This package ships none of their code — `uv` downloads the wheel from PyPI onto your machine at runtime, and it runs as a **separate subprocess** (never imported or linked into this TypeScript). The arms-length process boundary keeps pi-quiver' MIT license intact; the AGPL governs PyMuPDF itself, whose source is public. This holds only while the boundary stays subprocess-only (no vendoring/importing the wheel).
-
-### session-name — manual + opt-in automatic session naming
-
-Names work sessions so the session selector (and optionally the Ghostty tab) shows what each one is about.
-
-**Behaviors:**
-
-- **Manual `/session-name [name]`** - set the session name, or, with no argument, print the current one. Always available, regardless of config. A manual name wins: it suppresses later auto-naming for the session.
-- **Automatic naming (opt-in).** After the first agent turn completes, if no name is set yet, the extension asks the **current model** for a 3-6 word session title plus a 1-4 word tab label and applies both. It only runs once per session and never overwrites an existing name.
-- **Resume reflection (opt-in).** When a session that already carries a name is loaded/resumed/reloaded, its tab label is re-applied so the Ghostty tab matches.
-- **Per-turn re-assert (opt-in).** The tab is re-pinned to the session name at the start of every turn. Pi owns the OS terminal title (OSC 0, `pi - <name> - <cwd>`) and overwrites it on every name change and session switch; the re-assert is the only hook that fires *after* pi's writer on a session swap, so the Ghostty tab and the session name stay in sync instead of drifting. It self-heals: if the name was changed outside this extension, the tab label is re-derived from the new name.
-- **Ghostty tab rename.** The short label is written via OSC 2 (`ESC ] 2 ; <label> BEL`) **only when the active terminal is really Ghostty** (`TERM_PROGRAM=ghostty`, `TERM=xterm-ghostty`, or a `GHOSTTY_*` dir env) **and** stdout is a TTY. Other terminals are never touched. Auto-naming keeps its curated short label; re-derived labels (resume/external rename) are the first words of the session name.
-
-**OFF by default.** All automatic behavior (auto-naming + resume reflection) is inert until explicitly enabled. The manual command is unaffected.
+```mermaid
+flowchart LR
+    S[web page / PDF / doc] --> T["fetch / doc_to_md"]
+    T --> E[extract main content]
+    E --> G{"over 32KB or 1000 lines?"}
+    G -->|no| I[return inline to context]
+    G -->|yes| F[spill to temp file<br/>return preview + grep/read hint]
+```
 
-**Configuration** (`settings.json`, **project `.pi/settings.json` overrides the global agent-dir `settings.json`**). The global path is resolved via pi's own `getAgentDir()` (honours `PI_CODING_AGENT_DIR`, else `~/.pi/agent`), so it stays correct however this package is installed.
+## Quick example
 
-```jsonc
-{
-  // full form, defaults shown
-  "sessionAutoName": { "enabled": false, "ghosttyTab": true }
-}
+```bash
+pi install npm:pi-quiver
 ```
 
-| Key | Default | Meaning |
-|---|---|---|
-| `enabled` | `false` | Master switch for automatic naming + resume reflection. |
-| `ghosttyTab` | `true` | Whether to rename the Ghostty tab (only ever fires when the terminal is actually Ghostty). |
+```
+> fetch https://example.com/some-huge-changelog
+Saved-To: /tmp/pi-fetch/2026-...-example.com-....md
+60-line preview follows. grep '^#' the file for headings, or read a slice.
+```
 
-Boolean shorthand: `"sessionAutoName": true` enables everything (equivalent to `{ "enabled": true, "ghosttyTab": true }`); `false` disables everything.
+A 300 KB changelog page never touches your context window - you get a preview and a path.
 
-**Cost note:** when enabled, automatic naming makes **one extra short LLM call** per session (low reasoning effort, current model, a few-thousand-char conversation digest), once, after the first turn. When OFF (the default) it makes **no** model calls and writes **nothing** to the terminal.
+## Architecture
 
-**Runtime dependency:** `@earendil-works/pi-ai` (the unified LLM API provided by the pi runtime; a peer dependency, no separate install).
+| Extension | Tool | What it does |
+| --- | --- | --- |
+| `fetch.ts` | `fetch` | Retrieve URLs over HTTP(S). HTML -> Markdown (Readability extraction, Turndown conversion). Binary saved untouched to a temp file. GitHub issue/PR/repo/actions-run URLs auto-route through `gh` (falls back to HTTP). Same size gate as `doc_to_md`. |
+| `doc_to_md.ts` | `doc_to_md` | Convert a local PDF/DOCX/PPTX to Markdown. High-fidelity via `pymupdf4llm` (run through `uv`); degraded pure-JS fallback (`unpdf`) when `uv`/Python is unavailable or conversion times out. DOCX/PPTX convert via LibreOffice first. |
+| `session-name.ts` | `/session-name` | Manual + opt-in automatic session naming, with Ghostty tab rename. OFF by default. |
+| `sword-header.ts` | `/builtin-header` | Themed ASCII startup header replacing pi's default logo. OFF by default. |
+| `fast-mode.ts` | `/fast` | Inject Anthropic fast-mode (`speed: "fast"` + `anthropic-beta: fast-mode-2026-02-01`) into every Claude Opus 4.8 request, any thinking level. `--fast` flag + `/fast [on\|off\|status]`. OFF by default. |
 
-### sword-header — themed ASCII startup header
+Full routing rules, size-gate mechanics, and config: [doc/fetch.md](doc/fetch.md), [doc/doc-to-md.md](doc/doc-to-md.md).
 
-Replaces pi's built-in startup logo with a hero's greatsword (Michael J. Penick longsword, asciiart.eu). The ASCII art is verbatim; only the coloring is ours - hilt/grip/pommel use the `accent` token, the blade uses `text`, so it tracks whatever theme is active.
+## Key concepts
 
-**Behaviors:**
+| Concept | Meaning |
+| --- | --- |
+| Size gate | Text/Markdown/JSON output over 32 KB or 1000 lines spills to a temp file with a 60-line preview instead of inlining. |
+| Content routing | HTML -> Markdown, binary -> untouched file, GitHub URLs -> `gh` CLI, everything else -> the size gate. |
+| Graceful degradation | Optional binaries (`gh`, `uv`, LibreOffice) are never hard install-time deps; each has a defined, documented fallback or failure mode. |
+| Opt-in ergonomics | `session-name` and `sword-header` do nothing until explicitly enabled in `settings.json`. |
 
-- **TUI only.** Installs a custom header on `session_start` when `ctx.mode === "tui"`. In print/non-interactive mode (`-p`) it does nothing.
-- **`/builtin-header`** restores the built-in pi header at runtime (always available).
+## When to use
 
-**OFF by default.** The header is only installed when explicitly enabled via `settings.json`.
+- An agent needs to reason from a real web page, GitHub issue/PR, or local PDF/DOCX/PPTX instead of memory.
+- You want that ingestion to be safe by default, with no risk of a single call blowing the context budget.
 
-**Configuration** (`settings.json`, project `.pi/settings.json` overrides the global agent-dir layer; same resolution as `session-name`):
+## When NOT to use
 
-```jsonc
-{
-  "swordHeader": false           // default; true installs the header
-  // object form also accepted: "swordHeader": { "enabled": true }
-}
-```
+- You need a general-purpose web scraper (JS-rendered pages, pagination, auth flows) - `fetch` does plain HTTP + Readability extraction, nothing more.
+- You need spreadsheet conversion - `doc_to_md` explicitly excludes spreadsheets (they paginate badly via PDF).
+- You want automatic session naming or a custom header without opting in - both stay off until you flip the config.
 
 ## Install
 
@@ -176,6 +119,32 @@ git clone git@github.com:jjuraszek/pi-quiver.git ~/repos/pi-quiver
 pi -e ~/repos/pi-quiver/fetch.ts
 ```
 
+## Prerequisites
+
+The npm package's bundled JS deps install automatically on `pi install`. A few **runtime system binaries** are optional; each degrades gracefully when absent:
+
+| Prerequisite | Needed by | If absent |
+| --- | --- | --- |
+| `gh` (GitHub CLI, installed + `gh auth login`) | `fetch` GitHub issue/PR/repo/actions-run routing | Falls back to an HTTP fetch of the rendered page (private repos hit a login wall). |
+| `uv` (+ managed Python 3.14, fetched on first use) | `doc_to_md` high-fidelity PDF conversion | Degrades to the pure-JS `unpdf` fallback (no faithful tables/headings). |
+| LibreOffice (`soffice` on `PATH`) | `doc_to_md` DOCX/PPTX conversion | Office inputs error (no JS fallback for office->PDF); PDFs unaffected. |
+
+None is a hard install-time dependency of the package; they are tools you provide in the environment where pi runs.
+
+### Opt-in extension config
+
+Both are opt-in via `settings.json` (project `.pi/settings.json` overrides the global agent-dir layer):
+
+```jsonc
+{
+  "sessionAutoName": { "enabled": false, "ghosttyTab": true }, // or boolean shorthand
+  "swordHeader": false,                                        // or { "enabled": true }
+  "fastMode": false                                            // or { "enabled": true }
+}
+```
+
+`sessionAutoName.enabled` makes one extra short LLM call per session (once, after the first turn) to title it; `false` (default) makes no model calls. `fastMode` only affects `claude-opus-4-8` requests on Anthropic's `anthropic-messages` API; enabling it opts into premium fast-mode pricing. `--fast` forces it on for one launch; `/fast on|off` toggles live. Proxy providers (opencode, cloudflare-ai-gateway) are excluded. `fastMode`'s header injection needs the `before_provider_headers` hook (pi bundling `@earendil-works/pi-coding-agent` >= 0.80.5); on older pi the beta header is silently not sent. See [doc/fetch.md](doc/fetch.md) and [doc/doc-to-md.md](doc/doc-to-md.md) for the ingestion tools' full reference; session-name/sword-header behavior above is complete.
+
 ## Development
 
 Deps are peers (`@earendil-works/*`, `@sinclair/typebox`) plus the bundled
@@ -189,6 +158,10 @@ npm run test:all      # node --test *.test.ts  +  tsc --noEmit typecheck
 `npm test` runs the unit tests alone; `npm run typecheck` runs the type pass.
 Both run in CI on ubuntu + windows (`.github/workflows/test.yml`).
 
+## How this fits the platform
+
+pi-quiver is how ground truth gets into an agent's context - real pages, PDFs, docs, cleanly and safely. The other three then coordinate work over it ([pi-cohort](https://github.com/jjuraszek/pi-cohort)), prune it once it's stale ([pi-condense](https://github.com/jjuraszek/pi-condense)), and govern the process end to end ([pi-gauntlet](https://github.com/jjuraszek/pi-gauntlet)).
+
 ## Support
 
 If this saves you time, consider [buying me a coffee](https://buymeacoffee.com/jjurasszek).

package/fast-mode.ts

@@ -0,0 +1,182 @@
+/**
+ * Fast mode for Claude Opus 4.8.
+ *
+ * When enabled, injects Anthropic's fast-mode signals into every qualifying
+ * Opus 4.8 request on the anthropic-messages API, regardless of thinking level:
+ *   - payload: { ...payload, speed: "fast" }        (before_provider_request)
+ *   - header:  anthropic-beta: ...,fast-mode-2026-02-01  (before_provider_headers)
+ *
+ * OFF BY DEFAULT. Three control surfaces, lowest precedence first:
+ *   1. settings.json  "fastMode": true | { "enabled": true }  (default false)
+ *   2. --fast launch flag                                      (force-on only)
+ *   3. /fast [on|off|status] live toggle                       (wins for session)
+ *
+ * Header coupling to pi-ai internals: pi assembles `anthropic-beta` AFTER this
+ * hook and merges the hook's headers LAST, so setting the header here REPLACES
+ * pi's list. For opus-4-8 pi's conditional betas (fine-grained tool streaming,
+ * interleaved thinking) are never applied (eager tool streaming defaults on +
+ * forceAdaptiveThinking), so the only betas to preserve are the OAuth identity
+ * betas. We detect OAuth via the same token marker pi uses and rebuild the
+ * exact list. If pi later adds betas for opus-4-8, revisit buildBetaHeader.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { resolveConfig } from "./extension-config.ts";
+
+export const FAST_MODE_BETA = "fast-mode-2026-02-01";
+export const FAST_SPEED = "fast";
+// Loose prefix: matches dated snapshots (claude-opus-4-8-*). Opus 4.7 is out of
+// scope (D1); a future 4.9 needs a one-line addition here.
+export const FAST_MODE_MODEL_PREFIXES = ["claude-opus-4-8"];
+export const OAUTH_IDENTITY_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
+const STATUS_KEY = "fast-mode";
+const BETA_HEADER = "anthropic-beta";
+
+type Config = { enabled: boolean };
+const DEFAULT_CONFIG: Config = { enabled: false };
+
+export function coerce(raw: unknown): Partial<Config> | undefined {
+	if (raw === undefined) return undefined;
+	if (typeof raw === "boolean") return { enabled: raw };
+	if (raw && typeof raw === "object") {
+		const o = raw as Record<string, unknown>;
+		const out: Partial<Config> = {};
+		if (typeof o.enabled === "boolean") out.enabled = o.enabled;
+		return out;
+	}
+	return undefined;
+}
+
+type ModelLike = { id?: string; api?: string; provider?: string } | undefined;
+
+export function shouldInject(enabled: boolean, model: ModelLike): boolean {
+	if (!enabled || !model) return false;
+	if (model.provider !== "anthropic") return false;
+	if (model.api !== "anthropic-messages") return false;
+	const id = model.id;
+	if (typeof id !== "string") return false;
+	return FAST_MODE_MODEL_PREFIXES.some((p) => id.startsWith(p));
+}
+
+export function injectSpeed(payload: unknown): unknown {
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+		return payload;
+	}
+	return { ...(payload as Record<string, unknown>), speed: FAST_SPEED };
+}
+
+export function buildBetaHeader(existing: string | null | undefined, isOAuth: boolean): string {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	const add = (b: string): void => {
+		const t = b.trim();
+		if (t && !seen.has(t)) {
+			seen.add(t);
+			out.push(t);
+		}
+	};
+	if (isOAuth) OAUTH_IDENTITY_BETAS.forEach(add);
+	if (typeof existing === "string") existing.split(",").forEach(add);
+	add(FAST_MODE_BETA);
+	return out.join(",");
+}
+
+type State = { config: boolean; flag: boolean; live: boolean | null };
+
+export function resolveEnabled(s: State): boolean {
+	if (s.live !== null) return s.live;
+	return s.flag || s.config;
+}
+
+export default function (pi: ExtensionAPI) {
+	let liveOverride: boolean | null = null;
+	let enabled = false;
+
+	const readFlag = (): boolean => pi.getFlag("fast") === true;
+
+	const resolveState = (ctx: ExtensionContext): boolean => {
+		const config = resolveConfig(ctx.cwd, "fastMode", DEFAULT_CONFIG, coerce).enabled;
+		enabled = resolveEnabled({ config, flag: readFlag(), live: liveOverride });
+		return enabled;
+	};
+
+	const refreshStatus = (ctx: ExtensionContext): void => {
+		if (!enabled) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			return;
+		}
+		ctx.ui.setStatus(STATUS_KEY, shouldInject(enabled, ctx.model) ? "\u26a1 fast" : "\u26a1 n/a");
+	};
+
+	const detectOAuth = async (ctx: ExtensionContext): Promise<boolean | null> => {
+		if (!ctx.model) return null;
+		try {
+			const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+			if (!auth.ok) return null;
+			return typeof auth.apiKey === "string" && auth.apiKey.includes("sk-ant-oat");
+		} catch {
+			return null;
+		}
+	};
+
+	pi.registerFlag("fast", {
+		type: "boolean",
+		description: "Enable Anthropic fast mode for Opus 4.8 requests this launch",
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		resolveState(ctx);
+		refreshStatus(ctx);
+	});
+
+	pi.on("model_select", async (_event, ctx) => {
+		refreshStatus(ctx);
+	});
+
+	pi.on("before_provider_request", (event, ctx) => {
+		if (!shouldInject(enabled, ctx.model)) return;
+		return injectSpeed(event.payload);
+	});
+
+	pi.on("before_provider_headers", async (event, ctx) => {
+		if (!shouldInject(enabled, ctx.model)) return;
+		if (!event.headers) return;
+		const isOAuth = await detectOAuth(ctx);
+		if (isOAuth === null) return;
+		event.headers[BETA_HEADER] = buildBetaHeader(event.headers[BETA_HEADER], isOAuth);
+	});
+
+	pi.registerCommand("fast", {
+		description: "Manage Opus 4.8 fast mode: /fast [on|off|status]",
+		getArgumentCompletions: (prefix) => {
+			const p = prefix.trim().toLowerCase();
+			if (p.includes(" ")) return null;
+			const matches = ["on", "off", "status"].filter((v) => v.startsWith(p));
+			return matches.length ? matches.map((value) => ({ value, label: value })) : null;
+		},
+		handler: async (args, ctx) => {
+			const arg = args.trim().toLowerCase();
+			if (arg === "status") {
+				const eff = liveOverride !== null ? "live toggle" : readFlag() ? "--fast flag" : "settings.json";
+				const model = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "(no model selected)";
+				const applies = shouldInject(enabled, ctx.model) ? "applies to current model" : "does not apply to current model";
+				ctx.ui.notify(
+					`Fast mode is ${enabled ? "on" : "off"} (source: ${eff}). Model: ${model} - ${applies}.`,
+					"info",
+				);
+				return;
+			}
+			if (arg === "on" || arg === "off") {
+				liveOverride = arg === "on";
+			} else if (arg === "") {
+				liveOverride = !enabled;
+			} else {
+				ctx.ui.notify("Usage: /fast [on|off|status]", "warning");
+				return;
+			}
+			resolveState(ctx);
+			refreshStatus(ctx);
+			ctx.ui.notify(`Fast mode ${enabled ? "enabled" : "disabled"}`, "info");
+		},
+	});
+}

package/fetch.ts

@@ -44,7 +44,8 @@ interface FetchToolDetails {
 type GhTarget =
 	| { kind: "issue"; url: string }
 	| { kind: "pr"; url: string }
-	| { kind: "repo"; slug: string };
+	| { kind: "repo"; slug: string }
+	| { kind: "run"; slug: string; runId: string; url: string };
 
 const RESERVED_OWNERS = new Set([
 	"orgs", "users", "sponsors", "topics", "marketplace", "apps",
@@ -67,6 +68,9 @@ export function classifyGitHubTarget(url: URL): GhTarget | null {
 	if (segs.length === 4 && segs[2] === "pull" && /^\d+$/.test(segs[3])) {
 		return { kind: "pr", url: `https://github.com/${owner}/${repo}/pull/${segs[3]}` };
 	}
+	if (segs.length === 5 && segs[2] === "actions" && segs[3] === "runs" && /^\d+$/.test(segs[4])) {
+		return { kind: "run", slug: `${owner}/${repo}`, runId: segs[4], url: `https://github.com/${owner}/${repo}/actions/runs/${segs[4]}` };
+	}
 	if (segs.length === 2) {
 		return { kind: "repo", slug: `${owner}/${repo}` };
 	}
@@ -76,6 +80,7 @@ export function classifyGitHubTarget(url: URL): GhTarget | null {
 export function buildGhArgs(target: GhTarget): string[] {
 	if (target.kind === "issue") return ["issue", "view", target.url, "--comments"];
 	if (target.kind === "pr") return ["pr", "view", target.url, "--comments"];
+	if (target.kind === "run") return ["run", "view", target.runId, "--repo", target.slug];
 	return ["repo", "view", target.slug];
 }
 
@@ -120,12 +125,14 @@ export function planGhRouting(params: GhRoutingParams, url: URL): GhTarget | nul
 function ghCommandLabel(target: GhTarget): string {
 	if (target.kind === "issue") return "issue view --comments";
 	if (target.kind === "pr") return "pr view --comments";
+	if (target.kind === "run") return "run view";
 	return "repo view";
 }
 
 function ghSourceLine(target: GhTarget, ref: string): string {
 	if (target.kind === "issue") return `gh issue view ${ref} --comments`;
 	if (target.kind === "pr") return `gh pr view ${ref} --comments`;
+	if (target.kind === "run") return `gh run view ${target.runId} --repo ${target.slug}`;
 	return `gh repo view ${ref}`;
 }
 
@@ -451,14 +458,14 @@ export default function fetchExtension(pi: ExtensionAPI) {
 		name: "fetch",
 		label: "Fetch URL",
 		description:
-			"Fetch a URL over HTTP(S). HTML is extracted to Markdown (readability + turndown). Binary content (images, PDFs, archives) is saved untouched to a temp file and only a path is returned. Text/Markdown/JSON over 32KB or 1000 lines is written to a temp file with a 60-line preview; smaller content is returned inline. Parsable downloads are capped at 1MB, binary at 50MB. GitHub issue/PR/repo URLs are served via the gh CLI when available (falls back to HTTP otherwise).",
+			"Fetch a URL over HTTP(S). HTML is extracted to Markdown (readability + turndown). Binary content (images, PDFs, archives) is saved untouched to a temp file and only a path is returned. Text/Markdown/JSON over 32KB or 1000 lines is written to a temp file with a 60-line preview; smaller content is returned inline. Parsable downloads are capped at 1MB, binary at 50MB. GitHub issue/PR/repo/actions-run URLs are served via the gh CLI when available (falls back to HTTP otherwise).",
 		promptSnippet: "Fetch the contents of a URL",
 		promptGuidelines: [
 			"Use fetch when the user provides a URL or asks to read web content.",
 			"Binary responses return a file path only — pass that path to a tool that can process the bytes; do not expect inline content.",
 			"When the body is written to a file, grep it or read with offset/limit. Converted Markdown is grep-able by heading (^#).",
 			"Pass raw=true to skip Markdown/JSON conversion and get the decoded body as-is (still subject to the size gate).",
-			"GitHub issue/PR/repo links are fetched through the gh CLI automatically; pass raw=true to force the rendered HTML page.",
+			"GitHub issue/PR/repo/actions-run links are fetched through the gh CLI automatically; pass raw=true to force the rendered HTML page.",
 		],
 		parameters: Type.Object({
 			url: Type.String({ description: "Absolute http(s) URL" }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-quiver",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Personal pack of Pi coding-agent extensions: context-safe fetch, doc_to_md PDF/DOCX/PPTX-to-Markdown conversion, session naming, and a themed ASCII startup header.",
   "author": "Jacek Juraszek",
   "license": "MIT",
@@ -32,6 +32,7 @@
     "doc_to_md.ts",
     "session-name.ts",
     "sword-header.ts",
+    "fast-mode.ts",
     "extension-config.ts",
     "scripts/pdf_to_md.py",
     "types/**/*.d.ts",
@@ -41,7 +42,7 @@
   "scripts": {
     "check:agents-core": "node scripts/check-agents-core.mjs",
     "test": "node --test \"*.test.ts\"",
-    "typecheck": "npx -y tsc --noEmit --allowImportingTsExtensions --target es2022 --module nodenext --moduleResolution nodenext --strict --skipLibCheck --esModuleInterop --resolveJsonModule --lib es2022 --types node fetch.ts fetch.test.ts doc_to_md.ts doc_to_md.test.ts session-name.ts session-name.test.ts sword-header.ts sword-header.test.ts extension-config.ts types/turndown-plugin-gfm.d.ts",
+    "typecheck": "npx -y tsc --noEmit --allowImportingTsExtensions --target es2022 --module nodenext --moduleResolution nodenext --strict --skipLibCheck --esModuleInterop --resolveJsonModule --lib es2022 --types node fetch.ts fetch.test.ts doc_to_md.ts doc_to_md.test.ts session-name.ts session-name.test.ts sword-header.ts sword-header.test.ts fast-mode.ts fast-mode.test.ts extension-config.ts types/turndown-plugin-gfm.d.ts",
     "test:all": "npm run check:agents-core && npm run test && npm run typecheck"
   },
   "pi": {
@@ -49,7 +50,8 @@
       "./fetch.ts",
       "./doc_to_md.ts",
       "./session-name.ts",
-      "./sword-header.ts"
+      "./sword-header.ts",
+      "./fast-mode.ts"
     ],
     "image": "https://raw.githubusercontent.com/jjuraszek/pi-quiver/main/pi-quiver.png"
   },
@@ -86,7 +88,7 @@
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.80.3",
-    "@earendil-works/pi-coding-agent": "^0.80.3",
+    "@earendil-works/pi-coding-agent": "^0.80.5",
     "@earendil-works/pi-tui": "^0.80.3",
     "@sinclair/typebox": "^0.34.49",
     "@types/jsdom": "^28.0.3",