@diousk/pi-subagents-fast 0.20.0 → 0.21.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.21.0] - 2026-09-30
+
+> **Breaking: requires Pi 0.99.1 or newer.** Update Pi before installing this version. Legacy transcript and session API compatibility paths have been removed.
+
+### Added
+- **Custom agents accept `service_tier: fast`.** OpenAI Responses and Codex requests forward the configured tier, and `priority` remains accepted.
+
+### Changed
+- **The minimum supported Pi version is 0.99.1.** Development dependencies and blocking CI target that minimum. Scripted model fixtures use transcript replay and physical model lookup.
+
+### Fixed
+- **Mention clones preserve conversation history on Pi 0.99.1.** History is seeded through the session manager, and the live prompt is supplied through the resource loader. Historical system messages do not grant the clone the parent's tools.
+- **Subagent tool scope covers nested execution.** A bound `tool_call` guard blocks out-of-scope deferred/codemode calls, while tool narrowing preserves exposure. Synthetic extension paths match their logical names.
+- **Output transcripts preserve system messages.** System/tool-state changes receive a `system` entry type, and a leading system message no longer causes the initial user prompt to be duplicated.
+
 ## [0.20.0] - 2026-09-09
 
 > **Breaking — the npm package is now `@diousk/pi-subagents-fast`.** Existing installs of `@tintinweb/pi-subagents` are not automatically migrated; install this fork with `pi install npm:@diousk/pi-subagents-fast`.

package/README.md

@@ -76,7 +76,9 @@ npm pack --dry-run
 
 The `prepublishOnly` script runs lint, typecheck, tests, and the build before npm uploads the package. After publishing, install it with `pi install npm:@diousk/pi-subagents-fast`.
 
-Requires pi **0.84.0 or newer**: the [`SubagentWorkflow`](#subagentworkflow) tool builds on `constrainedSampling` (pi 0.82.0) and pi-tui's `stripTerminalSequences` (0.84.0). The `peerDependencies` range declares it, so npm flags an older pi at install time.
+Requires **Pi 0.99.1 or newer** and **Node.js 22.19.0 or newer**. Update Pi before installing this extension. The `peerDependencies` range declares the minimum, so npm flags an older Pi at install time.
+
+The development and CI baseline is **Pi 0.99.1**. Use that version or newer for `openai/gpt-6.1-sol` (API key) or `openai-codex/gpt-6.1-sol` (your Pi Codex login). Child sessions reuse the parent's configured providers and authentication; model limits and pricing come from Pi's provider catalog. See the [Pi 0.99.1 release](https://pi.dev/changelog/releases/0.99.1).
 
 ### Other hosts
 
@@ -337,8 +339,8 @@ All fields are optional — sensible defaults for everything.
 | `disallowed_tools` | — | Comma-separated tools to deny even if extensions provide them |
 | `isolation` | — | Set to `worktree` to run in an isolated git worktree, or `off` to refuse one even when the caller passes `isolation: "worktree"` (frontmatter is authoritative). `none`, `no`, and `false` are accepted spellings of `off` |
 | `model` | inherit parent | Model — `provider/modelId` or fuzzy name (`"haiku"`, `"sonnet"`). Resolved tolerantly (`.`/`-` and a trailing date stamp are interchangeable) and falls back to the same model under another provider if the named one doesn't have it |
-| `service_tier` | — | OpenAI Responses/Codex processing tier: `auto`, `default`, `flex`, `priority`, or `scale`. Applied only to `openai-responses` and `openai-codex-responses`; omitted preserves the provider default, and other APIs ignore it without displaying it as active |
-| `thinking` | inherit | off, minimal, low, medium, high, xhigh, max — actual availability depends on your pi version and model; pi clamps unsupported levels down |
+| `service_tier` | — | OpenAI Responses/Codex processing tier: `auto`, `default`, `flex`, `fast`, `priority`, or `scale`. Applied only to `openai-responses` and `openai-codex-responses`; omitted preserves the provider default, and other APIs ignore it without displaying it as active |
+| `thinking` | inherit | off, minimal, low, medium, high, xhigh, max — actual availability depends on your pi version and model; pi maps or clamps unsupported levels |
 | `max_turns` | unlimited | Max agentic turns before graceful shutdown. `0` or omit for unlimited |
 | `persist_session` | `subagents.json` `rememberAgents` (default `true`) | Persist this subagent as a normal pi session instead of keeping the session in memory only; overrides the `rememberAgents` project default in both directions. It records its spawning session as parent, so it nests under it in `/resume`. The subagent's `.output` transcript is still written either way unless `output_transcript: false` |
 | `output_transcript` | `true` (or `subagents.json` `outputTranscript`) | Write this subagent's `.output` transcript; when set, overrides the `subagents.json` `outputTranscript` default. Set `false` to write no transcript file or path. Governs only the transcript — independent of `persist_session`, `isolation: worktree`, and `memory:` |
@@ -350,7 +352,17 @@ All fields are optional — sensible defaults for everything.
 | `isolated` | `false` | Hermetic specialist mode: forces `extensions: false` + `skills: false` + drops `ext:` selectors. Only built-in tools. Distinct from `isolation: worktree` (filesystem) |
 | `enabled` | `true` | Set to `false` to disable an agent (useful for hiding a default agent per-project) |
 
-For an OpenAI Responses or Codex agent, set `service_tier: priority` to request priority processing. The UI shows the requested tier only when the effective model uses one of those APIs; other providers keep their normal request behavior and do not display a tier as active.
+For an OpenAI Responses or Codex agent, set `service_tier: fast` to request fast processing; `priority` remains a supported alias. Availability depends on the provider and account. The UI shows the requested tier only when the effective model uses one of those APIs. See [OpenAI fast mode](https://developers.openai.com/api/docs/guides/fast-mode).
+
+GPT-6.1 Sol supports `low`, `medium`, `high`, `xhigh`, and `max` reasoning. In Pi 0.99.1, `minimal` maps to provider effort `low`; `off` is clamped to that same alias because Sol cannot disable reasoning. The UI reports Pi's logical thinking level. Prefer explicit supported levels in agent files:
+
+```yaml
+model: openai-codex/gpt-6.1-sol
+thinking: medium
+service_tier: fast
+```
+
+Sol requires the Responses API for tool use. Selecting its Pi catalog entry chooses the corresponding Responses transport; no custom provider override is needed. See the [Sol model reference](https://developers.openai.com/api/docs/models/gpt-6.1-sol).
 
 Frontmatter is authoritative. If an agent file sets `model`, `thinking`, `service_tier`, `max_turns`, `inherit_context`, `run_in_background`, `isolated`, or `isolation`, those values are locked for that agent. For fields exposed by the `Agent` tool, its parameters only fill values the agent config leaves unspecified; `service_tier` is frontmatter-only.
 
@@ -408,6 +420,8 @@ A few rules the examples don't make obvious:
 - `extensions:` is the sole loading authority. `ext:foo` in `tools:` narrows what surfaces; it can't load `foo` on its own. Mismatches fire `extension-error:…` warnings.
 - Any `ext:` entry flips extension tools to an explicit allowlist — unnamed extensions still load (handlers fire) but expose no tools. So `tools: "*, ext:mcp/search"` exposes only `search` from `mcp`, nothing from any other extension.
 - Extension names match case-insensitively (`[Mcp]` = `[mcp]`); tool names in `ext:foo/bar` stay case-sensitive.
+- Synthetic extension identities match their logical names: `builtin:mcp` as `mcp`, `builtin:codemode` as `codemode`, and `<inline:foo>` as `foo`. This matches loaded extensions; it does not load Pi CLI built-in factories into SDK child sessions.
+- Scope checks also apply to nested `ctx.executeTool()` calls, including deferred and codemode tools. Deferred tools keep their exposure and are not automatically promoted into model declarations; extension-activated tools remain active only within the agent's scope.
 - Extensions that register tools **lazily** work too. MCP-backed extensions typically can't enumerate their tools until their servers connect, so they register from `session_start` or `before_agent_start` rather than at load. Subagent scoping is re-derived as tools appear, so these surface normally — including under `ext:` selectors, which keep narrowing correctly no matter when a tool shows up.
 - Extensions bound into a subagent see **both ends** of that session's lifecycle: `session_start` when the agent starts, `session_shutdown` (reason `quit`) when its session is disposed — on quit, and when its record is evicted ~10 minutes after it finishes. Release per-session resources there; anything left armed outlives the session it belongs to. Handlers are given three seconds on quit, after which teardown proceeds regardless.
 - An installed **package** extension matches by its package short name (`@scope/pi-subagents` → `[pi-subagents]`), in addition to its path-derived name (a package whose entry is `src/index.ts` also answers to `[src]`). Prefer the package name — the path-derived one is incidental.
@@ -667,7 +681,7 @@ Runtime tuning values set via `/agents` → Settings (max concurrency, max foreg
 
 **Report usage to session** (`reportUsage`, default `false`): whether subagent spend is added to *this* session's own totals. Subagents run in their own pi sessions, so by default pi's footer, statusline and `/cost` count only what the main model spent — a session that delegated most of its work reads as nearly free. Turn it on and each `Agent` / `get_subagent_result` / `steer_subagent` result carries the spend accumulated since the last one, which pi folds into `getSessionStats()`; `/cost` attributes it to the **Tools/summaries** bucket. Toggle via `/agents → Settings → Report usage to session`; applied live.
 
-Three things worth knowing about the numbers. Every token component is reported, `cacheRead` included — the cached prefix genuinely is re-read and re-billed on every call, and pi counts it the same way for the session's own messages, so withholding it would make a subagent's rows count differently from every other row in one total. (The extension's *own* token displays still leave it out, which is a different question: there it inflates a reading of how much work was done.) Cost is pi's own per-message figure, priced from the model's listed rates; a model pi has no rates for contributes zero rather than an estimate. And the context-window percentage is untouched: pi derives it from assistant messages alone, so a delegating session's context doesn't appear to fill up faster. Agents that finish in the background have no tool result of their own to ride on, so their spend is carried by the next one you make — the footer catches up on the following call, not the moment they finish.
+Three things worth knowing about the numbers. Every token component is reported, `cacheRead` included — the cached prefix genuinely is re-read and re-billed on every call, and pi counts it the same way for the session's own messages, so withholding it would make a subagent's rows count differently from every other row in one total. (The extension's *own* token displays still leave it out, which is a different question: there it inflates a reading of how much work was done.) Cost is pi's own per-message figure, priced from the model's listed rates; a model pi has no rates for contributes zero rather than an estimate. Reported subagent token counts do not inflate the parent's context-window percentage. On Pi 0.99.1 the tool-result text itself occupies context and is included in Pi's projection estimate. Agents that finish in the background have no tool result of their own to ride on, so their spend is carried by the next one you make — the footer catches up on the following call, not the moment they finish.
 
 **Show cost** (`showCost`, default `false`): whether the subagent surfaces print an estimated cost beside their token counts — the widget (running *and* finished lines), [FleetView](#fleetview), the conversation viewer, foreground results, `get_subagent_result`, and completion notifications:
 
@@ -696,6 +710,8 @@ Both places report what the run *actually* used, read back from the child sessio
   ↳ anthropic/claude-haiku-4-5 · thinking: low (asked max) · background
 ```
 
+For a virtual model, the displayed identity is the session's selected virtual model, rather than the physical model chosen for each response.
+
 Toggle via `/agents → Settings → Show model`; applied live.
 
 **Viewer markdown** (`viewerMarkdown`, default `"assistant"`): how much of the [conversation viewer](#ui)'s transcript is rendered as Markdown rather than shown verbatim.

package/dist/agent-runner.d.ts

@@ -85,12 +85,13 @@ export declare function parseExtSelectors(entries: string[]): {
  * snapshotted. `registerTool` writes into the very `extension.tools` maps this reads,
  * so `inScope()` sees late arrivals on the next call.
  *
- * Two enforcement points, because neither covers the whole picture:
+ * The active set and call-time checks cover different parts of scope:
  *
  *   - `turn_end` re-narrows the ACTIVE set. pi emits `turn_end` immediately before
  *     `prepareNextTurn` re-snapshots `agent.state.tools`, and session listeners run
  *     synchronously, so the narrow lands in time for turns 2..N.
- *   - `beforeToolCall` blocks out-of-scope calls. Turn 1 cannot be narrowed at all:
+ *   - The loader's bound `tool_call` handler blocks direct and nested calls.
+ *     Turn 1 cannot be narrowed at all:
  *     `before_agent_start` fires INSIDE `prompt()` and may widen the tool set, but
  *     `createContextSnapshot()` freezes that turn's tools immediately after — there
  *     is no hook in between. A call-time check is the only correct guard there.
@@ -117,7 +118,7 @@ export declare function installExtensionToolScope(session: AgentSession, ctx: {
      * seeded from `toolNames`.
      */
     readmitToolNames: Set<string>;
-}): void;
+}): (toolName: string) => boolean;
 /** Normalize max turns. undefined or 0 = unlimited, otherwise minimum 1. */
 export declare function normalizeMaxTurns(n: number | undefined): number | undefined;
 /** Get the default max turns value. undefined = unlimited. */

package/dist/agent-runner.js

@@ -68,6 +68,10 @@ export function installServiceTierPayload(session, serviceTier) {
  * single-file extensions to the basename minus `.ts`/`.js`.
  */
 export function extensionCanonicalName(extPath) {
+    if (extPath.startsWith("builtin:"))
+        return extPath.slice("builtin:".length).toLowerCase();
+    if (extPath.startsWith("<inline:") && extPath.endsWith(">"))
+        return extPath.slice(8, -1).toLowerCase();
     const base = basename(extPath);
     const name = base === "index.ts" || base === "index.js"
         ? basename(dirname(extPath))
@@ -132,6 +136,8 @@ function extensionPackageName(extPath) {
  */
 export function extensionCanonicalNames(extPath) {
     const canonical = extensionCanonicalName(extPath);
+    if (extPath.startsWith("builtin:") || extPath.startsWith("<inline:"))
+        return [canonical];
     const pkg = extensionPackageName(extPath);
     return pkg && pkg !== canonical ? [canonical, pkg] : [canonical];
 }
@@ -219,12 +225,13 @@ export function parseExtSelectors(entries) {
  * snapshotted. `registerTool` writes into the very `extension.tools` maps this reads,
  * so `inScope()` sees late arrivals on the next call.
  *
- * Two enforcement points, because neither covers the whole picture:
+ * The active set and call-time checks cover different parts of scope:
  *
  *   - `turn_end` re-narrows the ACTIVE set. pi emits `turn_end` immediately before
  *     `prepareNextTurn` re-snapshots `agent.state.tools`, and session listeners run
  *     synchronously, so the narrow lands in time for turns 2..N.
- *   - `beforeToolCall` blocks out-of-scope calls. Turn 1 cannot be narrowed at all:
+ *   - The loader's bound `tool_call` handler blocks direct and nested calls.
+ *     Turn 1 cannot be narrowed at all:
  *     `before_agent_start` fires INSIDE `prompt()` and may widen the tool set, but
  *     `createContextSnapshot()` freezes that turn's tools immediately after — there
  *     is no hook in between. A call-time check is the only correct guard there.
@@ -263,7 +270,7 @@ export function installExtensionToolScope(session, ctx) {
         for (const name of EXCLUDED_TOOL_NAMES)
             keep.delete(name);
         // Injected tools are legitimately active for this agent — re-admit them so
-        // the renarrow keeps them in the active set and beforeToolCall doesn't
+        // the renarrow keeps them in the active set and the call-time guard doesn't
         // block them. Already vetted against `disallowed_tools` by the caller,
         // which is the only place that knows which kind may be taken back.
         for (const name of readmitToolNames)
@@ -272,8 +279,10 @@ export function installExtensionToolScope(session, ctx) {
     };
     const renarrow = () => {
         const allowed = inScope();
-        const next = session.getAllTools().map((t) => t.name).filter((n) => allowed.has(n));
         const current = session.getActiveToolNames();
+        // Keep deferred/codemode tools callable without promoting them into model
+        // declarations. Explicit activation by an extension is preserved in scope.
+        const next = session.getAllTools().filter((tool) => allowed.has(tool.name) && (tool.exposure === "direct" || tool.exposure === "model-only" || current.includes(tool.name))).map((tool) => tool.name);
         // setActiveToolsByName unconditionally rebuilds the system prompt, so skip
         // the no-op that steady-state turns would otherwise pay for every turn.
         if (next.length !== current.length || next.some((n, i) => n !== current[i])) {
@@ -287,16 +296,7 @@ export function installExtensionToolScope(session, ctx) {
         if (event.type === "turn_end")
             renarrow();
     });
-    const priorBeforeToolCall = session.agent.beforeToolCall;
-    session.agent.beforeToolCall = async (context, signal) => {
-        if (!inScope().has(context.toolCall.name)) {
-            return {
-                block: true,
-                reason: `Tool "${context.toolCall.name}" is not available to this subagent.`,
-            };
-        }
-        return priorBeforeToolCall?.(context, signal);
-    };
+    return (toolName) => inScope().has(toolName);
 }
 /** Default max turns. undefined = unlimited (no turn limit). */
 let defaultMaxTurns;
@@ -557,6 +557,7 @@ export async function runAgent(ctx, type, prompt, options) {
     // must compare against this, not the surviving set (absence from survivors is
     // an exclude *succeeding*).
     let discoveredNames;
+    let toolInScope;
     const extensionsOverride = noExtensions || (loadAll && !hasExcludes)
         ? undefined
         : (base) => {
@@ -564,6 +565,8 @@ export async function runAgent(ctx, type, prompt, options) {
             return {
                 ...base,
                 extensions: base.extensions.filter((e) => {
+                    if (e.path === "<inline:subagent-tool-scope>")
+                        return true;
                     const canons = extensionCanonicalNames(e.path);
                     if (canons.some((n) => excludeNames.has(n)))
                         return false; // exclude wins
@@ -576,6 +579,19 @@ export async function runAgent(ctx, type, prompt, options) {
         agentDir,
         noExtensions,
         additionalExtensionPaths,
+        // Pi's nested ctx.executeTool calls dispatch tool_call directly, and prompt
+        // setup can replace agent.beforeToolCall. Enforce scope in that dispatch too.
+        extensionFactories: noExtensions ? [] : [{
+                name: "subagent-tool-scope",
+                hidden: true,
+                factory: (pi) => {
+                    pi.on("tool_call", (event) => {
+                        if (toolInScope && !toolInScope(event.toolName)) {
+                            return { block: true, reason: `Tool "${event.toolName}" is not available to this subagent.` };
+                        }
+                    });
+                },
+            }],
         extensionsOverride,
         noSkills,
         noPromptTemplates: true,
@@ -786,21 +802,14 @@ export async function runAgent(ctx, type, prompt, options) {
                 parentSession: ctx.sessionManager?.getSessionFile?.(),
             })
             : SessionManager.inMemory(effectiveCwd);
-    // Pi 0.80.8 replaced createAgentSession's modelRegistry option with
-    // modelRuntime, but ExtensionContext still exposes only the registry facade.
-    // Pass both so the full supported Pi range retains the parent's providers.
+    // ExtensionContext exposes the registry facade; its runtime owns provider auth.
     const parentModelRuntime = ctx.modelRegistry.runtime;
     const sessionOpts = {
         cwd: effectiveCwd,
         agentDir,
         sessionManager,
         settingsManager,
-        modelRegistry: ctx.modelRegistry,
-        // `as never` is what keeps this assignable across the supported Pi range:
-        // pre-0.80.8 the field exists only via the `modelRuntime?: unknown` shim
-        // above, while newer Pi types it as `ModelRuntime` — a shape an opaque
-        // `unknown` read off the private facade field can never satisfy.
-        ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime }),
+        modelRuntime: parentModelRuntime,
         model,
         tools: sessionTools,
         customTools: [...nestedTools, ...structuredTools],
@@ -835,7 +844,7 @@ export async function runAgent(ctx, type, prompt, options) {
     // handled below by re-deriving scope from the loader's live extension maps —
     // `registerTool` writes into those same maps, so late arrivals are judged too.
     if (!noExtensions) {
-        installExtensionToolScope(session, {
+        toolInScope = installExtensionToolScope(session, {
             loader,
             toolNames,
             disallowedSet,

package/dist/custom-agents.js

@@ -278,7 +278,7 @@ function parseMemory(val) {
 }
 /** Parse the OpenAI Responses/Codex `service_tier` frontmatter field. */
 function parseServiceTier(val) {
-    if (val === "auto" || val === "default" || val === "flex" || val === "priority" || val === "scale") {
+    if (val === "auto" || val === "default" || val === "flex" || val === "fast" || val === "priority" || val === "scale") {
         return val;
     }
     return undefined;

package/dist/mention-clone.d.ts

@@ -24,20 +24,6 @@
  * conversation with nothing in it yet clones to nothing in it yet, which is the
  * correct answer rather than a failure.
  *
- * It is also the oldest of the equivalent Pi APIs — `buildContextEntries` on
- * ReadonlySessionManager and the `sessionEntryToContextMessages` export both
- * arrived in 0.80.5 — where this one has been exported unchanged from before
- * the declared peer floor, and is the same code path (`byId` is only an index
- * cache, so passing it or not cannot change the result). Keeping the floor
- * honest costs nothing here: see the `compat-floor-pi` job.
- *
- * Its `thinkingLevel` is NOT used, and is the one place the newer API would be
- * better. `getSessionContextSettings` starts at "off" and moves only on an
- * explicit `thinking_level_change` entry, so a session where nobody ran
- * `/think` reports "off" rather than the level it is really using. Omitting the
- * field instead lets `createAgentSession` resolve it from settings, which is
- * that real level.
- *
  * Three details make the spawn belong to the real session rather than the
  * clone:
  *

package/dist/mention-clone.js

@@ -24,20 +24,6 @@
  * conversation with nothing in it yet clones to nothing in it yet, which is the
  * correct answer rather than a failure.
  *
- * It is also the oldest of the equivalent Pi APIs — `buildContextEntries` on
- * ReadonlySessionManager and the `sessionEntryToContextMessages` export both
- * arrived in 0.80.5 — where this one has been exported unchanged from before
- * the declared peer floor, and is the same code path (`byId` is only an index
- * cache, so passing it or not cannot change the result). Keeping the floor
- * honest costs nothing here: see the `compat-floor-pi` job.
- *
- * Its `thinkingLevel` is NOT used, and is the one place the newer API would be
- * better. `getSessionContextSettings` starts at "off" and moves only on an
- * explicit `thinking_level_change` entry, so a session where nobody ran
- * `/think` reports "off" rather than the level it is really using. Omitting the
- * field instead lets `createAgentSession` resolve it from settings, which is
- * that real level.
- *
  * Three details make the spawn belong to the real session rather than the
  * clone:
  *
@@ -60,7 +46,7 @@
  * The clone gets one tool and one job. It cannot read, write or run anything —
  * an invisible turn with the full toolset could do invisible work.
  */
-import { buildSessionContext, createAgentSession, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { buildSessionContext, convertToLlm, createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { runInChildSessionContext } from "./child-context.js";
 import { agentMentionReminder } from "./mention.js";
 /**
@@ -90,31 +76,51 @@ export async function runMentionClone(opts) {
             // false, and a foreground agent answers through its TOOL RESULT — which
             // here is delivered into a session that is disposed moments later, so the
             // agent would run, appear in the widget and the fleet, and reach nobody.
-            return agentTool.execute(undefined, { ...params, run_in_background: true }, signal, onUpdate, ctx);
+            return agentTool.execute(undefined, { ...params, run_in_background: true }, signal, onUpdate, { ..._cloneCtx, ...ctx });
         },
     };
     let session;
     try {
-        // Pi 0.80.8 moved createAgentSession from modelRegistry to modelRuntime;
-        // agent-runner.ts carries the same shim for the same reason — pass both so
-        // the clone keeps the parent's providers across the supported range.
+        // The registry facade retains the parent's configured runtime and auth.
         const parentModelRuntime = ctx.modelRegistry.runtime;
         // The conversation as the main session resolves it: compaction applied,
         // branch summaries substituted.
         const conversation = buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId());
-        // Pi 0.82.0 added this; below it the field is absent and the clone takes
-        // the settings level instead, which is what a session that never ran
-        // `/think` is on anyway. Same shim shape as `modelRuntime` below.
-        const thinkingLevel = ctx.thinkingLevel;
+        const sessionManager = SessionManager.inMemory(ctx.cwd);
+        // Replay conversation turns through the session manager. Historical system
+        // messages contain the parent's tool declarations, which the clone must not inherit.
+        for (const entry of conversation.messages) {
+            if (entry.role === "system")
+                continue;
+            if (entry.role === "branchSummary" || entry.role === "compactionSummary") {
+                for (const message of convertToLlm([entry]))
+                    sessionManager.appendMessage(message);
+            }
+            else {
+                sessionManager.appendMessage(entry);
+            }
+        }
+        const resourceLoader = new DefaultResourceLoader({
+            cwd: ctx.cwd,
+            agentDir: getAgentDir(),
+            noExtensions: true,
+            noSkills: true,
+            noPromptTemplates: true,
+            noThemes: true,
+            noContextFiles: true,
+            systemPromptOverride: () => ctx.getSystemPrompt(),
+            appendSystemPromptOverride: () => [],
+        });
+        await resourceLoader.reload();
         const created = await runInChildSessionContext(() => createAgentSession({
             cwd: ctx.cwd,
             // Nothing about the copy is worth persisting, and an in-memory manager
             // is also what keeps the real session untouched.
-            sessionManager: SessionManager.inMemory(ctx.cwd),
+            sessionManager,
+            resourceLoader,
             model: ctx.model,
-            ...(thinkingLevel && { thinkingLevel }),
-            modelRegistry: ctx.modelRegistry,
-            ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime }),
+            ...(ctx.thinkingLevel && { thinkingLevel: ctx.thinkingLevel }),
+            modelRuntime: parentModelRuntime,
             // An allowlist naming exactly the clone's own tool. NOT `noTools:
             // "all"`, whose doc comment ("start with no tools enabled") reads like
             // it spares custom tools and does not: it resolves to an EMPTY
@@ -127,16 +133,6 @@ export async function runMentionClone(opts) {
             customTools: [cloneAgentTool],
         }));
         session = created.session;
-        // The clone rebuilds a system prompt from cwd and agentDir, which is close
-        // but not the live one — extensions contribute to it per turn. Copy the
-        // real thing, so the copy reasons under the instructions the user's model
-        // is actually working under.
-        const systemPrompt = ctx.getSystemPrompt?.();
-        if (systemPrompt)
-            session.agent.state.systemPrompt = systemPrompt;
-        // The conversation itself. Pushed rather than assigned so the array the
-        // session was built around stays the one it goes on using.
-        session.agent.state.messages.push(...conversation.messages);
         // User text first, reminder after — the order Claude Code's attachment
         // renderer produces, where the reminder trails the message it is about.
         await session.prompt(`${message}\n\n${agentMentionReminder(type)}`);

package/dist/output-file.js

@@ -91,20 +91,26 @@ export function writeInitialEntry(path, agentId, prompt, cwd) {
  * Returns a cleanup function that does a final flush and unsubscribes.
  */
 export function streamToOutputFile(session, path, agentId, cwd, startIndex) {
-    // Index of the first message this stream is responsible for. A spawn writes
-    // messages[0] as the initial prompt entry, so it starts at 1. A resume hands
+    // A spawn writes its initial user prompt separately. Pi can project system
+    // messages before that prompt, so skip the first user message by role. A resume hands
     // in the session's length as of just before the run: the session already
     // holds every prior turn, and re-emitting those would duplicate history that
     // is already in the file.
-    let writtenCount = startIndex ?? 1;
+    let writtenCount = startIndex ?? 0;
+    let skipInitialUser = startIndex === undefined;
     const flush = () => {
         const messages = session.messages;
         while (writtenCount < messages.length) {
             const msg = messages[writtenCount];
+            if (skipInitialUser && msg.role === "user") {
+                skipInitialUser = false;
+                writtenCount++;
+                continue;
+            }
             const entry = {
                 isSidechain: true,
                 agentId,
-                type: msg.role === "assistant" ? "assistant" : msg.role === "user" ? "user" : "toolResult",
+                type: msg.role === "assistant" ? "assistant" : msg.role === "user" ? "user" : msg.role === "system" ? "system" : "toolResult",
                 message: msg,
                 timestamp: new Date().toISOString(),
                 cwd,

package/dist/types.d.ts

@@ -12,7 +12,7 @@ export declare const DEFAULT_AGENT_NAMES: readonly ["general-purpose", "Explore"
 /** Memory scope for persistent agent memory. */
 export type MemoryScope = "user" | "project" | "local";
 /** OpenAI Responses/Codex request processing tier. */
-export type ServiceTier = "auto" | "default" | "flex" | "priority" | "scale";
+export type ServiceTier = "auto" | "default" | "flex" | "fast" | "priority" | "scale";
 /**
  * Isolation mode for agent execution.
  *

package/docs/workflows.md

@@ -250,6 +250,8 @@ Any other key is rejected **by name** at the call. Note that this checks option
 
 Combination rules: `resume` cannot be combined with `agentType`, `model`, `effort`, `isolation`, `gate` or `schema` — a resumed child keeps the agent type, model and tree it was started with, and its session predates the `StructuredOutput` tool.
 
+With Pi 0.99.1, select Sol with `model: "openai-codex/gpt-6.1-sol"` (Pi's Codex login) or `model: "openai/gpt-6.1-sol"` (API key). Use `effort: "low"`, `"medium"`, `"high"`, `"xhigh"`, or `"max"`; Pi maps `minimal` to provider effort `low`. A custom `agentType` can pin `service_tier: fast` in its agent file; `service_tier` is not a workflow option. See the [README's model reference](../README.md#frontmatter-fields).
+
 ### `pipeline()` and `parallel()`
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diousk/pi-subagents-fast",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "A pi extension that brings Claude Code-like sub-agents and workflow orchestration to pi — parallel execution, live widget, fleet view, custom agent types, mid-run steering, dynamic workflows, Claude Code compatibility, look and feel.",
   "author": "tintinweb",
   "license": "MIT",
@@ -24,9 +24,9 @@
     "autonomous"
   ],
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.84.0",
-    "@earendil-works/pi-coding-agent": ">=0.84.0",
-    "@earendil-works/pi-tui": ">=0.84.0"
+    "@earendil-works/pi-ai": ">=0.99.1",
+    "@earendil-works/pi-coding-agent": ">=0.99.1",
+    "@earendil-works/pi-tui": ">=0.99.1"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.49",
@@ -50,9 +50,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.14",
-    "@earendil-works/pi-ai": "0.84.2",
-    "@earendil-works/pi-coding-agent": "0.84.2",
-    "@earendil-works/pi-tui": "0.84.2",
+    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "@types/node": "^25.5.0",
     "@vitest/coverage-istanbul": "^4.1.10",
     "typescript": "^6.0.0",

package/src/agent-runner.ts

@@ -14,6 +14,7 @@ import {
   DefaultResourceLoader,
   type ExtensionAPI,
   getAgentDir,
+  type ModelRuntime,
   SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
@@ -94,6 +95,8 @@ export function installServiceTierPayload(
  * single-file extensions to the basename minus `.ts`/`.js`.
  */
 export function extensionCanonicalName(extPath: string): string {
+  if (extPath.startsWith("builtin:")) return extPath.slice("builtin:".length).toLowerCase();
+  if (extPath.startsWith("<inline:") && extPath.endsWith(">")) return extPath.slice(8, -1).toLowerCase();
   const base = basename(extPath);
   const name = base === "index.ts" || base === "index.js"
     ? basename(dirname(extPath))
@@ -159,6 +162,7 @@ function extensionPackageName(extPath: string): string | undefined {
  */
 export function extensionCanonicalNames(extPath: string): string[] {
   const canonical = extensionCanonicalName(extPath);
+  if (extPath.startsWith("builtin:") || extPath.startsWith("<inline:")) return [canonical];
   const pkg = extensionPackageName(extPath);
   return pkg && pkg !== canonical ? [canonical, pkg] : [canonical];
 }
@@ -250,12 +254,13 @@ export function parseExtSelectors(entries: string[]): {
  * snapshotted. `registerTool` writes into the very `extension.tools` maps this reads,
  * so `inScope()` sees late arrivals on the next call.
  *
- * Two enforcement points, because neither covers the whole picture:
+ * The active set and call-time checks cover different parts of scope:
  *
  *   - `turn_end` re-narrows the ACTIVE set. pi emits `turn_end` immediately before
  *     `prepareNextTurn` re-snapshots `agent.state.tools`, and session listeners run
  *     synchronously, so the narrow lands in time for turns 2..N.
- *   - `beforeToolCall` blocks out-of-scope calls. Turn 1 cannot be narrowed at all:
+ *   - The loader's bound `tool_call` handler blocks direct and nested calls.
+ *     Turn 1 cannot be narrowed at all:
  *     `before_agent_start` fires INSIDE `prompt()` and may widen the tool set, but
  *     `createContextSnapshot()` freezes that turn's tools immediately after — there
  *     is no hook in between. A call-time check is the only correct guard there.
@@ -285,7 +290,7 @@ export function installExtensionToolScope(
      */
     readmitToolNames: Set<string>;
   },
-): void {
+): (toolName: string) => boolean {
   const { loader, toolNames, disallowedSet, extNames, narrowing, readmitToolNames } = ctx;
 
   // The names allowed right now. Mirrors the `ext:` opt-in flip: when any `ext:`
@@ -309,7 +314,7 @@ export function installExtensionToolScope(
     }
     for (const name of EXCLUDED_TOOL_NAMES) keep.delete(name);
     // Injected tools are legitimately active for this agent — re-admit them so
-    // the renarrow keeps them in the active set and beforeToolCall doesn't
+    // the renarrow keeps them in the active set and the call-time guard doesn't
     // block them. Already vetted against `disallowed_tools` by the caller,
     // which is the only place that knows which kind may be taken back.
     for (const name of readmitToolNames) keep.add(name);
@@ -318,8 +323,14 @@ export function installExtensionToolScope(
 
   const renarrow = () => {
     const allowed = inScope();
-    const next = session.getAllTools().map((t) => t.name).filter((n) => allowed.has(n));
     const current = session.getActiveToolNames();
+    // Keep deferred/codemode tools callable without promoting them into model
+    // declarations. Explicit activation by an extension is preserved in scope.
+    const next = session.getAllTools().filter((tool) =>
+      allowed.has(tool.name) && (
+        tool.exposure === "direct" || tool.exposure === "model-only" || current.includes(tool.name)
+      ),
+    ).map((tool) => tool.name);
     // setActiveToolsByName unconditionally rebuilds the system prompt, so skip
     // the no-op that steady-state turns would otherwise pay for every turn.
     if (next.length !== current.length || next.some((n, i) => n !== current[i])) {
@@ -335,16 +346,7 @@ export function installExtensionToolScope(
     if (event.type === "turn_end") renarrow();
   });
 
-  const priorBeforeToolCall = session.agent.beforeToolCall;
-  session.agent.beforeToolCall = async (context, signal) => {
-    if (!inScope().has(context.toolCall.name)) {
-      return {
-        block: true,
-        reason: `Tool "${context.toolCall.name}" is not available to this subagent.`,
-      };
-    }
-    return priorBeforeToolCall?.(context, signal);
-  };
+  return (toolName) => inScope().has(toolName);
 }
 
 /** Default max turns. undefined = unlimited (no turn limit). */
@@ -768,6 +770,7 @@ export async function runAgent(
   // must compare against this, not the surviving set (absence from survivors is
   // an exclude *succeeding*).
   let discoveredNames: Set<string> | undefined;
+  let toolInScope: ((toolName: string) => boolean) | undefined;
   const extensionsOverride: ((base: LoadExtensionsResult) => LoadExtensionsResult) | undefined =
     noExtensions || (loadAll && !hasExcludes)
       ? undefined
@@ -776,6 +779,7 @@ export async function runAgent(
           return {
             ...base,
             extensions: base.extensions.filter((e) => {
+              if (e.path === "<inline:subagent-tool-scope>") return true;
               const canons = extensionCanonicalNames(e.path);
               if (canons.some((n) => excludeNames.has(n))) return false; // exclude wins
               return loadAll || canons.some((n) => keepNames.has(n));
@@ -788,6 +792,19 @@ export async function runAgent(
     agentDir,
     noExtensions,
     additionalExtensionPaths,
+    // Pi's nested ctx.executeTool calls dispatch tool_call directly, and prompt
+    // setup can replace agent.beforeToolCall. Enforce scope in that dispatch too.
+    extensionFactories: noExtensions ? [] : [{
+      name: "subagent-tool-scope",
+      hidden: true,
+      factory: (pi) => {
+        pi.on("tool_call", (event) => {
+          if (toolInScope && !toolInScope(event.toolName)) {
+            return { block: true, reason: `Tool "${event.toolName}" is not available to this subagent.` };
+          }
+        });
+      },
+    }],
     extensionsOverride,
     noSkills,
     noPromptTemplates: true,
@@ -1014,24 +1031,14 @@ export async function runAgent(
         })
       : SessionManager.inMemory(effectiveCwd);
 
-  // Pi 0.80.8 replaced createAgentSession's modelRegistry option with
-  // modelRuntime, but ExtensionContext still exposes only the registry facade.
-  // Pass both so the full supported Pi range retains the parent's providers.
-  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: unknown }).runtime;
-  const sessionOpts: Parameters<typeof createAgentSession>[0] & {
-    modelRegistry: ExtensionContext["modelRegistry"];
-    modelRuntime?: unknown;
-  } = {
+  // ExtensionContext exposes the registry facade; its runtime owns provider auth.
+  const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: ModelRuntime }).runtime;
+  const sessionOpts: Parameters<typeof createAgentSession>[0] = {
     cwd: effectiveCwd,
     agentDir,
     sessionManager,
     settingsManager,
-    modelRegistry: ctx.modelRegistry,
-    // `as never` is what keeps this assignable across the supported Pi range:
-    // pre-0.80.8 the field exists only via the `modelRuntime?: unknown` shim
-    // above, while newer Pi types it as `ModelRuntime` — a shape an opaque
-    // `unknown` read off the private facade field can never satisfy.
-    ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime as never }),
+    modelRuntime: parentModelRuntime,
     model,
     tools: sessionTools,
     customTools: [...nestedTools, ...structuredTools],
@@ -1073,7 +1080,7 @@ export async function runAgent(
   // handled below by re-deriving scope from the loader's live extension maps —
   // `registerTool` writes into those same maps, so late arrivals are judged too.
   if (!noExtensions) {
-    installExtensionToolScope(session, {
+    toolInScope = installExtensionToolScope(session, {
       loader,
       toolNames,
       disallowedSet,

package/src/custom-agents.ts

@@ -297,7 +297,7 @@ function parseMemory(val: unknown): MemoryScope | undefined {
 
 /** Parse the OpenAI Responses/Codex `service_tier` frontmatter field. */
 function parseServiceTier(val: unknown): ServiceTier | undefined {
-  if (val === "auto" || val === "default" || val === "flex" || val === "priority" || val === "scale") {
+  if (val === "auto" || val === "default" || val === "flex" || val === "fast" || val === "priority" || val === "scale") {
     return val;
   }
   return undefined;

package/src/mention-clone.ts

@@ -24,20 +24,6 @@
  * conversation with nothing in it yet clones to nothing in it yet, which is the
  * correct answer rather than a failure.
  *
- * It is also the oldest of the equivalent Pi APIs — `buildContextEntries` on
- * ReadonlySessionManager and the `sessionEntryToContextMessages` export both
- * arrived in 0.80.5 — where this one has been exported unchanged from before
- * the declared peer floor, and is the same code path (`byId` is only an index
- * cache, so passing it or not cannot change the result). Keeping the floor
- * honest costs nothing here: see the `compat-floor-pi` job.
- *
- * Its `thinkingLevel` is NOT used, and is the one place the newer API would be
- * better. `getSessionContextSettings` starts at "off" and moves only on an
- * explicit `thinking_level_change` entry, so a session where nobody ran
- * `/think` reports "off" rather than the level it is really using. Omitting the
- * field instead lets `createAgentSession` resolve it from settings, which is
- * that real level.
- *
  * Three details make the spawn belong to the real session rather than the
  * clone:
  *
@@ -64,14 +50,18 @@
 import type { Model } from "@earendil-works/pi-ai";
 import {
   buildSessionContext,
+  convertToLlm,
   createAgentSession,
+  DefaultResourceLoader,
   type ExtensionContext,
+  getAgentDir,
+  type ModelRuntime,
   SessionManager,
   type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { runInChildSessionContext } from "./child-context.js";
 import { agentMentionReminder } from "./mention.js";
-import type { SubagentType, ThinkingLevel } from "./types.js";
+import type { SubagentType } from "./types.js";
 
 export interface MentionCloneOptions {
   /** The MAIN session's context — what the spawn is attributed to, and the
@@ -125,37 +115,54 @@ export async function runMentionClone(opts: MentionCloneOptions): Promise<Mentio
         { ...(params as Record<string, unknown>), run_in_background: true } as typeof params,
         signal,
         onUpdate,
-        ctx,
+        { ..._cloneCtx, ...ctx },
       );
     },
   };
 
   let session: Awaited<ReturnType<typeof createAgentSession>>["session"] | undefined;
   try {
-    // Pi 0.80.8 moved createAgentSession from modelRegistry to modelRuntime;
-    // agent-runner.ts carries the same shim for the same reason — pass both so
-    // the clone keeps the parent's providers across the supported range.
-    const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: unknown }).runtime;
+    // The registry facade retains the parent's configured runtime and auth.
+    const parentModelRuntime = (ctx.modelRegistry as unknown as { runtime?: ModelRuntime }).runtime;
     // The conversation as the main session resolves it: compaction applied,
     // branch summaries substituted.
     const conversation = buildSessionContext(
       ctx.sessionManager.getEntries(),
       ctx.sessionManager.getLeafId(),
     );
-    // Pi 0.82.0 added this; below it the field is absent and the clone takes
-    // the settings level instead, which is what a session that never ran
-    // `/think` is on anyway. Same shim shape as `modelRuntime` below.
-    const thinkingLevel = (ctx as { thinkingLevel?: ThinkingLevel }).thinkingLevel;
+    const sessionManager = SessionManager.inMemory(ctx.cwd);
+    // Replay conversation turns through the session manager. Historical system
+    // messages contain the parent's tool declarations, which the clone must not inherit.
+    for (const entry of conversation.messages) {
+      if (entry.role === "system") continue;
+      if (entry.role === "branchSummary" || entry.role === "compactionSummary") {
+        for (const message of convertToLlm([entry])) sessionManager.appendMessage(message);
+      } else {
+        sessionManager.appendMessage(entry);
+      }
+    }
+    const resourceLoader = new DefaultResourceLoader({
+      cwd: ctx.cwd,
+      agentDir: getAgentDir(),
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      systemPromptOverride: () => ctx.getSystemPrompt(),
+      appendSystemPromptOverride: () => [],
+    });
+    await resourceLoader.reload();
     const created = await runInChildSessionContext(() =>
       createAgentSession({
         cwd: ctx.cwd,
         // Nothing about the copy is worth persisting, and an in-memory manager
         // is also what keeps the real session untouched.
-        sessionManager: SessionManager.inMemory(ctx.cwd),
+        sessionManager,
+        resourceLoader,
         model: ctx.model as Model<never> | undefined,
-        ...(thinkingLevel && { thinkingLevel }),
-        modelRegistry: ctx.modelRegistry,
-        ...(parentModelRuntime !== undefined && { modelRuntime: parentModelRuntime as never }),
+        ...(ctx.thinkingLevel && { thinkingLevel: ctx.thinkingLevel }),
+        modelRuntime: parentModelRuntime,
         // An allowlist naming exactly the clone's own tool. NOT `noTools:
         // "all"`, whose doc comment ("start with no tools enabled") reads like
         // it spares custom tools and does not: it resolves to an EMPTY
@@ -166,21 +173,10 @@ export async function runMentionClone(opts: MentionCloneOptions): Promise<Mentio
         // agent-runner's `tools: sessionTools` beside its nested `customTools`.
         tools: [cloneAgentTool.name],
         customTools: [cloneAgentTool],
-      } as Parameters<typeof createAgentSession>[0]),
+      }),
     );
     session = created.session;
 
-    // The clone rebuilds a system prompt from cwd and agentDir, which is close
-    // but not the live one — extensions contribute to it per turn. Copy the
-    // real thing, so the copy reasons under the instructions the user's model
-    // is actually working under.
-    const systemPrompt = ctx.getSystemPrompt?.();
-    if (systemPrompt) session.agent.state.systemPrompt = systemPrompt;
-
-    // The conversation itself. Pushed rather than assigned so the array the
-    // session was built around stays the one it goes on using.
-    session.agent.state.messages.push(...conversation.messages);
-
     // User text first, reminder after — the order Claude Code's attachment
     // renderer produces, where the reminder trails the message it is about.
     await session.prompt(`${message}\n\n${agentMentionReminder(type)}`);

package/src/output-file.ts

@@ -104,21 +104,27 @@ export function streamToOutputFile(
   cwd: string,
   startIndex?: number,
 ): () => void {
-  // Index of the first message this stream is responsible for. A spawn writes
-  // messages[0] as the initial prompt entry, so it starts at 1. A resume hands
+  // A spawn writes its initial user prompt separately. Pi can project system
+  // messages before that prompt, so skip the first user message by role. A resume hands
   // in the session's length as of just before the run: the session already
   // holds every prior turn, and re-emitting those would duplicate history that
   // is already in the file.
-  let writtenCount = startIndex ?? 1;
+  let writtenCount = startIndex ?? 0;
+  let skipInitialUser = startIndex === undefined;
 
   const flush = () => {
     const messages = session.messages;
     while (writtenCount < messages.length) {
       const msg = messages[writtenCount];
+      if (skipInitialUser && msg.role === "user") {
+        skipInitialUser = false;
+        writtenCount++;
+        continue;
+      }
       const entry = {
         isSidechain: true,
         agentId,
-        type: msg.role === "assistant" ? "assistant" : msg.role === "user" ? "user" : "toolResult",
+        type: msg.role === "assistant" ? "assistant" : msg.role === "user" ? "user" : msg.role === "system" ? "system" : "toolResult",
         message: msg,
         timestamp: new Date().toISOString(),
         cwd,

package/src/types.ts

@@ -18,7 +18,7 @@ export const DEFAULT_AGENT_NAMES = ["general-purpose", "Explore", "Plan"] as con
 export type MemoryScope = "user" | "project" | "local";
 
 /** OpenAI Responses/Codex request processing tier. */
-export type ServiceTier = "auto" | "default" | "flex" | "priority" | "scale";
+export type ServiceTier = "auto" | "default" | "flex" | "fast" | "priority" | "scale";
 
 /**
  * Isolation mode for agent execution.

package/vitest.config.mts

@@ -0,0 +1,47 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  // The print-mode e2e suite (test/subagents-print-mode-e2e.test.ts) drives REAL
+  // faux-model turns through pi-coding-agent + pi-agent-core. That requires ONE
+  // shared @earendil-works/pi-ai instance so the faux provider the test registers
+  // lands in the same api-registry the session streams through. npm physically
+  // duplicates pi-ai (a top-level copy and one nested under pi-coding-agent), which
+  // otherwise yields two registries and "No API provider registered" errors.
+  // Inlining the @earendil-works packages routes them through Vite's resolver so
+  // dedupe can collapse pi-ai to a single instance — for the parent AND for every
+  // subagent session the extension spawns. dedupe alone is insufficient (it only
+  // affects modules Vite resolves; without inline the runtime stays externalized).
+  test: {
+    server: { deps: { inline: [/@earendil-works\/pi-/] } },
+    // Local reporting only — deliberately no `thresholds`, and not wired into
+    // CI. src/index.ts is mostly the /agents wizard, which is TUI flow with
+    // almost no logic and is not worth a fake-TUI harness; any global floor
+    // would therefore either sit below what the rest of the suite achieves
+    // (and ratchet down as tests are deleted) or force exactly that harness.
+    // Coverage here measures lines touched, not behavior pinned.
+    //
+    // `istanbul`, NOT the `v8` default. v8 under-reports badly on this suite:
+    // `src/env.ts` came out at 54.54% for the full run but 90.9% for
+    // `vitest run --coverage test/env.test.ts` — coverage cannot fall as more
+    // tests run. Bisecting pins it on test/subagents-print-mode-e2e.test.ts,
+    // which boots a REAL pi session; pi's own resource loader re-loads the
+    // extension and its imports, so the same source file appears to v8 twice —
+    // once executed, once barely — and the merge takes the wrong one rather
+    // than the union. The damage was not confined to env.ts: v8 also reported
+    // module-level `const` declarations in src/settings.ts as uncovered, which
+    // is impossible since they run on import.
+    //
+    // istanbul instruments at transform time and accumulates per source path,
+    // so a second load adds to the same counters instead of shadowing them.
+    // Same suite, same run: v8 68.6% vs istanbul 76.5% statements, and the
+    // per-file numbers now match what a single-file run reports. If you switch
+    // this back to v8, re-check env.ts against `--coverage test/env.test.ts`
+    // before trusting anything the table says.
+    coverage: {
+      provider: "istanbul",
+      reporter: ["text", "html"],
+      include: ["src/**/*.ts"],
+    },
+  },
+  resolve: { dedupe: ["@earendil-works/pi-ai"] },
+});