@monotykamary/pi-better-openai 0.2.7 → 0.2.8

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.2.8
+
+- Add GPT-6.1 Sol fallback metadata and Fast support for the GPT-6 model family.
+- Add `/openai-tier` for Standard, Fast, and capability-gated API Astra Ultrafast, with explicit pricing warnings, persistence, diagnostics, and footer labels.
+- Add opt-in `openai_decide` and `/openai-decisions` through Pi's classifier API, with typed validation, cancellation, safe errors, and usage accounting.
+- Include classifier tool usage in footer totals and preserve legacy Fast settings and customized model lists.
+- Document remaining native OpenAI Decisions, Codex subscription Ultrafast, and hosted multi-agent integration gates; no undocumented endpoint or chat fallback is assumed.
+
+## 0.2.7
+
+- Validate against Pi 0.99.0, including an offline real-host package-loading probe.
+- Declare imported host packages as wildcard peers and pin development dependencies to Pi 0.99.0.

package/README.md

@@ -30,8 +30,9 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 
 ## Features
 
-- GPT-6 Astra and Daybreak Blue/Red model fallbacks for the built-in `openai-codex` provider.
-- Fast mode for supported OpenAI models, toggled with `/fast` or in `/openai-settings`.
+- GPT-6.1 Sol, GPT-6 Astra, and Daybreak Blue/Red model fallbacks for the built-in `openai-codex` provider.
+- Standard, Fast, and capability-gated Ultrafast service tiers via `/openai-tier` or `/openai-settings`; `/fast` remains a quick Fast toggle.
+- Opt-in typed decisions through `openai_decide`, using an explicitly selected Pi classifier provider (including Jev). Native OpenAI Decisions remains gated on a published adapter.
 - OpenAI subscription usage display via `/openai-usage` and the footer.
 - Interactive settings picker via `/openai-settings`.
 - Footer customization for model, thinking, fast mode, usage, and token/cost context.
@@ -40,7 +41,9 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 - Codex-backed realtime voice through `/live`, with an animated microphone waveform and coding-task delegation into the active pi session.
 - Animated Codex custom pets rendered in the Better OpenAI footer.
 - Commands:
-  - `/fast` toggles fast mode.
+  - `/fast` toggles Fast and Standard; it never enables Ultrafast.
+  - `/openai-tier [standard|fast|ultrafast]` shows or selects the requested service tier.
+  - `/openai-decisions [models|use provider/model|off]` inspects or configures typed decisions.
   - `/openai-image <prompt>` generates an image directly.
   - `/openai-websearch <query>` searches the web and inserts the cited answer into the session.
   - `/live` starts or stops realtime voice mode. `Ctrl+Shift+L` is the keyboard toggle.
@@ -72,7 +75,14 @@ Default supported models:
 [
   "openai/gpt-5.4",
   "openai/gpt-5.5",
+  "openai/gpt-6-astra",
+  "openai/gpt-6.1-sol",
+  "openai/gpt-6-sol",
+  "openai/gpt-6-luna",
   "openai-codex/gpt-6-astra",
+  "openai-codex/gpt-6.1-sol",
+  "openai-codex/gpt-6-sol",
+  "openai-codex/gpt-6-luna",
   "openai-codex/gpt-5.6-sol",
   "openai-codex/gpt-5.6-terra",
   "openai-codex/gpt-5.6-luna",
@@ -87,8 +97,12 @@ Example config:
 {
   "persistState": true,
   "notifyOnModelSwitch": true,
-  "desiredActive": false,
-  "supportedModels": ["openai/gpt-5.5", "openai-codex/gpt-5.5"],
+  "serviceTier": "standard",
+  "decisions": {
+    "enabled": false,
+    "model": "",
+    "timeoutMs": 10000
+  },
   "usage": {
     "enabled": true,
     "refreshIntervalMs": 60000,
@@ -125,9 +139,56 @@ Example config:
 }
 ```
 
+## Service tiers
+
+`/openai-tier fast` requests `service_tier: "priority"`. `/openai-tier standard` explicitly requests `"default"`, clearing an inherited Fast/Ultrafast request tier on OpenAI providers. Legacy disabled configurations without an explicit tier leave payloads untouched. `/fast` and the `--fast` flag never select Ultrafast.
+
+`/openai-tier ultrafast` explicitly opts into **6x Standard token prices** for `openai/gpt-6-astra` over the Responses API. Only the documented global (`https://api.openai.com/v1`) and US (`https://us.api.openai.com/v1`) endpoints are enabled. EU/regional endpoints, custom proxies, other models, and Codex subscription Ultrafast are not enabled without verified support. This does not promise account entitlement or available rate limits. Unsupported selections remain requested but inactive; the extension does not inject a lower-tier fallback or retry a rejected request.
+
+The footer shows `fast` or `ultrafast` only when supported by the current model. Diagnostics distinguish the requested tier and last injected payload from server-confirmed service or billing. **Pi's host cost estimates may omit the Ultrafast premium**; use OpenAI billing for actual charges. The host's native transport is preserved; WebSockets are recommended by OpenAI but HTTP is also supported. See [Ultrafast documentation](https://developers.openai.com/api/docs/guides/ultrafast-mode) and [pricing](https://developers.openai.com/api/docs/pricing?latest-pricing=ultrafast).
+
+`serviceTier` takes precedence over legacy `desiredActive`/`active` within each config layer; project state still overrides global state. `persistState: false` keeps tier changes session-only. `supportedModels` overrides the Fast allowlist, not Ultrafast capabilities. Unknown config fields and customized model lists are preserved.
+
+## Typed decisions
+
+The `openai_decide` tool returns typed judgments through Pi's classifier API, **not chat completions**. It is disabled by default and never chooses a provider automatically. To use an existing Jev classifier explicitly:
+
+```text
+/openai-decisions models
+/openai-decisions use typesafe/jev-latest
+```
+
+Configure that provider's credentials through Pi (for example, `TYPESAFE_API_KEY` for TypeSafe). The model list shows registered classifiers, not guaranteed credentials or entitlement. `/openai-decisions use` saves the selected model and enables decisions in the active project/global config; `/openai-decisions off` disables requests. These settings are independent of service-tier persistence. Provider-qualified IDs containing further slashes, such as `openrouter/typesafe/jev-1.13`, are supported when registered by the host. Prefer pinned versions for stable evaluations.
+
+**Native OpenAI Decisions is not yet implemented:** as of the September 29, 2026 research checkpoint, no verifiable public endpoint/schema or SDK adapter was found. The bridge accepts OpenAI only once a classifier adapter is registered in Pi; it does not invent an endpoint, forward Codex OAuth to another service, or silently substitute a chat model. See the [integration status and remaining gates](plans/devday-integration.md).
+
+Example tool input:
+
+```json
+{
+  "state": { "testFailure": "connection to local test database timed out" },
+  "questions": {
+    "route": {
+      "type": "choice",
+      "instructions": "Classify the failure for human review.",
+      "criteria": { "environment": "Environment problem", "code": "Code defect" }
+    }
+  }
+}
+```
+
+- `state`: JSON object; send only the necessary context, never credentials or the entire session.
+- `questions`: 1–32 named questions. `choice` uses 2–64 labeled criteria; `bool` uses `true`/`false` criteria; `score` uses 2–64 ordered criteria. Pi maps boolean questions to Jev's `noul` representation.
+- Total input is capped at 64 KiB. `decisions.timeoutMs` defaults to 10000 and is clamped to 1000–60000. Cancellation/deadlines abort the provider request; there are no automatic retries. A timed-out upstream request may still incur charges.
+- Results have `status: "ok"`, provider/model provenance, and typed `answers`; errors have `status: "error"` and mark the tool failed. Structured output is available to programmatic callers. Provider error text is withheld to prevent credential/state leakage.
+- Probabilities and confidence remain uncertain judgments; scores retain their provider-specific scale. No claim of cross-provider calibration is made. Decisions never authorize tools, execute commands, change the active model, or start background polling.
+- Reported classifier token usage/cost is included in tool results and the Better OpenAI footer. Missing usage or catalog pricing is not evidence that a request was free.
+
 ## Codex model fallbacks
 
-The extension adds `gpt-6-astra`, `gpt-daybreak-blue-latest`, and `gpt-daybreak-red-latest` to the built-in `openai-codex` provider without requiring local `models.json` entries. Existing built-in models remain available, and metadata from pi's live catalog takes precedence when pi publishes an official entry with the same ID.
+The extension adds `gpt-6.1-sol`, `gpt-6-astra`, `gpt-daybreak-blue-latest`, and `gpt-daybreak-red-latest` to the built-in `openai-codex` provider without requiring local `models.json` entries. Existing built-in models remain available, and metadata from pi's live catalog takes precedence when pi publishes an official entry with the same ID.
+
+The GPT-6.1 Sol fallback uses Codex's conservative 272K context default, 128K output limit, and published short/long-context pricing. It maps Pi's `minimal` level to `low` and disables `off`; the model does not accept `none` or `minimal` reasoning efforts. See [model documentation](https://developers.openai.com/api/docs/models/gpt-6.1-sol) and the [upstream Codex catalog change](https://github.com/openai/codex/commit/b1e72963c3b71a9265a551e54beff078384efed9).
 
 Daybreak models require separate OpenAI approval and provisioning. pi currently exposes reasoning levels through `max`; Codex's `ultra` automatic-delegation mode is not a pi thinking level.
 

package/index.ts

@@ -1,8 +1,7 @@
 /**
  * Better OpenAI for pi.
  *
- * Adds `service_tier: "priority"` to OpenAI provider payloads while fast mode is
- * enabled and the selected model is in the configured allow-list.
+ * Adds capability-gated OpenAI service tiers and opt-in native typed decisions.
  */
 import {
   type ExtensionAPI,
@@ -17,6 +16,7 @@ import {
   SettingsList,
   type SettingsListTheme,
 } from "@earendil-works/pi-tui";
+import type { Usage } from "@earendil-works/pi-ai";
 import { registerOpenAICodexModels } from "./src/codex-models.ts";
 import { CONFIG_BASENAME, STATUS_KEY } from "./src/identity.ts";
 import {
@@ -49,6 +49,8 @@ import {
   LIVE_SETTING_DESCRIPTORS,
   PET_SETTING_DESCRIPTORS,
   FAST_SETTING_DESCRIPTORS,
+  DECISIONS_SETTING_DESCRIPTORS,
+  isServiceTier,
   type SettingsOptionDescriptor,
   configPaths,
   type ResolvedConfig,
@@ -80,6 +82,7 @@ import { ResetController } from "./src/reset-controller.ts";
 import { registerOpenAIImage, _imageTest } from "./src/image.ts";
 import { registerOpenAIWebSearch, _websearchTest } from "./src/websearch.ts";
 import { registerOpenAILive } from "./src/live/index.ts";
+import { registerOpenAIDecisions } from "./src/decisions.ts";
 import {
   type CodexPetPackage,
   codexHome,
@@ -91,7 +94,7 @@ import {
   registerOpenAIPets,
   _petsTest,
 } from "./src/pets.ts";
-import { FastController, modelList, supportsFast } from "./src/fast-controller.ts";
+import { FastController, supportsFast } from "./src/fast-controller.ts";
 import { isOpenAISubscriptionModel, UsageController } from "./src/usage-controller.ts";
 import { PetFooterController } from "./src/pet-footer-controller.ts";
 import {
@@ -338,12 +341,14 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       ...nextConfig,
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
     };
     if (!nextConfig.persistState) return;
     writeConfig(nextConfig.configPath, {
       ...readRawConfig(nextConfig.configPath),
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
     });
   }
 
@@ -368,15 +373,22 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     ctx.ui.notify(fastController.stateText(ctx, nextConfig), "info");
   }
 
+  function addFooterUsage(usage: Usage | undefined): void {
+    if (!usage) return;
+    footerTotals.input += usage.input;
+    footerTotals.output += usage.output;
+    footerTotals.cacheRead += usage.cacheRead;
+    footerTotals.cacheWrite += usage.cacheWrite;
+    footerTotals.cost += usage.cost.total;
+  }
+
   function refreshFooterTotals(ctx: ExtensionContext): void {
     footerTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
     for (const entry of ctx.sessionManager.getEntries()) {
-      if (entry.type !== "message" || entry.message.role !== "assistant") continue;
-      footerTotals.input += entry.message.usage.input;
-      footerTotals.output += entry.message.usage.output;
-      footerTotals.cacheRead += entry.message.usage.cacheRead;
-      footerTotals.cacheWrite += entry.message.usage.cacheWrite;
-      footerTotals.cost += entry.message.usage.cost.total;
+      if (entry.type !== "message") continue;
+      if (entry.message.role === "assistant" || entry.message.role === "toolResult") {
+        addFooterUsage(entry.message.usage);
+      }
     }
   }
 
@@ -433,6 +445,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
       `Image default save: ${cfg.image.defaultSave}`,
       `Websearch enabled: ${cfg.websearch.enabled}`,
       `Websearch model: ${cfg.websearch.model} (${cfg.websearch.reasoningEffort}/${cfg.websearch.responseLength}, ${cfg.websearch.maxOutputTokens} tokens, ${cfg.websearch.timeoutMs}ms)`,
+      `Decisions enabled: ${cfg.decisions.enabled}`,
+      `Decision classifier: ${cfg.decisions.model || "not selected"} (${cfg.decisions.timeoutMs}ms)`,
+      "Native OpenAI Decisions requires a registered classifier adapter; no chat fallback.",
       `Live enabled: ${cfg.live.enabled}`,
       `Live voice: ${cfg.live.voice}`,
       `Pet enabled: ${cfg.pets.enabled}`,
@@ -531,6 +546,37 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand("openai-tier", {
+    description: "Select standard, fast, or ultrafast (API Astra; 6x Standard token prices)",
+    handler: async (args, ctx) => {
+      const tier = args.trim().toLowerCase();
+      if (!tier) {
+        ctx.ui.notify(
+          `Requested tier: ${fastController.desiredTier}. ${fastController.stateText(ctx, config(ctx))}`,
+          "info",
+        );
+        return;
+      }
+      if (!isServiceTier(tier)) {
+        ctx.ui.notify(
+          "Usage: /openai-tier [standard | fast | ultrafast]. Ultrafast explicitly opts into 6x Standard token prices.",
+          "error",
+        );
+        return;
+      }
+      const cfg = refresh(ctx);
+      fastController.setTier(ctx, cfg, tier);
+      persist(cfg);
+      updateFooter(ctx);
+      ctx.ui.notify(
+        fastController.stateText(ctx, cfg),
+        tier === "ultrafast" || (fastController.desiredActive && !fastController.active)
+          ? "warning"
+          : "info",
+      );
+    },
+  });
+
   pi.registerCommand(OPENAI_STATUS_COMMAND, {
     description: "Show OpenAI subscription usage status",
     handler: async (_args, ctx) => {
@@ -798,16 +844,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   }
 
   function buildFastSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
-    return [
-      {
-        id: "fast.enabled",
-        label: "Fast mode",
-        currentValue: String(fastController.desiredActive),
-        values: ["true", "false"],
-        description: `Request OpenAI fast mode. Activates for supported models: ${modelList(cfg.supportedModels)}.`,
-      },
-      ...settingsItemsFromDescriptors(FAST_SETTING_DESCRIPTORS, cfg),
-    ];
+    return settingsItemsFromDescriptors(FAST_SETTING_DESCRIPTORS, cfg, {
+      serviceTier: { currentValue: fastController.desiredTier },
+    });
   }
 
   function buildFooterSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
@@ -870,12 +909,13 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     return [
       {
         id: "section.fast",
-        label: "Fast mode",
+        label: "Service tier",
         currentValue: fastSettingsSummary(ctx, cfg),
-        description: "Configure OpenAI fast mode and persistence.",
+        description:
+          "Configure Standard, Fast, Ultrafast, and persistence. Ultrafast costs 6x Standard.",
         submenu: (_value, done) =>
           settingsSubmenu(
-            "Fast mode settings",
+            "Service tier settings",
             () => buildFastSettingsItems(config(ctx)),
             ctx,
             () => done(fastSettingsSummary(ctx, config(ctx))),
@@ -933,6 +973,38 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
             () => done(websearchSettingsSummary(config(ctx))),
           ),
       },
+      {
+        id: "section.decisions",
+        label: "Typed decisions",
+        currentValue: cfg.decisions.enabled ? cfg.decisions.model || "model required" : "disabled",
+        description: "Opt-in native classifier requests; no chat fallback or automatic actions.",
+        submenu: (_value, done) =>
+          settingsSubmenu(
+            "Typed decision settings",
+            () => {
+              const next = config(ctx);
+              const models = ctx.modelRegistry.getModelsOfType("classifier");
+              return settingsItemsFromDescriptors(DECISIONS_SETTING_DESCRIPTORS, next, {
+                "decisions.model": {
+                  values: [
+                    ...new Set([
+                      "",
+                      next.decisions.model,
+                      ...models.map((model) => `${model.provider}/${model.id}`),
+                    ]),
+                  ],
+                },
+              });
+            },
+            ctx,
+            () =>
+              done(
+                config(ctx).decisions.enabled
+                  ? config(ctx).decisions.model || "model required"
+                  : "disabled",
+              ),
+          ),
+      },
       {
         id: "section.live",
         label: "Live voice",
@@ -998,14 +1070,29 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     const bool = rawValue === "true";
     if (id === "fast.enabled") {
       fastController.setDesired(ctx, cfg, bool);
+    } else if (id === "serviceTier") {
+      if (!isServiceTier(rawValue)) return;
+      fastController.setTier(ctx, cfg, rawValue);
+      ctx.ui.notify(
+        fastController.stateText(ctx, cfg),
+        rawValue === "ultrafast" || (fastController.desiredActive && !fastController.active)
+          ? "warning"
+          : "info",
+      );
     }
     const petKey = id.startsWith("pets.") ? id.slice("pets.".length) : undefined;
     const nextRawConfig = applySettingToRawConfig(current, id, rawValue, {
       persistState: cfg.persistState,
       active: fastController.active,
       desiredActive: fastController.desiredActive,
+      serviceTier: fastController.desiredTier,
       petEmptyValue: PET_EMPTY_VALUE,
     });
+    if (id === "persistState" && bool) {
+      nextRawConfig.serviceTier = fastController.desiredTier;
+      nextRawConfig.active = fastController.active;
+      nextRawConfig.desiredActive = fastController.desiredActive;
+    }
     if (petKey) {
       if (petKey === "enabled" || petKey === "sizeCells" || petKey === "slug")
         petController.invalidateLoadKey();
@@ -1102,6 +1189,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
 
   registerOpenAIImage(pi, config);
   registerOpenAIWebSearch(pi, config);
+  registerOpenAIDecisions(pi, config, refresh);
   registerOpenAILive(pi, config);
   registerOpenAIPets(pi, {
     wake: async (ctx, slug) => {
@@ -1270,8 +1358,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
 
           const modelName = ctx.model?.id || "no-model";
           const thinkingLevel = pi.getThinkingLevel();
-          const fastSuffix =
-            fastController.active && supportsFast(ctx, cfg.supportedModels) ? " fast" : "";
+          const fastSuffix = fastController.statusSegment(ctx, cfg)
+            ? ` ${fastController.desiredTier}`
+            : "";
           let rightWithoutProvider = modelName;
           if (ctx.model?.reasoning) {
             rightWithoutProvider =
@@ -1448,7 +1537,9 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     fastController.initializeForSession(ctx, nextConfig, pi.getFlag(FLAG) === true);
     if (
       fastController.desiredActive !== nextConfig.desiredActive ||
-      fastController.active !== nextConfig.active
+      fastController.active !== nextConfig.active ||
+      fastController.desiredTier !==
+        (nextConfig.serviceTier ?? (nextConfig.desiredActive ? "fast" : "standard"))
     )
       persist(nextConfig);
     if (hasTerminalUI(ctx)) petController.installResizeGuard(ctx);
@@ -1489,11 +1580,8 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   pi.on("turn_end", (event, ctx) => {
     invalidateContextUsage();
     if (event.message?.role === "assistant") {
-      footerTotals.input += event.message.usage.input;
-      footerTotals.output += event.message.usage.output;
-      footerTotals.cacheRead += event.message.usage.cacheRead;
-      footerTotals.cacheWrite += event.message.usage.cacheWrite;
-      footerTotals.cost += event.message.usage.cost.total;
+      addFooterUsage(event.message.usage);
+      for (const result of event.toolResults ?? []) addFooterUsage(result.usage);
     } else refreshFooterTotals(ctx);
     updateFooter(ctx);
     void usageController.refresh(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",
@@ -38,6 +38,8 @@
     "index.ts",
     "src/",
     "README.md",
+    "CHANGELOG.md",
+    "plans/devday-integration.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"
   ],

package/plans/devday-integration.md

@@ -0,0 +1,48 @@
+# DevDay integration status
+
+Research checkpoint: September 29, 2026 (UTC). Announcements and account entitlements can change independently of source releases.
+
+## Implemented
+
+- GPT-6.1 Sol fallback metadata, with native Pi transport/auth and live catalog precedence preserved.
+- Fast-mode defaults for GPT-6 Astra, 6.1 Sol, Sol, and Luna on OpenAI/Codex.
+- Explicit Standard/Fast/Ultrafast selection, legacy state migration, model/endpoint capability gates, persistence, diagnostics, cost disclosure, and footer labels.
+- `openai_decide`: an opt-in bridge to Pi's classifier API. Explicit model selection, bounded typed input/output, cancellation/deadlines, usage reporting, and no chat/provider fallback.
+- No autonomous actions, model routing, approval bypasses, or inference-driven polling. Classification is an advisory primitive; application code owns policy and execution.
+
+## Native OpenAI Decisions: blocked on a verifiable contract
+
+The announcement is reported in [DevDay coverage](https://www.axios.com/2026/09/29/openai-dev-day-2026-dots-space-sol). At the research checkpoint, the public docs index and OpenAI Node SDK did not expose a verifiable Decisions contract; Codex search hits concerned existing approval decisions. This is not proof that private or later access is unavailable.
+
+The tool works with explicitly selected registered classifiers, including Jev. It does not pretend this is OpenAI's new service. Once OpenAI publishes its contract:
+
+1. Verify model IDs, schema, error/refusal behavior, modalities, endpoint, auth audience, rate limits, pricing, and data residency.
+2. Prefer a native Pi classifier adapter rather than duplicating credentials and transport here. Register classifier models, not chat models; the current tool can then select them.
+3. Preserve provider semantics. Do not equate arbitrary numeric scores or self-reported confidence with calibrated probabilities, or silently translate incompatible question types.
+4. Keep API-key and Codex subscription access separate until subscription authorization is documented. Do not infer OAuth compatibility from a product announcement.
+5. Add fixture tests and an opt-in live probe before claiming support. No default model ID is guessed today.
+
+### Evaluation checklist
+
+Before automated routing or background triage is enabled, compare pinned Jev/OpenAI classifier versions on the same consented, non-sensitive labeled cases:
+
+- failure classification, candidate-tool ranking, task routing, and notification relevance;
+- p50/p95 end-to-end latency, cost per useful decision, invalid-result/refusal/timeout rates;
+- accuracy and abstention coverage; Brier score/calibration only for outputs documented as probabilities;
+- low-confidence escalation and immutable policy/permission boundaries.
+
+Do not automatically run paid benchmark requests. A typed result is not proof of truth or authorization. TypeSafe's [September 15 Jev announcement](https://typesafe.ai/blog/introducing-system-one-models-and-jev) establishes timing and the decision-oriented interface, not OpenAI implementation provenance.
+
+## Codex subscription Ultrafast: capability gate remains closed
+
+The [public Ultrafast guide](https://developers.openai.com/api/docs/guides/ultrafast-mode) documents API Astra support. Codex has catalog-driven tier controls and WebSocket tier-switch tests, but its inspected bundled Astra/Sol catalog advertises Fast, not a subscription Ultrafast entitlement.
+
+Enable subscription Ultrafast only after an authenticated model/account capability contract is established, with tests for account switching, capability withdrawal, and unsupported requests. Arbitrary `supportedModels` configuration must not bypass this gate. Global/US API Astra is the verified path today. Host cost reporting currently may omit its 6x premium; never describe local estimates as actual billing.
+
+## Hosted Responses multi-agent: deliberately deferred
+
+[Responses multi-agent](https://developers.openai.com/api/docs/guides/responses-multi-agent) is a separate beta protocol, not a tier or ordinary thinking level. Adding only `multi_agent.enabled` is insufficient and could conflict with Fabric's orchestration.
+
+A future opt-in integration must handle agent identities, hosted collaboration items versus client tool calls, interleaved streams, continuation routing, cancellation, concurrency and total-spend limits, and permission enforcement for every child. Do not assume `max_concurrent_subagents` limits total agents, tree depth, or total spend. Keep the existing local orchestration owner until these invariants are verified.
+
+Dots, Space, and other consumer surfaces are not added without a documented integration contract.

package/src/codex-models.ts

@@ -59,6 +59,26 @@ export const CODEX_MODEL_FALLBACKS: CodexModel[] = [
     },
     compat: CODEX_COMPAT,
   },
+  {
+    id: "gpt-6.1-sol",
+    name: "GPT-6.1 Sol",
+    api: CODEX_API,
+    provider: CODEX_PROVIDER_ID,
+    baseUrl: CODEX_BASE_URL,
+    reasoning: true,
+    thinkingLevelMap: { off: null, minimal: "low", xhigh: "xhigh", max: "max" },
+    input: ["text", "image"],
+    contextWindow: 272000,
+    maxTokens: 128000,
+    cost: {
+      input: 2,
+      output: 10,
+      cacheRead: 0.1,
+      cacheWrite: 2.5,
+      tiers: [{ inputTokensAbove: 272000, input: 4, output: 15, cacheRead: 0.2, cacheWrite: 5 }],
+    },
+    compat: CODEX_COMPAT,
+  },
   {
     id: "gpt-daybreak-blue-latest",
     name: "Daybreak Blue",

package/src/config.ts

@@ -10,6 +10,13 @@ import {
 } from "./live/voices.ts";
 import { piAgentDir } from "./paths.ts";
 
+export const SERVICE_TIERS = ["standard", "fast", "ultrafast"] as const;
+export type ServiceTier = (typeof SERVICE_TIERS)[number];
+
+export function isServiceTier(value: unknown): value is ServiceTier {
+  return typeof value === "string" && (SERVICE_TIERS as readonly string[]).includes(value);
+}
+
 export const FOOTER_MODES = ["replace", "status", "off"] as const;
 export const IMAGE_SAVE_MODES = ["none", "project", "global", "custom"] as const;
 export const IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"] as const;
@@ -37,7 +44,14 @@ export const PET_STATES = [
 export const DEFAULT_SUPPORTED_MODELS = [
   "openai/gpt-5.4",
   "openai/gpt-5.5",
+  "openai/gpt-6-astra",
+  "openai/gpt-6.1-sol",
+  "openai/gpt-6-sol",
+  "openai/gpt-6-luna",
   "openai-codex/gpt-6-astra",
+  "openai-codex/gpt-6.1-sol",
+  "openai-codex/gpt-6-sol",
+  "openai-codex/gpt-6-luna",
   "openai-codex/gpt-5.6-sol",
   "openai-codex/gpt-5.6-terra",
   "openai-codex/gpt-5.6-luna",
@@ -49,6 +63,16 @@ export const DEFAULT_SUPPORTED_MODELS = [
 // default list. Treat those exact snapshots as unset so later additions to
 // DEFAULT_SUPPORTED_MODELS (such as gpt-6-astra) reach existing installs.
 const LEGACY_SEEDED_SUPPORTED_MODELS: readonly (readonly string[])[] = [
+  [
+    "openai/gpt-5.4",
+    "openai/gpt-5.5",
+    "openai-codex/gpt-6-astra",
+    "openai-codex/gpt-5.6-sol",
+    "openai-codex/gpt-5.6-terra",
+    "openai-codex/gpt-5.6-luna",
+    "openai-codex/gpt-5.4",
+    "openai-codex/gpt-5.5",
+  ],
   ["openai/gpt-5.4", "openai/gpt-5.5", "openai-codex/gpt-5.4", "openai-codex/gpt-5.5"],
   [
     "openai/gpt-5.4",
@@ -126,7 +150,15 @@ export type PetConfig = {
   sizeCells?: number;
 };
 
+export type DecisionsConfig = {
+  enabled?: boolean;
+  model?: string;
+  timeoutMs?: number;
+};
+
 export interface ConfigFile {
+  serviceTier?: ServiceTier;
+  decisions?: DecisionsConfig;
   persistState?: boolean;
   notifyOnModelSwitch?: boolean;
   active?: boolean;
@@ -146,6 +178,8 @@ export interface SupportedModel {
 }
 
 export interface ResolvedConfig {
+  serviceTier?: ServiceTier;
+  decisions: Required<DecisionsConfig>;
   configPath: string;
   projectConfigPath: string;
   globalConfigPath: string;
@@ -218,7 +252,14 @@ export const DEFAULT_PET_CONFIG: Required<PetConfig> = {
   sizeCells: 10,
 };
 
+export const DEFAULT_DECISIONS_CONFIG: Required<DecisionsConfig> = {
+  enabled: false,
+  model: "",
+  timeoutMs: 10_000,
+};
+
 export const DEFAULT_CONFIG: ConfigFile = {
+  decisions: DEFAULT_DECISIONS_CONFIG,
   // supportedModels is intentionally omitted so generated config files never pin
   // the default list; resolution falls back to DEFAULT_SUPPORTED_MODELS live.
   persistState: true,
@@ -239,6 +280,7 @@ export type SettingsOptionSection =
   | "footer"
   | "image"
   | "websearch"
+  | "decisions"
   | "live"
   | "pets";
 
@@ -262,14 +304,25 @@ const numberSetting = (rawValue: string): number => Number(rawValue);
 const stringSetting = (rawValue: string): string => rawValue;
 
 export const FAST_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "serviceTier",
+    section: "root",
+    key: "serviceTier",
+    label: "Service tier",
+    currentValue: (cfg) => cfg.serviceTier ?? (cfg.desiredActive ? "fast" : "standard"),
+    values: SERVICE_TIERS,
+    description:
+      "Ultrafast explicitly opts into 6x Standard token prices for API Astra (global/US only). Codex subscription access is not verified. Host cost estimates may exclude tier premiums.",
+    parse: stringSetting,
+  },
   {
     id: "persistState",
     section: "root",
     key: "persistState",
-    label: "Persist fast state",
+    label: "Persist service tier",
     currentValue: (cfg) => String(cfg.persistState),
     values: ["true", "false"],
-    description: "Remember fast-mode state across sessions.",
+    description: "Remember the selected service tier across sessions.",
     parse: booleanSetting,
   },
   {
@@ -605,7 +658,42 @@ export const PET_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
   },
 ];
 
+export const DECISIONS_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  {
+    id: "decisions.enabled",
+    section: "decisions",
+    key: "enabled",
+    label: "Enable decisions",
+    values: ["true", "false"],
+    currentValue: (cfg) => String(cfg.decisions.enabled),
+    parse: booleanSetting,
+    description:
+      "Opt in to sending bounded state to the explicitly selected native classifier. No chat fallback or automatic actions.",
+  },
+  {
+    id: "decisions.model",
+    section: "decisions",
+    key: "model",
+    label: "Classifier model",
+    currentValue: (cfg) => cfg.decisions.model,
+    parse: stringSetting,
+    description:
+      "Select with /openai-decisions use provider/model. OpenAI requires a published native classifier; Jev can be selected explicitly today.",
+  },
+  {
+    id: "decisions.timeoutMs",
+    section: "decisions",
+    key: "timeoutMs",
+    label: "Decision timeout (ms)",
+    values: ["5000", "10000", "30000"],
+    currentValue: (cfg) => String(cfg.decisions.timeoutMs),
+    parse: numberSetting,
+    description: "Maximum decision request duration; no automatic retries.",
+  },
+];
+
 export const SETTINGS_OPTION_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
+  ...DECISIONS_SETTING_DESCRIPTORS,
   ...FAST_SETTING_DESCRIPTORS,
   ...FOOTER_SETTING_DESCRIPTORS,
   ...USAGE_SETTING_DESCRIPTORS,
@@ -687,6 +775,23 @@ export function readConfig(path: string): ConfigFile | undefined {
   if (!existsSync(path)) return undefined;
   const parsed = readRawConfig(path);
   const config: ConfigFile = {};
+  if (isServiceTier(parsed.serviceTier)) config.serviceTier = parsed.serviceTier;
+  if (isRecord(parsed.decisions)) {
+    config.decisions = {};
+    if (Object.hasOwn(parsed.decisions, "enabled"))
+      config.decisions.enabled = parsed.decisions.enabled === true;
+    // Invalid explicit selections must not fall back to a different global provider.
+    if (Object.hasOwn(parsed.decisions, "model"))
+      config.decisions.model =
+        typeof parsed.decisions.model === "string" ? parsed.decisions.model.trim() : "";
+    if (
+      typeof parsed.decisions.timeoutMs === "number" &&
+      Number.isFinite(parsed.decisions.timeoutMs)
+    )
+      config.decisions.timeoutMs = parsed.decisions.timeoutMs;
+  } else if (Object.hasOwn(parsed, "decisions")) {
+    config.decisions = { enabled: false, model: "" };
+  }
   if (typeof parsed.persistState === "boolean") config.persistState = parsed.persistState;
   if (typeof parsed.notifyOnModelSwitch === "boolean")
     config.notifyOnModelSwitch = parsed.notifyOnModelSwitch;
@@ -798,6 +903,7 @@ export function readConfig(path: string): ConfigFile | undefined {
 }
 
 export type SettingPatchContext = SettingsValueContext & {
+  serviceTier?: ServiceTier;
   persistState?: boolean;
   active?: boolean;
   desiredActive?: boolean;
@@ -811,10 +917,14 @@ export function applySettingToRawConfig(
 ): Record<string, unknown> {
   const next: Record<string, unknown> = { ...current };
   const bool = rawValue === "true";
-  if (id === "fast.enabled") {
+  if (id === "fast.enabled" || id === "serviceTier") {
+    if (id === "serviceTier" && !isServiceTier(rawValue)) return next;
     if (context.persistState) {
-      next.active = context.active ?? bool;
-      next.desiredActive = context.desiredActive ?? bool;
+      const tier =
+        context.serviceTier ?? (isServiceTier(rawValue) ? rawValue : bool ? "fast" : "standard");
+      next.serviceTier = tier;
+      next.active = context.active ?? tier !== "standard";
+      next.desiredActive = context.desiredActive ?? tier !== "standard";
     }
   } else {
     const descriptor = SETTINGS_OPTION_BY_ID.get(id);
@@ -856,10 +966,37 @@ export function resolveConfig(cwd: string): ResolvedConfig {
   const projectConfig = readConfig(paths.project) ?? {};
   const merged = { ...DEFAULT_CONFIG, ...globalConfig, ...projectConfig };
   const selectedPath = projectConfigExists ? paths.project : paths.global;
-  const desiredActive = merged.desiredActive ?? merged.active ?? false;
+  // A project legacy boolean must also override a global explicit tier.
+  const stateConfig =
+    [projectConfig, globalConfig].find(
+      (cfg) =>
+        cfg.serviceTier !== undefined ||
+        cfg.desiredActive !== undefined ||
+        cfg.active !== undefined,
+    ) ?? {};
+  const serviceTier = stateConfig.serviceTier;
+  const desiredActive =
+    serviceTier !== undefined
+      ? serviceTier !== "standard"
+      : (stateConfig.desiredActive ?? stateConfig.active ?? false);
   const configuredSupportedModels = parseModels(merged.supportedModels);
 
   return {
+    serviceTier,
+    decisions: {
+      ...DEFAULT_DECISIONS_CONFIG,
+      ...globalConfig.decisions,
+      ...projectConfig.decisions,
+      timeoutMs: Math.max(
+        1000,
+        Math.min(
+          60_000,
+          projectConfig.decisions?.timeoutMs ??
+            globalConfig.decisions?.timeoutMs ??
+            DEFAULT_DECISIONS_CONFIG.timeoutMs,
+        ),
+      ),
+    },
     configPath: selectedPath,
     projectConfigPath: paths.project,
     globalConfigPath: paths.global,

package/src/decisions.ts

@@ -0,0 +1,405 @@
+import {
+  Type,
+  type ClassifierContext,
+  type ClassifierResult,
+  type Static,
+} from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  isRecord,
+  parseModelKey,
+  readRawConfig,
+  writeConfig,
+  type DecisionsConfig,
+  type ResolvedConfig,
+} from "./config.ts";
+
+export const OPENAI_DECIDE_TOOL = "openai_decide";
+export const OPENAI_DECISIONS_COMMAND = "openai-decisions";
+export const MAX_DECISION_BYTES = 64 * 1024;
+const MAX_QUESTIONS = 32;
+const MAX_CRITERIA = 64;
+const text = Type.String({ minLength: 1, maxLength: 4096 });
+const question = Type.Union([
+  Type.Object(
+    {
+      type: Type.Literal("choice"),
+      instructions: text,
+      criteria: Type.Record(Type.String(), text, { minProperties: 2, maxProperties: MAX_CRITERIA }),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      type: Type.Literal("bool"),
+      instructions: text,
+      criteria: Type.Object({ true: text, false: text }, { additionalProperties: false }),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    {
+      type: Type.Literal("score"),
+      instructions: text,
+      criteria: Type.Array(text, { minItems: 2, maxItems: MAX_CRITERIA }),
+    },
+    { additionalProperties: false },
+  ),
+]);
+export const DECISION_PARAMETERS = Type.Object(
+  {
+    state: Type.Record(Type.String(), Type.Unknown(), {
+      description:
+        "Only the JSON state needed for this decision. Do not send secrets or the entire session.",
+    }),
+    questions: Type.Record(Type.String(), question, {
+      minProperties: 1,
+      maxProperties: MAX_QUESTIONS,
+    }),
+  },
+  { additionalProperties: false },
+);
+const probability = Type.Number({ minimum: 0, maximum: 1 });
+export const DECISION_OUTPUT = Type.Union([
+  Type.Object(
+    {
+      status: Type.Literal("ok"),
+      provider: Type.String(),
+      model: Type.String(),
+      answers: Type.Record(
+        Type.String(),
+        Type.Union([
+          Type.Object(
+            {
+              type: Type.Literal("choice"),
+              choice: Type.String(),
+              probabilities: Type.Record(Type.String(), probability),
+              confidence: Type.Number(),
+            },
+            { additionalProperties: false },
+          ),
+          Type.Object({ type: Type.Literal("bool"), probability }, { additionalProperties: false }),
+          Type.Object(
+            { type: Type.Literal("score"), score: Type.Number(), confidence: Type.Number() },
+            { additionalProperties: false },
+          ),
+        ]),
+      ),
+    },
+    { additionalProperties: false },
+  ),
+  Type.Object(
+    { status: Type.Literal("error"), error: Type.String() },
+    { additionalProperties: false },
+  ),
+]);
+type DecisionOutput = Static<typeof DECISION_OUTPUT>;
+
+class DecisionError extends Error {}
+
+function requireDecision(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new DecisionError(message);
+}
+
+function validText(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= 4096;
+}
+
+export function validateDecisionRequest(value: unknown): ClassifierContext {
+  requireDecision(
+    isRecord(value) && isRecord(value.state) && isRecord(value.questions),
+    "Decisions require a JSON state object and typed questions.",
+  );
+  let encoded: string;
+  try {
+    encoded = JSON.stringify(value, (_key, item: unknown) => {
+      if (typeof item === "number" && !Number.isFinite(item)) throw new Error();
+      if (["undefined", "function", "symbol", "bigint"].includes(typeof item)) throw new Error();
+      return item;
+    });
+  } catch {
+    throw new DecisionError("Decision input must contain only finite JSON values.");
+  }
+  requireDecision(
+    Buffer.byteLength(encoded, "utf8") <= MAX_DECISION_BYTES,
+    "Decision input exceeds the 64 KiB limit.",
+  );
+  requireDecision(
+    Object.keys(value).every((key) => key === "state" || key === "questions"),
+    "Unexpected decision input fields.",
+  );
+  const questions = Object.entries(value.questions);
+  requireDecision(
+    questions.length > 0 && questions.length <= MAX_QUESTIONS,
+    "Provide between 1 and 32 decision questions.",
+  );
+  for (const [key, item] of questions) {
+    requireDecision(
+      key.length > 0 &&
+        key.length <= 128 &&
+        !["__proto__", "constructor", "prototype"].includes(key),
+      "Invalid decision question key.",
+    );
+    requireDecision(
+      isRecord(item) && validText(item.instructions),
+      "Each question requires bounded, nonempty instructions.",
+    );
+    requireDecision(
+      Object.keys(item).every((field) => ["type", "instructions", "criteria"].includes(field)),
+      "Unexpected decision question fields.",
+    );
+    if (item.type === "score") {
+      requireDecision(
+        Array.isArray(item.criteria) &&
+          item.criteria.length >= 2 &&
+          item.criteria.length <= MAX_CRITERIA &&
+          item.criteria.every(validText),
+        "Scores require 2–64 ordered criteria.",
+      );
+    } else {
+      requireDecision(
+        (item.type === "choice" || item.type === "bool") && isRecord(item.criteria),
+        "Question type must be choice, bool, or score.",
+      );
+      const keys = Object.keys(item.criteria);
+      requireDecision(
+        keys.length >= 2 &&
+          keys.length <= MAX_CRITERIA &&
+          keys.every(
+            (label) =>
+              label.length > 0 &&
+              label.length <= 128 &&
+              !["__proto__", "constructor", "prototype"].includes(label),
+          ) &&
+          Object.values(item.criteria).every(validText),
+        "Provide 2–64 valid labeled criteria.",
+      );
+      if (item.type === "bool")
+        requireDecision(
+          keys.length === 2 && keys.includes("true") && keys.includes("false"),
+          "Boolean criteria must be true and false.",
+        );
+    }
+  }
+  return JSON.parse(encoded) as ClassifierContext;
+}
+
+const finite = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value);
+const unit = (value: unknown): value is number => finite(value) && value >= 0 && value <= 1;
+
+export function validateDecisionAnswers(
+  answers: unknown,
+  request: ClassifierContext,
+): ClassifierResult["answers"] {
+  const invalid = "Classifier returned invalid typed answers.";
+  requireDecision(
+    isRecord(answers) && Object.keys(answers).length === Object.keys(request.questions).length,
+    invalid,
+  );
+  const clean: ClassifierResult["answers"] = {};
+  for (const [key, q] of Object.entries(request.questions)) {
+    const answer = answers[key];
+    requireDecision(isRecord(answer) && answer.type === q.type, invalid);
+    if (q.type === "bool") {
+      requireDecision(unit(answer.probability), invalid);
+      clean[key] = { type: "bool", probability: answer.probability };
+    } else if (q.type === "score") {
+      requireDecision(finite(answer.score) && finite(answer.confidence), invalid);
+      // Preserve the provider's score scale; do not relabel it as a probability.
+      clean[key] = { type: "score", score: answer.score, confidence: answer.confidence };
+    } else {
+      requireDecision(
+        typeof answer.choice === "string" &&
+          Object.hasOwn(q.criteria, answer.choice) &&
+          isRecord(answer.probabilities) &&
+          finite(answer.confidence),
+        invalid,
+      );
+      const entries = Object.entries(answer.probabilities);
+      requireDecision(
+        entries.length === Object.keys(q.criteria).length &&
+          entries.every(([label, p]) => Object.hasOwn(q.criteria, label) && unit(p)),
+        invalid,
+      );
+      requireDecision(
+        Math.abs(entries.reduce((sum, [, p]) => sum + (p as number), 0) - 1) <= 0.001,
+        invalid,
+      );
+      clean[key] = {
+        type: "choice",
+        choice: answer.choice,
+        confidence: answer.confidence,
+        probabilities: Object.fromEntries(entries) as Record<string, number>,
+      };
+    }
+  }
+  return clean;
+}
+
+export async function evaluateDecision(
+  ctx: ExtensionContext,
+  cfg: ResolvedConfig,
+  input: unknown,
+  signal?: AbortSignal,
+) {
+  let result: ClassifierResult | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  signal?.addEventListener("abort", abort, { once: true });
+  if (signal?.aborted) abort();
+  let abortListener: (() => void) | undefined;
+  try {
+    requireDecision(
+      cfg.decisions.enabled,
+      "Decisions are disabled. Select a native classifier with /openai-decisions use provider/model to opt in.",
+    );
+    const key = parseModelKey(cfg.decisions.model);
+    requireDecision(
+      key,
+      "Select an explicit native classifier with /openai-decisions use provider/model.",
+    );
+    const model = ctx.modelRegistry.getModelOfType("classifier", key.provider, key.id);
+    requireDecision(
+      model,
+      "The configured native classifier is unavailable. No OpenAI endpoint or chat fallback is assumed; inspect /openai-decisions models.",
+    );
+    const request = validateDecisionRequest(input);
+    requireDecision(!controller.signal.aborted, "Decision request aborted.");
+    const cancelled = new Promise<never>((_resolve, reject) => {
+      abortListener = () =>
+        reject(
+          new DecisionError(
+            signal?.aborted ? "Decision request aborted." : "Decision request timed out.",
+          ),
+        );
+      controller.signal.addEventListener("abort", abortListener, { once: true });
+    });
+    timer = setTimeout(abort, cfg.decisions.timeoutMs);
+    result = await Promise.race([
+      ctx.modelRegistry.classify(model, request, { signal: controller.signal }),
+      cancelled,
+    ]);
+    requireDecision(
+      !controller.signal.aborted,
+      signal?.aborted ? "Decision request aborted." : "Decision request timed out.",
+    );
+    requireDecision(
+      result.stopReason === "stop",
+      result.stopReason === "aborted"
+        ? "Decision request aborted."
+        : "Decision provider failed. Check the selected provider's credentials and availability in Pi.",
+    );
+    requireDecision(
+      result.provider === model.provider && result.model === model.id,
+      "Classifier response did not match the selected provider/model.",
+    );
+    const answers = validateDecisionAnswers(result.answers, request);
+    const output: DecisionOutput = {
+      status: "ok",
+      provider: result.provider,
+      model: result.model,
+      answers,
+    };
+    return {
+      content: [{ type: "text" as const, text: JSON.stringify(output) }],
+      details: output,
+      structuredContent: output,
+      usage: result.usage,
+    };
+  } catch (error) {
+    // Provider errors can echo submitted state or credentials; never expose their text.
+    const output: DecisionOutput = {
+      status: "error",
+      error:
+        error instanceof DecisionError
+          ? error.message
+          : "Decision provider failed. Check the selected provider's credentials and availability in Pi.",
+    };
+    return {
+      content: [{ type: "text" as const, text: output.error }],
+      details: output,
+      structuredContent: output,
+      isError: true,
+      usage: result?.usage,
+    };
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+    if (abortListener) controller.signal.removeEventListener("abort", abortListener);
+  }
+}
+
+export function registerOpenAIDecisions(
+  pi: ExtensionAPI,
+  getConfig: (ctx: ExtensionContext) => ResolvedConfig,
+  refreshConfig: (ctx: ExtensionContext) => ResolvedConfig,
+): void {
+  function save(ctx: ExtensionContext, patch: DecisionsConfig): void {
+    const cfg = refreshConfig(ctx);
+    const raw = readRawConfig(cfg.configPath);
+    writeConfig(cfg.configPath, {
+      ...raw,
+      decisions: { ...(isRecord(raw.decisions) ? raw.decisions : {}), ...patch },
+    });
+    refreshConfig(ctx);
+  }
+
+  pi.registerCommand(OPENAI_DECISIONS_COMMAND, {
+    description: "Configure opt-in native decisions: models | use provider/model | off",
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+      if (arg === "off") {
+        save(ctx, { enabled: false });
+        ctx.ui.notify("Decision requests disabled.", "info");
+      } else if (arg === "models") {
+        const models = ctx.modelRegistry.getModelsOfType("classifier");
+        ctx.ui.notify(
+          models.length
+            ? models.map((m) => `${m.provider}/${m.id}`).join("\n") +
+                "\nCatalog entries do not guarantee credentials or entitlement."
+            : "No native classifiers registered. No OpenAI Decisions endpoint is assumed.",
+          "info",
+        );
+      } else if (arg.startsWith("use ")) {
+        const key = parseModelKey(arg.slice(4));
+        if (!key || !ctx.modelRegistry.getModelOfType("classifier", key.provider, key.id)) {
+          ctx.ui.notify(
+            "Unknown native classifier. Use /openai-decisions models; chat models are not accepted.",
+            "error",
+          );
+          return;
+        }
+        const model = `${key.provider}/${key.id}`;
+        save(ctx, { enabled: true, model });
+        ctx.ui.notify(
+          `Decisions enabled for ${model}. Submitted state is sent to that provider and billed there. No automatic actions or provider fallback.`,
+          "warning",
+        );
+      } else if (!arg) {
+        const cfg = getConfig(ctx).decisions;
+        ctx.ui.notify(
+          `Decisions: ${cfg.enabled ? "enabled" : "disabled"}; model: ${cfg.model || "not selected"}; timeout: ${cfg.timeoutMs}ms.\n/openai-decisions models | use provider/model | off\nOpenAI native Decisions requires a published classifier adapter in Pi; no endpoint is guessed.`,
+          "info",
+        );
+      } else {
+        ctx.ui.notify("Usage: /openai-decisions [models | use provider/model | off]", "error");
+      }
+    },
+  });
+  pi.registerTool({
+    name: OPENAI_DECIDE_TOOL,
+    label: "Typed decision",
+    description:
+      "Answer bounded choice, bool, or score questions using the user's explicitly configured native classifier. Disabled until opt-in. Supports Pi classifier providers (including Jev); OpenAI requires a native adapter. Never uses a chat fallback or executes decisions.",
+    parameters: DECISION_PARAMETERS,
+    outputSchema: DECISION_OUTPUT,
+    promptGuidelines: [
+      "Use only for explicitly requested judgments after the user selects a classifier. Send minimal state, not secrets or the full session.",
+      "Treat probabilities as uncertain judgments, not permission to act. Preserve score semantics and escalate ambiguous results.",
+    ],
+    execute: (_id, params, signal, _onUpdate, ctx) =>
+      evaluateDecision(ctx, getConfig(ctx), params, signal),
+  });
+}

package/src/fast-controller.ts

@@ -1,7 +1,10 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { ResolvedConfig, SupportedModel } from "./config.ts";
+import type { ResolvedConfig, ServiceTier, SupportedModel } from "./config.ts";
 import { isRecord } from "./config.ts";
 
+export const ULTRAFAST_NOTICE =
+  "Ultrafast uses 6x Standard token prices for API GPT-6 Astra (global/US only). Codex subscription access is not verified. Host cost estimates may exclude tier premiums.";
+
 export function currentModelKey(ctx: ExtensionContext): string {
   return ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "none";
 }
@@ -14,6 +17,41 @@ export function supportsFast(ctx: ExtensionContext, supportedModels: SupportedMo
   );
 }
 
+export function supportsUltrafast(ctx: ExtensionContext): boolean {
+  const model = ctx.model;
+  if (
+    model?.provider !== "openai" ||
+    model.id !== "gpt-6-astra" ||
+    model.api !== "openai-responses"
+  )
+    return false;
+  try {
+    const url = new URL(model.baseUrl);
+    return (
+      url.protocol === "https:" &&
+      !url.username &&
+      !url.password &&
+      !url.port &&
+      ["api.openai.com", "us.api.openai.com"].includes(url.hostname) &&
+      /^\/v1\/?$/.test(url.pathname) &&
+      !url.search &&
+      !url.hash
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function supportsServiceTier(
+  ctx: ExtensionContext,
+  cfg: ResolvedConfig,
+  tier: ServiceTier,
+): boolean {
+  if (tier === "ultrafast") return supportsUltrafast(ctx);
+  if (tier === "fast") return supportsFast(ctx, cfg.supportedModels);
+  return ctx.model?.provider === "openai" || ctx.model?.provider === "openai-codex";
+}
+
 export function modelList(supportedModels: SupportedModel[]): string {
   return supportedModels.length > 0
     ? supportedModels.map((model) => `${model.provider}/${model.id}`).join(", ")
@@ -35,54 +73,80 @@ export function fastStateText(
 }
 
 export class FastController {
-  desiredActive = false;
+  desiredTier: ServiceTier = "standard";
   active = false;
+  private explicitSelection = false;
   private lastInjectedAt: number | undefined;
   private lastInjectedModel: string | undefined;
   private lastInjectedTier: string | undefined;
-  private readonly serviceTier: string;
 
-  constructor(serviceTier: string) {
-    this.serviceTier = serviceTier;
+  private readonly fastServiceTier: string;
+
+  constructor(fastServiceTier = "priority") {
+    this.fastServiceTier = fastServiceTier;
+  }
+
+  get desiredActive(): boolean {
+    return this.desiredTier !== "standard";
   }
 
   applyDesiredState(ctx: ExtensionContext, cfg: ResolvedConfig): void {
-    this.active = this.desiredActive && supportsFast(ctx, cfg.supportedModels);
+    this.active = this.desiredActive && supportsServiceTier(ctx, cfg, this.desiredTier);
   }
 
   initializeForSession(ctx: ExtensionContext, cfg: ResolvedConfig, flagActive: boolean): void {
-    this.desiredActive = cfg.persistState ? cfg.desiredActive : false;
-    if (flagActive) this.desiredActive = true;
+    this.desiredTier = cfg.persistState
+      ? (cfg.serviceTier ?? (cfg.desiredActive ? "fast" : "standard"))
+      : "standard";
+    this.explicitSelection = cfg.persistState && cfg.serviceTier !== undefined;
+    if (flagActive) {
+      this.desiredTier = "fast";
+      this.explicitSelection = true;
+    }
     this.applyDesiredState(ctx, cfg);
   }
 
   setDesired(ctx: ExtensionContext, cfg: ResolvedConfig, next: boolean): void {
-    this.desiredActive = next;
+    this.setTier(ctx, cfg, next ? "fast" : "standard");
+  }
+
+  setTier(ctx: ExtensionContext, cfg: ResolvedConfig, tier: ServiceTier): void {
+    this.desiredTier = tier;
+    this.explicitSelection = true;
     this.applyDesiredState(ctx, cfg);
   }
 
   stateText(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    if (this.desiredTier === "ultrafast") {
+      return this.active
+        ? `Ultrafast mode is on for ${currentModelKey(ctx)}. ${ULTRAFAST_NOTICE}`
+        : this.unsupportedRequestMessage(ctx, cfg);
+    }
     return fastStateText(ctx, this.desiredActive, this.active, cfg.supportedModels);
   }
 
   unsupportedRequestMessage(ctx: ExtensionContext, cfg: ResolvedConfig): string {
+    if (this.desiredTier === "ultrafast") {
+      return `Ultrafast requested, but inactive for ${currentModelKey(ctx)}. ${ULTRAFAST_NOTICE} No lower-tier fallback will be injected.`;
+    }
     return `Fast mode requested, but ${currentModelKey(ctx)} is unsupported. It will activate automatically when you switch to a supported model: ${modelList(cfg.supportedModels)}.`;
   }
 
   inactiveForModelMessage(ctx: ExtensionContext): string {
-    return `Fast mode inactive for unsupported model ${currentModelKey(ctx)}.`;
+    const name = this.desiredTier === "ultrafast" ? "Ultrafast" : "Fast";
+    return `${name} mode inactive for unsupported model ${currentModelKey(ctx)}.`;
   }
 
   settingsSummary(ctx: ExtensionContext, cfg: ResolvedConfig): string {
-    if (this.active) return "on";
-    if (this.desiredActive)
-      return supportsFast(ctx, cfg.supportedModels) ? "requested" : "requested inactive";
-    return "off";
+    return (
+      this.desiredTier +
+      (this.desiredActive && !supportsServiceTier(ctx, cfg, this.desiredTier) ? " (inactive)" : "")
+    );
   }
 
   statusSegment(ctx: ExtensionContext, cfg: ResolvedConfig): string | undefined {
-    return this.active && supportsFast(ctx, cfg.supportedModels)
-      ? `${ctx.model?.id ?? "model"} fast`
+    return this.active && supportsServiceTier(ctx, cfg, this.desiredTier)
+      ? `${ctx.model?.id ?? "model"} ${this.desiredTier}`
       : undefined;
   }
 
@@ -91,22 +155,33 @@ export class FastController {
     ctx: ExtensionContext,
     cfg: ResolvedConfig,
   ): unknown {
-    if (!this.active || !supportsFast(ctx, cfg.supportedModels) || !isRecord(event.payload))
+    if (!isRecord(event.payload) || !supportsServiceTier(ctx, cfg, this.desiredTier))
+      return undefined;
+    if (typeof event.payload.model === "string" && event.payload.model !== ctx.model?.id)
       return undefined;
+    if (this.desiredTier === "standard" && !this.explicitSelection) return undefined;
+    const tier =
+      this.desiredTier === "standard"
+        ? "default"
+        : this.desiredTier === "fast"
+          ? this.fastServiceTier
+          : "ultrafast";
     this.lastInjectedAt = Date.now();
     this.lastInjectedModel = currentModelKey(ctx);
-    this.lastInjectedTier = this.serviceTier;
-    return { ...event.payload, service_tier: this.serviceTier };
+    this.lastInjectedTier = tier;
+    return { ...event.payload, service_tier: tier };
   }
 
   debugLines(ctx: ExtensionContext, cfg: ResolvedConfig): string[] {
     return [
-      `Fast desired: ${this.desiredActive}`,
-      `Fast active: ${this.active}`,
+      `Requested service tier: ${this.desiredTier}`,
+      `Effective override: ${supportsServiceTier(ctx, cfg, this.desiredTier) ? (this.desiredTier === "standard" && !this.explicitSelection ? "none (provider default)" : this.desiredTier) : "inactive (unsupported)"}`,
       `Current model: ${currentModelKey(ctx)}`,
-      `Supported model: ${supportsFast(ctx, cfg.supportedModels)}`,
-      `Configured service_tier: ${this.serviceTier}`,
+      `Fast supported: ${supportsFast(ctx, cfg.supportedModels)}`,
+      `Ultrafast supported: ${supportsUltrafast(ctx)}`,
       `Last injected: ${this.lastInjectedAt ? `${new Date(this.lastInjectedAt).toLocaleTimeString()} (${this.lastInjectedModel}, ${this.lastInjectedTier})` : "never"}`,
+      "Injection records requests, not server-confirmed service tiers or billing.",
+      ULTRAFAST_NOTICE,
     ];
   }
 }