@qadanm/opencode-smart-router 0.4.0 → 0.6.1

package/docs/INSTALL.md

@@ -1,7 +1,5 @@
 # Install, verify, and remove
 
-# Install, verify, and remove
-
 ## Install
 
 One command, from a checkout. Requires Node 20.12+, npm and git. No `jq`.
@@ -102,11 +100,44 @@ A safe smoke test:
 2. Send a narrow CSS change with an explicit file path.
 3. The session should switch to an economy model before the request, and the file should change.
 4. Send an ordinary feature request; it should use a standard model at or above the intelligence floor.
-5. Send a redesign with a screenshot; it should require a vision model and record a premium approval suggestion.
-6. Run `/router-approve` and repeat the redesign; a premium model may be selected once.
+5. Send a tier-3 request (architecture, sophisticated redesign); with the 0.6.x default
+   `premium.mode: "auto"` it escalates to a plan model (Sonnet 5.5 or GPT-6.1 Sol)
+   automatically — no approval step, paid from the plan-model pool.
+6. Run `/router-why` on the escalated prompt; the reason should name auto escalation
+   and the candidate trace should show the flagship row.
 7. Select a model manually in the desktop picker; the next prompt must not be overridden, and `/router-status` should show `manual`.
 8. Run `/router-auto` to resume.
 
+## Automatic flagship escalation (0.6.0 and later)
+
+The default premium mode is `auto`. How it behaves:
+
+- **Tier-1/2 work never touches the plan-model pool.** Routine tasks stay on the
+  ordinary Design Plan models exactly as before.
+- **Tier-3 work escalates by itself.** Architecture, sophisticated redesigns, and
+  other tier-3 classifications route to Claude Sonnet 5.5 or GPT-6.1 Sol without an
+  approval prompt, while the pool has budget.
+- **The pool is the budget.** Auto escalation is funded from the OpenDesign
+  plan-model pool ($120/month on Pro), read from the plan catalog and tracked in a
+  ledger that survives restarts. When the pool is spent, escalation degrades to an
+  approval gate (`/router-approve`) and the router serves the task with the strongest
+  ordinary model — a routing refusal never fails a serviceable task.
+- **Auto requires a resolvable pool.** If `providers.opendesign.plan` does not
+  resolve to a known plan, auto refuses rather than falling back to the legacy
+  premium budget, so spend is always attributable to a pool.
+
+To change the behavior:
+
+```json
+{
+  "premium": { "mode": "auto", "monthlyBudgetUsd": 120 }
+}
+```
+
+`mode` may be `off` (never premium), `ask` (one-shot approval per request),
+`allowed` (session approval unlocks the legacy premium budget), or `auto`.
+A project-level `.opencode/smart-router.json` can tighten this but not loosen it.
+
 ## Configuration
 
 No config file is required. To customize:

package/docs/LIMITATIONS.md

@@ -61,9 +61,26 @@ It is queried with OpenCode's existing OAuth access token from the `opencode` co
 
 The V2 prompt admission hook can mutate a prompt but exposes no typed rejection operation. The router blocks admission by throwing `RouterBlockedError` from the prompt hook. On the installed 2.1.4 server this was verified to reject the prompt with HTTP 500 and no provider request; the session title changes to `BLOCKED` and the reason is recorded in the decision.
 
-This is safe but not polished: the HTTP error is generic, so the title and notification are the user-facing explanation. `routing.failClosed` defaults to true. Manual selections and paused routing are outside the strict block.
+This is safe but not polished: the HTTP error is generic, so the title and notification are the user-facing explanation.
 
-A routing exception must also block. The earlier catch-and-continue path was a fail-open defect and is being removed.
+### What may and may not block a prompt
+
+Blocking is **opt-in**. `routing.failClosed` defaults to `false`, and the default is the contract, not a tuning knob.
+
+A defect in this plugin degrades to "do not route", never to "do not work". When the router cannot produce a decision because something inside it failed, the prompt is served with the model already selected, which is what would have happened if the plugin were not installed. The reason is recorded in warnings and in the decision record, so the failure is visible without being fatal.
+
+`routing.failClosed: true` is available for an owner who has decided they would rather be stopped than pay for an unrouted request. It applies to plugin faults only. It does **not** govern quota safety: a provider configured for probing but with no reading is always refused, because that is a spending decision about a provider the router cannot see, not a response to its own failure.
+
+Every hook is wrapped in `containHook()` and routing runs against a deadline. A hook cannot throw to the host and cannot hold a prompt indefinitely; if routing has not finished within the budget (10 seconds by default), the prompt proceeds unrouted. The reasoning is in [INCIDENT-2026-11-06-prompt-lockout.md](INCIDENT-2026-11-06-prompt-lockout.md).
+
+## 4a. OpenCode does not contain a plugin hook
+
+Verified against a real OpenCode 2.2.5 process on 2026-11-06:
+
+- a plugin hook that **throws** fails the prompt with HTTP 500;
+- a plugin hook that **never settles** blocks until the caller gives up.
+
+OpenCode has no timeout and no catch of its own at this boundary, so a plugin cannot rely on the host to survive it. Every guarantee therefore has to come from the plugin, which is what `src/server/containment.ts` is for. `scripts/isolated-e2e.sh` asserts both limitations so the reason for that module stays visible.
 
 ## 5. Manual CLI selection at session creation
 

package/docs/SHARED-CORE.md

@@ -45,18 +45,60 @@ Session and step events are process-global in this SDK. A session is claimed by
 
 The prompt hook checks `projectID` before claiming a session. Title writes are filtered by project. Commands and RPC remain location-scoped, so each project exposes its own 16 router commands.
 
-## Fail-closed policy
+## Failure policy
 
-`routing.failClosed` defaults to `true`. When no eligible route exists and the current model is unqualified, the router:
+`routing.failClosed` defaults to **`false`**.
+
+A defect in this plugin degrades to "do not route", never to "do not work". When
+the router cannot produce a decision because something inside it failed, the
+prompt is served with the model already selected, which is what would have
+happened had the plugin not been installed. The reason is recorded in warnings
+and in the decision record.
+
+Blocking is available as an explicit opt-in. With `routing.failClosed: true`,
+an unexpected routing failure:
 
 1. writes a `BLOCKED` session title;
 2. sends a nonintrusive notification where supported;
 3. records a blocked decision with the reason;
 4. throws `RouterBlockedError` from the prompt hook.
 
-The installed server was probed with a throwing prompt hook: the prompt returned HTTP 500 and was not admitted; the session had no model and no request was sent. OpenCode does not expose a typed rejection API. The HTTP error is generic, so the title and notification are the user-facing explanation. This is a documented limitation, not a silent execution path. Manual selections and paused routing are outside the strict block.
-
-Every unexpected routing exception is now converted into a blocked decision, a `BLOCKED` title, and a `RouterBlockedError` before admission. A malformed model definition or an engine bug can no longer fall through to an unqualified model. The opt-out is explicit: `routing.failClosed: false`.
+OpenCode exposes no typed rejection API, so the block travels as an exception.
+The installed server was probed with a throwing prompt hook: the prompt returned
+HTTP 500 and was not admitted. The HTTP error is generic, so the title and
+notification are the user-facing explanation.
+
+Version 0.6.0 defaulted this to `true` and treated every internal exception as a
+blocking condition. That turned a missing ledger method into a total refusal to
+send any prompt, including in manual mode, and the owner had to remove the
+plugin by hand. The reasoning is in
+[INCIDENT-2026-11-06-prompt-lockout.md](INCIDENT-2026-11-06-prompt-lockout.md).
+
+`failClosed` does not govern quota safety. The rule "a provider configured for
+probing but with no reading is refused" is unconditional, because it is a
+spending decision about a provider the router cannot see.
+
+## Containment at the host boundary
+
+OpenCode does not catch a plugin hook that throws and does not time out a hook
+that never settles. Both were verified against a real OpenCode 2.2.5 process on
+2026-11-06 and are asserted by `scripts/isolated-e2e.sh`. The guarantee has to
+come from this side of the boundary, so `src/server/containment.ts` provides:
+
+- `containHook()`, which makes a hook's failure a recorded warning rather than a
+  failed request. A deliberate `RouterBlockedError` passes through only when the
+  caller opts in.
+- `withDeadline()`, which bounds routing. If routing has not finished within the
+  budget (10 seconds by default), the prompt proceeds unrouted and the timeout is
+  reported.
+
+## Shared core versioning
+
+The process-wide core is stamped with `SHARED_CORE_API`. A bundle adopts a core
+from `globalThis` only when the stamp matches. A core left by a different
+version is a different class with a different method set, and adopting it is how
+0.6.0 produced `this.ledger.planPoolSpent is not a function` on every prompt.
+`init()` additionally replaces a ledger that is not a `LedgerStore` instance.
 
 ## Quota and persistence
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qadanm/opencode-smart-router",
-  "version": "0.4.0",
+  "version": "0.6.1",
   "description": "Subscription-aware model routing for OpenCode: nested usage windows, multi-pool credit accounting, context policy, and self-healing routing that repairs prompts and fails over deterministic rejections.",
   "keywords": [
     "opencode",
@@ -76,7 +76,9 @@
     "@opencode/plugin": "2.2.5"
   },
   "devDependencies": {
+    "@types/jsdom": "^30.0.0",
     "@types/node": "^24.0.0",
+    "jsdom": "^27.4.0",
     "solid-js": "^1.9.18",
     "typescript": "^5.9.3",
     "vite": "^7.3.7",

package/src/core/config.ts

@@ -105,8 +105,8 @@ export const DEFAULT_SETTINGS: RouterSettings = {
     requireZdr: false,
   },
   premium: {
-    mode: "ask",
-    monthlyBudgetUsd: 0,
+    mode: "auto",
+    monthlyBudgetUsd: 120,
     oneShotApproval: true,
   },
   routing: {
@@ -118,7 +118,12 @@ export const DEFAULT_SETTINGS: RouterSettings = {
     largeContextHysteresisPct: 35,
     maxEscalationsPerTask: 2,
     preferSameProvider: true,
-    failClosed: true,
+    // A defect in this plugin must never make the editor unusable. Routing is
+    // an optimization; the host works without it. Failing open means an
+    // internal error leaves the current model in place and lets the prompt
+    // through. An owner who would rather be stopped than pay for an unrouted
+    // request can set this to true explicitly.
+    failClosed: false,
     protectEscalationPool: true,
     longContextFloorTokens: 1_000_000,
     calibrateFloor: false,
@@ -156,7 +161,6 @@ export const DEFAULT_SETTINGS: RouterSettings = {
     // bug, not a feature: the session title is the user's, and status belongs in
     // the desktop panel or the terminal's status line. Turning this on is an
     // explicit choice, and turning it back off restores the original names.
-    titleIndicator: false,
     notifications: true,
     compactMode: false,
     compact: false,
@@ -200,6 +204,11 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value)
 
 const asBoolean = (value: unknown, fallback: boolean, warnings: string[], path: string): boolean => {
+  // Absent and invalid are different. A key that was never written takes the
+  // fallback silently; only a value the user actually provided can be wrong.
+  // Collapsing the two produced dozens of warnings for a config that set one
+  // provider plan, which buried the real problems in the noise.
+  if (value === undefined) return fallback
   if (typeof value === "boolean") return value
   warnings.push(`${path} must be a boolean; using ${fallback}`)
   return fallback
@@ -213,6 +222,7 @@ const asNumber = (
   min: number,
   max: number,
 ): number => {
+  if (value === undefined) return fallback
   if (typeof value !== "number" || !Number.isFinite(value)) {
     warnings.push(`${path} must be a finite number; using ${fallback}`)
     return fallback
@@ -223,6 +233,7 @@ const asNumber = (
 }
 
 const asString = (value: unknown, fallback: string, warnings: string[], path: string): string => {
+  if (value === undefined) return fallback
   if (typeof value === "string" && value.trim().length > 0) return value.trim()
   warnings.push(`${path} must be a non-empty string; using ${fallback}`)
   return fallback
@@ -235,6 +246,7 @@ const asEnum = <T extends string>(
   warnings: string[],
   path: string,
 ): T => {
+  if (value === undefined) return fallback
   if (typeof value === "string" && (values as ReadonlyArray<string>).includes(value)) return value as T
   warnings.push(`${path} must be one of ${values.join(", ")}; using ${fallback}`)
   return fallback
@@ -510,6 +522,7 @@ const validateDefinitions = (value: unknown, warnings: string[]): ModelDefinitio
 }
 
 const validateModels = (value: unknown, base: ModelSettings, warnings: string[]): ModelSettings => {
+  if (value === undefined) return base
   if (!isRecord(value)) {
     warnings.push("models must be an object; using defaults")
     return base
@@ -568,7 +581,7 @@ export const validateSettings = (input: unknown, base: RouterSettings = DEFAULT_
 
   const premiumInput = isRecord(input.premium) ? input.premium : {}
   const premium: PremiumSettings = {
-    mode: asEnum(premiumInput.mode, ["off", "ask", "allowed"] as const, base.premium.mode, warnings, "premium.mode"),
+    mode: asEnum(premiumInput.mode, ["off", "ask", "allowed", "auto"] as const, base.premium.mode, warnings, "premium.mode"),
     monthlyBudgetUsd: asNumber(
       premiumInput.monthlyBudgetUsd,
       base.premium.monthlyBudgetUsd,
@@ -715,7 +728,6 @@ export const validateSettings = (input: unknown, base: RouterSettings = DEFAULT_
     "ui.compactMode",
   )
   const ui = {
-    titleIndicator: asBoolean(uiInput.titleIndicator, base.ui.titleIndicator, warnings, "ui.titleIndicator"),
     notifications: asBoolean(uiInput.notifications, base.ui.notifications, warnings, "ui.notifications"),
     compactMode: compactToggle,
     compact: compactToggle,
@@ -942,7 +954,9 @@ export const applyProjectGuardrails = (
           ? "off"
           : globalSettings.premium.mode === "ask" || candidate.premium.mode === "ask"
             ? "ask"
-            : "allowed",
+            : globalSettings.premium.mode === "auto" && candidate.premium.mode === "auto"
+              ? "auto"
+              : "allowed",
       monthlyBudgetUsd: Math.min(globalSettings.premium.monthlyBudgetUsd, candidate.premium.monthlyBudgetUsd),
     },
     providers: Object.fromEntries(
@@ -964,7 +978,10 @@ export const applyProjectGuardrails = (
   if (candidate.privacy.allowTrainingModels && !globalSettings.privacy.allowTrainingModels) {
     warnings.push("Project config tried to enable training models; global privacy setting kept it disabled")
   }
-  if (candidate.premium.mode === "allowed" && globalSettings.premium.mode !== "allowed") {
+  if (
+    (candidate.premium.mode === "allowed" || candidate.premium.mode === "auto") &&
+    globalSettings.premium.mode !== candidate.premium.mode
+  ) {
     warnings.push("Project config tried to enable automatic premium routing; global setting kept it restricted")
   }
   return tightened

package/src/core/models/registry.ts

@@ -54,6 +54,7 @@ const fromSeed = (seed: SeedModel): ModelRecord => ({
   intelligence: seed.intelligence,
   design: seed.design,
   designEvidence: seed.designEvidence ?? "curated",
+  ...(seed.capabilities ? { capabilities: { ...seed.capabilities } } : {}),
   ...(seed.creditMultiplier && seed.creditMultiplier > 0 ? { creditMultiplier: seed.creditMultiplier } : {}),
   ...(seed.protocol ? { protocol: seed.protocol } : {}),
   ...(seed.escalationOnly ? { escalationOnly: true } : {}),

package/src/core/models/seed.ts

@@ -21,6 +21,8 @@ export interface SeedModel {
   /** True when the model is funded from a pool reserved for escalation. */
   escalationOnly?: boolean
   premium?: boolean
+  /** Per-kind capability evidence, passed through with provenance intact. */
+  capabilities?: ModelRecord["capabilities"]
   training?: boolean
   free?: boolean
   tier: 1 | 2 | 3
@@ -511,14 +513,16 @@ const BASE_SEED_MODELS: ReadonlyArray<SeedModel> = [
     maxOutput: 128_000,
     input: ["text", "image", "pdf"],
     cost: tieredCost(cost(2, 10, 0.1, 2.5)[0]!, 272_000, { input: 4, output: 15, read: 0.2, write: 5 }),
-    intelligence: 0,
+    intelligence: 55,
     design: 88,
     designEvidence: "unverified",
+    capabilities: { coding: 56, debugging: 65, agentic: 41, architecture: 86 },
     premium: true,
     tier: 3,
-    approved: false,
+    approved: true,
     monthlyAllowanceUsd: 20,
-    notes: "Unscored in the current model cards. Explicit approval required.",
+    notes:
+      "Intelligence 55 on Artificial Analysis v5.0.1 (2026-11-06). Capabilities: Terminal-Bench 4.0 56 percent, AutomationBench 65 percent, FrontierCode 2.0 41 percent, same index and configuration. Long-context tier doubles input to 4 and raises output to 15 above 272K. Auto-approved for tier-3 escalation by owner instruction 2026-11-06; the Command Code gateway advertises 1.05M but that window is unverified, so treat it as pending a passed probe.",
   },
   {
     key: "commandcode/gpt-6-astra",
@@ -714,8 +718,14 @@ const OPENDESIGN_SEED_MODELS: ReadonlyArray<SeedModel> = OPENDESIGN_MODELS.map((
   intelligence: model.intelligence,
   design: model.design,
   designEvidence: model.designEvidence,
+  // Per-kind benchmark evidence passes through with its provenance intact.
+  ...(model.capabilities ? { capabilities: { ...model.capabilities } } : {}),
   tier: model.tier,
   approved: model.approved,
+  // Plan models (Sonnet, Sol, Opus, Astra) are premium: they draw from the
+  // plan-model pool, which premium policy and its budget govern. Design Plan
+  // models are ordinary allowance, never premium.
+  premium: !OPENDESIGN_DESIGN_PLAN_MODELS.has(model.modelID),
   // Every OpenDesign allowance is a shared provider-level pool, so no model
   // carries its own monthly allowance.
   monthlyAllowanceUsd: 0,

package/src/core/plans/catalog.ts

@@ -102,6 +102,12 @@ export const OPENDESIGN_DESIGN_PLAN_MODELS: ReadonlySet<string> = new Set([
   "claude-haiku-5.5",
   "glm-5.3-flashx",
   "gpt-6-luna",
+  // The gateway serves MiniMax M3.1 Flash both inside and outside the Design
+  // Plan group, and OpenDesign has not published which applies (see the model
+  // note). Treated as Design Plan: it is an ordinary tier-2 workhorse, and
+  // misclassifying it the other way would let a routine model drain the
+  // escalation pool.
+  "minimax-m3.1-flash",
 ])
 
 export const OPENDESIGN_DESIGN_PLAN_POOL = "design-plan"

package/src/core/policy/eligibility.ts

@@ -41,6 +41,34 @@ export const decidePremium = (input: {
   if (mode === "efficiency") {
     return { allowed: false, requiresApproval: false, reason: "Maximum Efficiency locks premium models unless you select one manually." }
   }
+/**
+ * Standing escalation: mode "auto" is the owner's pre-granted approval for
+ * tier-3 work, funded from the plan-model pool while it lasts. Exhaustion
+ * degrades to an approval gate, never a hard block, because a routing refusal
+ * cannot put credits back.
+ */
+  if (premium.mode === "auto") {
+    // Auto escalation is funded from the plan-model pool, and only from it:
+    // auto requires a resolvable pool. Without one (OpenDesign disabled or an
+    // unknown plan), falling back to the legacy premium budget would let auto
+    // spend premium models from other providers that no ledger attributes, so
+    // the gate degrades to an approval request instead.
+    if ((premium.planPoolRemainingUsd ?? 0) > 0) {
+      return {
+        allowed: true,
+        requiresApproval: false,
+        reason: "Auto escalation: the plan-model pool has remaining budget for premium-tier work.",
+      }
+    }
+    return {
+      allowed: false,
+      requiresApproval: true,
+      reason:
+        premium.planPoolRemainingUsd === undefined
+          ? "Auto escalation needs a resolvable plan-model pool (set providers.opendesign.plan); approval is required for this request."
+          : "Auto escalation is out of plan-model budget; approval is required for this request.",
+    }
+  }
   if (session?.premiumOneShot && settings.premium.oneShotApproval) {
     return { allowed: true, requiresApproval: false, reason: "A one-shot premium approval is active for this session." }
   }
@@ -146,7 +174,12 @@ const providerLimitReached = (
     // would break legitimate fallbacks to providers with no quota model at all.
     const providerSettings = settings.providers[providerID]
     const expectedProbe = providerSettings?.enabled === true && providerSettings?.probeUsage === true
-    if (expectedProbe && quotaIsKnown && settings.routing?.failClosed !== false) {
+    // Unconditional, and deliberately not tied to routing.failClosed. That
+    // setting governs what happens when THIS PLUGIN breaks; this check governs
+    // whether it is safe to spend on a provider it cannot see. An owner asking
+    // the router to keep working through its own faults is not asking it to
+    // route into a provider that may be full.
+    if (expectedProbe && quotaIsKnown) {
       return "Provider quota has not been probed yet; refusing rather than assuming it has room"
     }
     return undefined
@@ -391,6 +424,25 @@ export const evaluateEligibility = (input: EligibilityInput): EligibilityResult
     }
   }
 
+  // The mirror gate: while escalation is available, tier-3 work draws on the
+  // plan-model pool and ordinary models stand down. A tier-3 task served by a
+  // standard model runs at ~0.7 expected success by construction - that is
+  // precisely the situation the pool exists to prevent, and no cost ranking
+  // should be able to quietly trade 24 points of success probability for a
+  // few cents. "Insufficient benefit" is answered by the classifier (a task
+  // ordinary models serve well is not classified tier 3) and by the budget
+  // gate (escalation that cannot be paid for does not happen), not by letting
+  // a cheap model absorb hard work. When this gate leaves no route at all,
+  // the engine's premiumFallback deliberately picks the strongest ordinary
+  // model, so exhaustion degrades instead of failing the task.
+  if (task.tier === 3 && premium.allowed && !model.premium) {
+    return {
+      eligible: false,
+      reason: "Premium-tier work escalates to the plan-model pool while escalation budget remains",
+      warnings,
+    }
+  }
+
   // An escalation pool is capacity, not routine allowance. When an
   // ordinary-allowance route can already serve the task, spending the
   // escalation pool on it converts a cheap request into a scarce one.

package/src/core/providers/opendesign-models.ts

@@ -53,6 +53,20 @@ export interface OpenDesignModelSpec {
   readonly tier: 1 | 2 | 3
   readonly approved: boolean
   readonly notes: string
+  /**
+   * Per-kind capability evidence. An absent axis means "not measured", never
+   * zero, and each entry's provenance is named alongside it.
+   */
+  readonly capabilities?: {
+    /** Agentic coding benchmark, percent. */
+    readonly coding?: number
+    /** Complex-debugging / automation benchmark, percent. */
+    readonly debugging?: number
+    /** Long-horizon autonomous-execution benchmark, percent. */
+    readonly agentic?: number
+    /** Curated architectural-reasoning score, same 0-100 scale. */
+    readonly architecture?: number
+  }
 }
 
 const cost = (input: number, output: number, read: number, write = 0): CostTier[] => [
@@ -107,6 +121,7 @@ const spec = (
     tier: extra.tier,
     approved: extra.approved,
     notes: extra.notes,
+    ...(extra.capabilities ? { capabilities: extra.capabilities } : {}),
   }
 }
 
@@ -298,7 +313,11 @@ export const OPENDESIGN_MODELS: ReadonlyArray<OpenDesignModelSpec> = [
   // windows. Only available on Plus, Pro and Max.
   // ---------------------------------------------------------------------------
   spec("claude-sonnet-5.5", "Claude Sonnet 5.5", {
-    context: 328_000,
+    // Probed 2026-11-06: one request with 819,383 random-filler prompt tokens
+    // returned 200, finish stop, all three mid-document sentinels retrieved,
+    // $1.62. The catalog is raised to the smallest probed-verified figure,
+    // rounded down; the advertised 1M is NOT assumed from an 800K pass.
+    context: 800_000,
     maxOutput: 128_000,
     input: ["text", "image", "pdf"],
     cost: cost(2, 10, 0.2, 2.5),
@@ -306,9 +325,10 @@ export const OPENDESIGN_MODELS: ReadonlyArray<OpenDesignModelSpec> = [
     design: 90,
     designEvidence: "curated",
     tier: 3,
-    approved: false,
+    approved: true,
+    capabilities: { coding: 64, debugging: 72, agentic: 42, architecture: 88 },
     notes:
-      "Plan model. Premier design and architecture quality. Funded from plan model credits, so routing here consumes escalation capacity rather than routine allowance.",
+      "Plan model. Premier design and architecture quality. Funded from plan model credits, so routing here consumes escalation capacity rather than routine allowance. Capabilities: Terminal-Bench 4.0 64 percent, AutomationBench 72 percent, FrontierCode 2.0 42 percent (Artificial Analysis v5.0.1, 2026-11-06, max reasoning; independent evaluations, not guarantees); architecture 88 curated. Auto-approved for tier-3 escalation by owner instruction 2026-11-06. Context probed 2026-11-06: 800K verified end-to-end (819,383 prompt tokens accepted, sentinels at start/middle/end retrieved, no truncation, $1.62); advertised 1M remains unverified.",
   }),
   spec("gpt-6-sol", "GPT-6 Sol", {
     context: 304_000,
@@ -323,16 +343,22 @@ export const OPENDESIGN_MODELS: ReadonlyArray<OpenDesignModelSpec> = [
     notes: "Plan model. Unscored in the router's curated set. Explicit approval required.",
   }),
   spec("gpt-6.1-sol", "GPT-6.1 Sol", {
-    context: 400_000,
+    // Probed 2026-11-06: one request with 820,701 prompt tokens returned 200,
+    // finish stop, all three sentinels retrieved, $2.74 - and the long-context
+    // surcharge (input $4/M above 272K) was billed, confirming tiered pricing
+    // applies exactly as cataloged. Raised to 800K (verified), not 1M.
+    context: 800_000,
     maxOutput: 128_000,
     input: ["text", "image", "pdf"],
     cost: tieredCost(cost(2, 10, 0.1, 2.5)[0]!, 272_000, { input: 4, output: 15, read: 0.2, write: 5 }),
-    intelligence: 0,
+    intelligence: 55,
     design: 88,
     designEvidence: "unverified",
     tier: 3,
-    approved: false,
-    notes: "Plan model. Unscored. Explicit approval required.",
+    approved: true,
+    capabilities: { coding: 56, debugging: 65, agentic: 41, architecture: 86 },
+    notes:
+      "Plan model. Intelligence 55 on Artificial Analysis v5.0.1 (2026-11-06), tied with Sonnet 5.5 on that index; the per-kind capabilities break the tie toward Sonnet for agentic coding. Sol used far fewer generated tokens on the same suite, so it stays the cheaper tier-3 route on short fresh contexts. Capabilities: Terminal-Bench 4.0 56 percent, AutomationBench 65 percent, FrontierCode 2.0 41 percent, same index and configuration. Architecture 86 curated. Long-context tier doubles input to 4 and raises output to 15 above 272K. Auto-approved for tier-3 escalation by owner instruction 2026-11-06. Context probed 2026-11-06: 800K verified end-to-end (820,701 prompt tokens accepted with sentinels retrieved, no truncation, $2.74 billed at the tiered long-context rate); advertised 1M remains unverified.",
   }),
   spec("gpt-6-astra", "GPT-6 Astra", {
     context: 400_000,

package/src/core/quota/ledger.ts

@@ -83,6 +83,7 @@ export const emptyMetrics = (now = Date.now()): Metrics => ({
   dryRunDecisions: 0,
   premiumRequests: 0,
   premiumUsd: 0,
+  planPoolUsd: 0,
   latencyMsTotal: 0,
   latencySamples: 0,
   failures: emptyFailureCounts(),
@@ -108,6 +109,7 @@ export const emptyLedger = (now = Date.now()): Ledger => ({
   version: LEDGER_VERSION,
   usage: [],
   premiumSpend: [],
+  planPoolSpend: [],
   sessions: {},
   decisions: [],
   metrics: emptyMetrics(now),
@@ -374,6 +376,12 @@ export const hydrateLedger = (value: unknown): { ledger: Ledger; warnings: strin
           .map((entry) => ({ month: String(entry.month ?? ""), usd: Math.max(0, finite(entry.usd)) }))
           .filter((entry) => entry.month)
       : [],
+    planPoolSpend: Array.isArray(value.planPoolSpend)
+      ? value.planPoolSpend
+          .filter(isRecord)
+          .map((entry) => ({ month: String(entry.month ?? ""), usd: Math.max(0, finite(entry.usd)) }))
+          .filter((entry) => entry.month)
+      : [],
     sessions,
     decisions: decisions.slice(0, MAX_DECISIONS),
     metrics: {
@@ -392,6 +400,7 @@ export const hydrateLedger = (value: unknown): { ledger: Ledger; warnings: strin
       dryRunDecisions: Math.max(0, finite(metrics.dryRunDecisions)),
       premiumRequests: Math.max(0, finite(metrics.premiumRequests)),
       premiumUsd: Math.max(0, finite(metrics.premiumUsd)),
+      planPoolUsd: Math.max(0, finite(metrics.planPoolUsd)),
       latencyMsTotal: Math.max(0, finite(metrics.latencyMsTotal)),
       latencySamples: Math.max(0, finite(metrics.latencySamples)),
       lastLatencyMs: typeof metrics.lastLatencyMs === "number" ? metrics.lastLatencyMs : undefined,
@@ -417,6 +426,8 @@ export interface StepUsage {
   readonly at?: number
   readonly latencyMs?: number
   readonly premium?: boolean
+  /** True when this step drew from the plan-model pool (escalation allowance). */
+  readonly planPool?: boolean
 }
 
 export interface BootstrapSession {
@@ -565,6 +576,25 @@ export class LedgerStore {
     return this.ledger.premiumSpend.find((entry) => entry.month === month)?.usd ?? 0
   }
 
+  /**
+   * Spend against the plan-model pool (the escalation allowance), tracked in
+   * its own monthly buckets so the $120 pool gate reads one number that
+   * survives restarts. Premium spend that is not plan-pool spend - Command
+   * Code GOAT flagships on their own allowances - never lands here.
+   */
+  planPoolSpent(month = monthKey()) {
+    return this.ledger.planPoolSpend.find((entry) => entry.month === month)?.usd ?? 0
+  }
+
+  private addPlanPoolSpend(usd: number, at: number) {
+    if (usd <= 0) return
+    const month = monthKey(at)
+    const existing = this.ledger.planPoolSpend.find((entry) => entry.month === month)
+    if (existing) existing.usd += usd
+    else this.ledger.planPoolSpend.push({ month, usd })
+    this.ledger.metrics.planPoolUsd += usd
+  }
+
   private addPremiumSpend(usd: number) {
     if (usd <= 0) return
     const month = monthKey()
@@ -626,6 +656,7 @@ export class LedgerStore {
       }
     }
     if (input.premium) this.addPremiumSpend(event.usd)
+    if (input.planPool) this.addPlanPoolSpend(event.usd, at)
 
     const session = this.ensureSession(input.sessionID)
     session.lastModel = input.model