@oisin-ee/oisinpi 0.7.2 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @oisin-ee/oisinpi
 
+## 0.9.0
+
+### Minor Changes
+
+- [#21](https://github.com/oisin-ee/oisinpi/pull/21) [`5e80e12`](https://github.com/oisin-ee/oisinpi/commit/5e80e1209af813427b16049c77de3f068d928fd1) Thanks [@momo-momokaya](https://github.com/apps/momo-momokaya)! - Add sticky tier virtual models with bounded recovery, shared gateway circuits, and quota-aware pool selection.
+
+### Patch Changes
+
+- Updated dependencies [[`5e80e12`](https://github.com/oisin-ee/oisinpi/commit/5e80e1209af813427b16049c77de3f068d928fd1)]:
+  - @oisin-ee/pi-tiers@0.9.0
+  - @oisin-ee/pi-guardrails@0.9.0
+  - @oisin-ee/pi-prewalk@0.9.0
+  - @oisin-ee/pi-todo@0.9.0
+
+## 0.8.0
+
+### Patch Changes
+
+- Updated dependencies [[`50877ec`](https://github.com/oisin-ee/oisinpi/commit/50877ec0f9bba71b7f70d8bf8d3754191ac73364)]:
+  - @oisin-ee/pi-todo@0.8.0
+  - @oisin-ee/pi-prewalk@0.8.0
+  - @oisin-ee/pi-guardrails@0.8.0
+
 ## 0.7.2
 
 ### Patch Changes

package/node_modules/@oisin-ee/pi-guardrails/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-guardrails",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Agent guardrails for pi, Claude Code, and Codex: Git safety, no waiting, no typing into other agents, GitOps-only clusters.",
   "keywords": [
     "claude-code",

package/node_modules/@oisin-ee/pi-prewalk/README.md

@@ -1,6 +1,7 @@
 # @oisin-ee/pi-prewalk
 
-Prewalk starts with the active planner model. After the planning nudge, a successful `todo` call opens the handoff gate.
+Prewalk starts with the active planner model. After the planning nudge, validated local task activation opens the handoff gate.
+Without the task-provider capability, a successful `todo` call opens the gate instead. Imported workers need no bookkeeping call.
 The first subsequent `edit` or `write` result switches the session to the target model, even if that result failed.
 Nested calls through codemode also count. Without a callable `todo` tool, the gate is open.
 

package/node_modules/@oisin-ee/pi-prewalk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-prewalk",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "A one-shot planner-to-executor handoff for pi, with branch-backed Rust rules.",
   "keywords": [
     "pi-extension",

package/node_modules/@oisin-ee/pi-prewalk/src/adapter.ts

@@ -4,6 +4,7 @@ import type { BoundaryResult, SessionBoundaryDraft } from "@earendil-works/pi-co
 import type { Context, Files, Host } from "./ports.ts";
 import { branchRecords, calls } from "./branch.ts";
 import type { CallEvidence } from "./branch.ts";
+import { activeTask } from "./tasks.ts";
 import { decide } from "./wasm.ts";
 
 /**
@@ -117,6 +118,7 @@ class Adapter {
           todo.exposure === "deferred" ||
           this.#pi.getActiveTools().includes("todo"));
     return {
+      active_unit: activeTask(this.#pi.events),
       available: ctx.modelRegistry
         .getAvailable()
         .map((candidate) => `${candidate.provider}/${candidate.id}`),

package/node_modules/@oisin-ee/pi-prewalk/src/generated/prewalk_core.d.ts

@@ -55,6 +55,10 @@ export interface Facts {
      * Is todo callable (directly or through codemode)?
      */
     todo: boolean;
+    /**
+     * Current provider activation; absent preserves the legacy successful-todo rule.
+     */
+    active_unit?: boolean | undefined;
     /**
      * Todo source identity for status.
      */

package/node_modules/@oisin-ee/pi-prewalk/src/ports.ts

@@ -12,7 +12,7 @@ type Host = Pick<
   | "getThinkingLevel"
   | "setThinkingLevel"
   | "setModel"
->;
+> & { readonly events: Readonly<ExtensionAPI["events"]> };
 /** Read-only pi facts. */
 interface Context {
   readonly cwd: string;

package/node_modules/@oisin-ee/pi-prewalk/src/tasks.ts

@@ -0,0 +1,48 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+interface ActiveProvider {
+  readonly active: () => unknown;
+}
+
+/**
+ * Validates only the capability method this consumer needs.
+ * @param {unknown} value Capability response.
+ * @returns {boolean} Whether the active query is callable.
+ */
+const isProvider = (value: unknown): value is ActiveProvider =>
+    typeof value === "object" &&
+    value !== null &&
+    "active" in value &&
+    typeof value.active === "function",
+  /**
+   * Queries current activation without loading todo or interpreting its snapshots.
+   * @param {Readonly<ExtensionAPI["events"]>} events Extension capability bus.
+   * @returns {boolean | undefined} Activation, or unavailable legacy capability.
+   */
+  activeTask = (events: Readonly<ExtensionAPI["events"]>): boolean | undefined => {
+    const replies: unknown[] = [];
+    events.emit("oisin.tasks.acquire.v1", {
+      reply: (provider: unknown): void => {
+        replies.push(provider);
+      },
+      version: 1,
+    });
+    const [provider] = replies,
+      one = 1;
+    if (replies.length !== one || !isProvider(provider)) {
+      return undefined;
+    }
+    const result: unknown = provider.active();
+    if (
+      typeof result !== "object" ||
+      result === null ||
+      !("ok" in result) ||
+      result.ok !== true ||
+      !("value" in result)
+    ) {
+      return undefined;
+    }
+    return result.value !== null && result.value !== undefined;
+  };
+
+export { activeTask };

package/node_modules/@oisin-ee/pi-tiers/README.md

@@ -0,0 +1,65 @@
+# @oisin-ee/pi-tiers
+
+Tier virtual models keep each branch on its chosen physical model until a failure requires recovery.
+The selected thinking level passes through to the physical model. Pi clamps unsupported levels.
+A model switch loses prompt caches and thinking signatures.
+
+## Config
+
+Put `tiers.json` in the Pi agent directory (`~/.pi/agent` by default):
+
+```json
+{
+  "sol": ["cliproxy/gpt-5.6", "cliproxy/claude-opus-4-6"],
+  "luna": ["cliproxy/minimax-m3", "cliproxy/gpt-5.6"]
+}
+```
+
+Select `tier/sol` or `tier/luna`. Each target must identify a configured physical model.
+An absent file registers no tiers. Invalid config stops registration. Reload Pi after config changes.
+This package does not load `model-alias.json` or register `alias/*` models.
+
+## Recovery
+
+Gateway failures open a provider-wide circuit. Recovery waits, then retries the same target.
+The delay starts at two seconds and doubles to one minute. Gateway failures never cool individual models or pools.
+
+Quota failures exclude a pool. Model IDs that start with `claude-`, `gpt-`, or `minimax-` use the corresponding shared pool.
+Other models use their provider ID as the pool.
+The snapshot reset time controls the exclusion when the pool is exhausted.
+Without that reset, cooldown starts at five minutes and doubles to one hour.
+
+Pi handles native transient retries first. After native retries end, boundary recovery selects the next target.
+Unknown models and request, authentication, or configuration failures stop without failover. Abort never requests recovery.
+Each user turn permits two recoveries. Native transient retries retain Pi's separate retry budget.
+
+Boundary recovery removes only the failed assistant entry from model context.
+A state-only custom entry records the next route. Recovery never creates user messages or rewrites their text.
+The chosen target, attempted targets, and remaining budget follow the session branch.
+
+## Quota and shared state
+
+Before routing, the extension runs `dogsled quota --json --cached` with a two-second timeout.
+The result stays in memory for one minute. Missing Dogsled or an invalid snapshot disables quota filtering.
+The command never requests a CLIProxy refresh.
+
+A pool is exhausted only when every account has a full window with a future reset.
+For multiple blocked windows, an account becomes available after its last reset.
+The first available account ends the pool exclusion.
+
+The shared store is `~/.pi/agent/state/pi-tiers/state.json`.
+An exclusive `lock/` directory protects each read-modify-write transaction. Its `owner.json` records the process ID and creation time.
+A temporary state file and atomic rename protect readers. Lock acquisition stops after two seconds.
+A dead owner or a lock older than 30 seconds permits takeover through atomic directory rename.
+An ownerless directory also expires after 30 seconds. Retired generations remain for 60 seconds to exclude competing takeovers.
+Invalid state and filesystem failures stop routing rather than discard shared health.
+
+Pi 1.3.0 response events contain no model or request identity.
+HTTP status applies only when an error includes the response's `x-request-id` or `request-id` value.
+Otherwise, the classifier uses error text. Unrelated response status never affects routing.
+
+## Development
+
+```bash
+proto run moon -- run pi-tiers:lint pi-tiers:test
+```

package/node_modules/@oisin-ee/pi-tiers/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@oisin-ee/pi-tiers",
+  "version": "0.9.0",
+  "description": "Sticky virtual model tiers with quota-aware recovery for pi.",
+  "keywords": [
+    "pi-extension",
+    "pi-package",
+    "tiers"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oisin-ee/oisinpi.git",
+    "directory": "packages/pi-tiers"
+  },
+  "files": [
+    "src/",
+    "!src/**/*.test.ts",
+    "!src/fixture.ts"
+  ],
+  "type": "module",
+  "devDependencies": {
+    "@earendil-works/pi-ai": "catalog:",
+    "@earendil-works/pi-coding-agent": "catalog:"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  }
+}

package/node_modules/@oisin-ee/pi-tiers/src/branch.ts

@@ -0,0 +1,75 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { State } from "./policy.ts";
+import { VIRTUAL_MODEL_STATE_ENTRY } from "@earendil-works/pi-coding-agent";
+
+const ZERO = 0,
+  RECOVERY = "pi-tiers.recovery",
+  /**
+   * Validates branch data before policy uses it.
+   * @param {unknown} value Stored state.
+   * @returns {boolean} Valid state.
+   */
+  isState = (value: unknown): value is State =>
+    typeof value === "object" &&
+    value !== null &&
+    "chosen" in value &&
+    typeof value.chosen === "string" &&
+    "budget" in value &&
+    typeof value.budget === "number" &&
+    Number.isSafeInteger(value.budget) &&
+    value.budget >= ZERO &&
+    "attempted" in value &&
+    Array.isArray(value.attempted) &&
+    value.attempted.every((item: unknown) => typeof item === "string"),
+  /**
+   * Reads state for one tier, including an unconsumed recovery marker.
+   * A subsequent Pi state entry consumes the marker without editing history.
+   * @param {readonly SessionEntry[]} branch Active branch.
+   * @param {string} tier Virtual model ID.
+   * @returns {State | undefined} Latest branch-owned state.
+   */
+  branchState = (branch: readonly SessionEntry[], tier: string): State | undefined => {
+    for (const entry of branch.toReversed()) {
+      if (
+        entry.type === "custom" &&
+        (entry.customType === VIRTUAL_MODEL_STATE_ENTRY || entry.customType === RECOVERY)
+      ) {
+        const data: unknown = entry.data;
+        if (
+          typeof data === "object" &&
+          data !== null &&
+          "provider" in data &&
+          data.provider === "tier" &&
+          "modelId" in data &&
+          data.modelId === tier &&
+          "state" in data &&
+          isState(data.state)
+        ) {
+          return data.state;
+        }
+      }
+    }
+    return undefined;
+  },
+  /**
+   * Detects a real user entry after the latest route or recovery marker.
+   * Pi can label recovery as user after the failed assistant is omitted.
+   * @param {readonly SessionEntry[]} branch Active branch.
+   * @returns {boolean} Whether a fresh user turn started.
+   */
+  newUserTurn = (branch: readonly SessionEntry[]): boolean => {
+    for (const entry of branch.toReversed()) {
+      if (entry.type === "message" && entry.message.role === "user") {
+        return true;
+      }
+      if (
+        entry.type === "custom" &&
+        (entry.customType === RECOVERY || entry.customType === VIRTUAL_MODEL_STATE_ENTRY)
+      ) {
+        return false;
+      }
+    }
+    return false;
+  };
+
+export { branchState, newUserTurn, RECOVERY };

package/node_modules/@oisin-ee/pi-tiers/src/config.ts

@@ -0,0 +1,48 @@
+import { target } from "./policy.ts";
+
+/** Validated tier names and ordered physical targets. */
+type Tiers = ReadonlyMap<string, readonly string[]>;
+
+const ZERO = 0,
+  /**
+   * Validates a tier's ordered model references.
+   * @param {string} name Tier name.
+   * @param {unknown} models External list.
+   * @returns {readonly string[]} Unique physical targets.
+   */
+  parseTargets = (name: string, models: unknown): readonly string[] => {
+    if (
+      name.length === ZERO ||
+      !Array.isArray(models) ||
+      models.length === ZERO ||
+      !models.every((model: unknown): model is string => typeof model === "string")
+    ) {
+      throw new Error(`Invalid tier: ${name}`);
+    }
+    for (const model of models) {
+      target(model);
+    }
+    return [...new Set(models)];
+  },
+  /**
+   * Validates user config before registration.
+   * @param {string | undefined} source User JSON.
+   * @returns {Tiers} Tier definitions.
+   */
+  parseConfig = (source?: string): Tiers => {
+    if (source === undefined) {
+      return new Map();
+    }
+    const value: unknown = JSON.parse(source);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new Error("tiers.json must contain a tier-to-model map.");
+    }
+    const tiers = new Map<string, readonly string[]>();
+    for (const [name, models] of Object.entries(value)) {
+      tiers.set(name, parseTargets(name, models));
+    }
+    return tiers;
+  };
+
+export { parseConfig };
+export type { Tiers };

package/node_modules/@oisin-ee/pi-tiers/src/health.ts

@@ -0,0 +1,92 @@
+/** Backoff record shared by all sessions on one host. */
+interface Backoff {
+  readonly failures: number;
+  readonly until: number;
+}
+/** Provider circuits and pool cooldowns have separate namespaces. */
+interface Health {
+  readonly circuits: Readonly<Record<string, Backoff>>;
+  readonly pools: Readonly<Record<string, Backoff>>;
+}
+/** One atomic update to shared health. */
+interface Change {
+  readonly kind: "gateway" | "quota";
+  readonly key: string;
+  readonly now: number;
+  readonly reset: number | undefined;
+}
+
+const ZERO = 0,
+  ONE = 1,
+  TWO = 2,
+  QUOTA_DELAY = 300_000,
+  QUOTA_MAX = 3_600_000,
+  GATEWAY_DELAY = 2000,
+  GATEWAY_MAX = 60_000,
+  /**
+   * Creates an empty health store.
+   * @returns {Health} Healthy endpoints and pools.
+   */
+  emptyHealth = (): Health => ({ circuits: {}, pools: {} }),
+  /**
+   * Computes exponential backoff while preserving distinct failure domains.
+   * @param {Health} health Current store.
+   * @param {Change} change Failure observation.
+   * @returns {Health} Updated store.
+   */
+  updateHealth = (health: Health, change: Change): Health => {
+    const namespace = change.kind === "gateway" ? "circuits" : "pools",
+      previous = health[namespace][change.key],
+      base = change.kind === "gateway" ? GATEWAY_DELAY : QUOTA_DELAY,
+      maximum = change.kind === "gateway" ? GATEWAY_MAX : QUOTA_MAX,
+      failures = (previous?.failures ?? ZERO) + ONE,
+      delay = Math.min(maximum, base * TWO ** (failures - ONE)),
+      record = { failures, until: change.reset ?? change.now + delay };
+    return Object.assign({}, health, {
+      [namespace]: Object.assign({}, health[namespace], { [change.key]: record }),
+    });
+  },
+  /**
+   * Validates persisted backoff records.
+   * @param {unknown} value External map.
+   * @returns {boolean} Whether all records are valid.
+   */
+  isBackoffs = (value: unknown): value is Record<string, Backoff> =>
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.values(value).every(
+      (entry: unknown) =>
+        typeof entry === "object" &&
+        entry !== null &&
+        "failures" in entry &&
+        typeof entry.failures === "number" &&
+        Number.isSafeInteger(entry.failures) &&
+        entry.failures >= ZERO &&
+        "until" in entry &&
+        typeof entry.until === "number" &&
+        Number.isSafeInteger(entry.until) &&
+        entry.until >= ZERO,
+    ),
+  /**
+   * Rejects corrupt stores rather than silently discarding cooldowns.
+   * @param {string} source Persisted JSON.
+   * @returns {Health} Validated health state.
+   */
+  parseHealth = (source: string): Health => {
+    const value: unknown = JSON.parse(source);
+    if (
+      typeof value !== "object" ||
+      value === null ||
+      !("circuits" in value) ||
+      !("pools" in value) ||
+      !isBackoffs(value.circuits) ||
+      !isBackoffs(value.pools)
+    ) {
+      throw new Error("Invalid pi-tiers health state.");
+    }
+    return { circuits: value.circuits, pools: value.pools };
+  };
+
+export { emptyHealth, parseHealth, updateHealth };
+export type { Change, Health };

package/node_modules/@oisin-ee/pi-tiers/src/index.ts

@@ -0,0 +1,70 @@
+import type {
+  AfterProviderResponseEvent,
+  ExtensionAPI,
+  ModelRoute,
+} from "@earendil-works/pi-coding-agent";
+import { Store, readConfig, wait } from "./source.ts";
+import type { Health } from "./health.ts";
+import { Recovery } from "./recovery.ts";
+import type { Request } from "./ports.ts";
+import { Router } from "./router.ts";
+import type { State } from "./policy.ts";
+import { parseConfig } from "./config.ts";
+
+const QUOTA_TIMEOUT = 2000,
+  SUCCESS = 0,
+  /**
+   * Registers user-defined tiers and the final-boundary recovery adapter.
+   * @param {ExtensionAPI} pi Pi extension authority.
+   * @returns {Promise<void>} Registration completion.
+   */
+  extension = async (pi: ExtensionAPI): Promise<void> => {
+    const tiers = parseConfig(await readConfig()),
+      store = new Store(),
+      router = new Router({
+        change: async (change): Promise<void> => store.change(change),
+        now: Date.now,
+        quota: async (): Promise<string> => {
+          try {
+            const result = await pi.exec("dogsled", ["quota", "--json", "--cached"], {
+              timeout: QUOTA_TIMEOUT,
+            });
+            return result.code === SUCCESS ? result.stdout : "";
+          } catch {
+            return "";
+          }
+        },
+        read: async (): Promise<Health> => store.read(),
+        wait,
+      }),
+      recovery = new Recovery(router, tiers);
+    for (const [id, targets] of tiers) {
+      pi.registerVirtualModel<State>({
+        id,
+        name: `Tier: ${id}`,
+        provider: "tier",
+        route: async (request: Request, ctx): Promise<ModelRoute<State>> =>
+          router.route(targets, request, ctx),
+        thinkingLevels: ["off", "minimal", "low", "medium", "high", "xhigh", "max"],
+      });
+    }
+    pi.on(
+      "after_provider_response",
+      (
+        event: Readonly<Omit<AfterProviderResponseEvent, "headers">> & {
+          readonly headers: Readonly<Record<string, string>>;
+        },
+      ) => {
+        router.responses.observe(event.headers, event.status);
+      },
+    );
+    pi.on("agent_before_settle", async (event, ctx) => recovery.settle(event, ctx));
+    pi.on("agent_settled", () => {
+      router.responses.clear();
+    });
+    pi.on("session_start", () => {
+      router.responses.clear();
+    });
+  };
+
+export default extension;

package/node_modules/@oisin-ee/pi-tiers/src/lock.ts

@@ -0,0 +1,53 @@
+/** A lock generation identifies its owning process and creation time. */
+interface Owner {
+  readonly created_ms: number;
+  readonly pid: number;
+}
+
+const ZERO = 0,
+  STALE_MS = 30_000,
+  RETIRED_MS = 60_000,
+  /**
+   * Validates lock metadata before process checks or path construction.
+   * @param {string} source Owner JSON.
+   * @returns {Owner | undefined} Complete metadata, or an interrupted write.
+   */
+  parseOwner = (source: string): Owner | undefined => {
+    try {
+      const value: unknown = JSON.parse(source);
+      if (
+        typeof value !== "object" ||
+        value === null ||
+        !("pid" in value) ||
+        !("created_ms" in value) ||
+        typeof value.pid !== "number" ||
+        !Number.isSafeInteger(value.pid) ||
+        value.pid <= ZERO ||
+        typeof value.created_ms !== "number" ||
+        !Number.isSafeInteger(value.created_ms) ||
+        value.created_ms < ZERO
+      ) {
+        return undefined;
+      }
+      return { created_ms: value.created_ms, pid: value.pid };
+    } catch {
+      return undefined;
+    }
+  },
+  /**
+   * Names a retired generation without using untrusted path fragments.
+   * @param {Owner} owner Observed generation.
+   * @returns {string} Tombstone directory name.
+   */
+  retiredName = (owner: Owner): string => `retired-${owner.pid}-${owner.created_ms}`,
+  /**
+   * Compares a fresh observation with a previously observed generation.
+   * @param {Owner | undefined} current Fresh metadata.
+   * @param {Owner} expected Original metadata.
+   * @returns {boolean} Whether retirement still applies.
+   */
+  sameOwner = (current: Owner | undefined, expected: Owner): boolean =>
+    current?.pid === expected.pid && current.created_ms === expected.created_ms;
+
+export { parseOwner, RETIRED_MS, retiredName, sameOwner, STALE_MS };
+export type { Owner };

package/node_modules/@oisin-ee/pi-tiers/src/policy.ts

@@ -0,0 +1,85 @@
+/** Failure classes control recovery, not provider retry settings. */
+type Failure = "gateway" | "quota" | "transient" | "request";
+/** Durable router state on one session branch. */
+interface State {
+  readonly attempted: readonly string[];
+  readonly budget: number;
+  readonly chosen: string;
+}
+/** Parsed physical model reference. */
+interface Target {
+  readonly id: string;
+  readonly pool: string;
+  readonly provider: string;
+}
+
+const ZERO = 0,
+  ONE = 1,
+  BAD_GATEWAY = 502,
+  UNAVAILABLE = 503,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  FORBIDDEN = 403,
+  BUDGET = 2,
+  QUOTA_STATUS = 429,
+  GATEWAY_STATUSES = new Set([BAD_GATEWAY, UNAVAILABLE]),
+  REQUEST_STATUSES = new Set([BAD_REQUEST, UNAUTHORIZED, FORBIDDEN]),
+  /**
+   * Classifies exactly once, with permanent failures taking precedence.
+   * @param {string} message Provider error text.
+   * @param {number | undefined} status Correlated HTTP status.
+   * @returns {Failure} Recovery class.
+   */
+  classify = (message: string, status?: number): Failure => {
+    if (
+      REQUEST_STATUSES.has(status ?? ZERO) ||
+      /unknown model|\b(?:status|code|HTTP)\s*:?\s*(?:400|401|403)\b|unauthorized|forbidden/iu.test(
+        message,
+      )
+    ) {
+      return "request";
+    }
+    if (
+      GATEWAY_STATUSES.has(status ?? ZERO) ||
+      /\b(?:status|code|HTTP)\s*:?\s*(?:502|503)\b|no available server|bad gateway|unable to connect/iu.test(
+        message,
+      )
+    ) {
+      return "gateway";
+    }
+    if (
+      status === QUOTA_STATUS ||
+      /\b(?:status|code|HTTP)\s*:?\s*429\b|usage.limit|rate_limit|insufficient_quota|quota exceeded/iu.test(
+        message,
+      )
+    ) {
+      return "quota";
+    }
+    return /overloaded|timeout|timed out|websocket.*1006|server_busy|retry after/iu.test(message)
+      ? "transient"
+      : "request";
+  },
+  /**
+   * Parses a provider-qualified model and assigns its quota pool.
+   * @param {string} reference Model reference.
+   * @returns {Target} Physical target.
+   */
+  target = (reference: string): Target => {
+    const separator = reference.indexOf("/"),
+      provider = reference.slice(ZERO, separator),
+      id = reference.slice(separator + ONE);
+    if (separator < ONE || id.length === ZERO) {
+      throw new Error(`Invalid tier target: ${reference}`);
+    }
+    const pools = [
+        ["claude-", "claude"],
+        ["gpt-", "codex"],
+        ["minimax-", "minimax"],
+      ],
+      pool =
+        pools.find(([prefix]: readonly string[]) => id.startsWith(prefix ?? ""))?.[ONE] ?? provider;
+    return { id, pool, provider };
+  };
+
+export { BUDGET, classify, target };
+export type { Failure, State, Target };