@oh-my-pi/pi-catalog 18.0.11 → 18.1.0

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 ## [Unreleased]
 
+## [18.1.0] - 2026-09-01
+
+### Added
+
+- Added GitLab Duo model support.
+- Added provider support for Llama.cpp, LM Studio, and Minimax.
+- Added catalog entries for Qwen 3.8 27B, Granite 4.2 8B, Abliterated variants, GLM 5.3, and Qwen 3.8 Flash Next.
+- Added compatibility metadata for context management and reasoning summaries on supported provider-compatible model endpoints.
+- Added the native ClinePass provider with live model discovery, subscription and free-tier model listings, current limits and pricing, model modalities, and per-model reasoning controls. Subscription models display API-equivalent pricing while free-tier models display as free.
+- Added native Devin provider discovery with current Cascade model capabilities, pricing, limits, reasoning controls, selector aliases, and model descriptions and recommendation/beta metadata. Added static SWE-1.6 defaults so the provider can resolve a default model before account-scoped discovery completes.
+- Added per-tier model pricing and long-context pricing support, along with expanded catalog metadata for model limits, API routes, input modalities, and provider-specific model aliases.
+
+### Changed
+
+- Updated pricing data across the catalog to reflect current provider rates.
+- Standardized model display names for greater consistency.
+- Improved model compatibility classification and variant selection using structured model identities, providing more reliable detection of model families, revisions, reasoning variants, and provider-specific capabilities.
+
+### Fixed
+
+- Fixed compatibility detection for vendor-prefixed GLM models on Mistral and Cerebras, restoring the appropriate tokenizer and reasoning-history behavior.
+- Removed an obsolete OpenCode provider entry that exposed unavailable Zen models in the model picker.
+- Fixed model revision detection for parameterized model IDs, including correct classification of Qwen, Fireworks Kimi, and Cursor-wrapped Grok models.
+- Fixed Kimi K3 reasoning-effort handling on OpenAI-compatible hosts such as LiteLLM and vLLM.
+- Fixed pricing for Codex Daybreak aliases, including worker variants.
+- Fixed reasoning-effort variants for local Ollama models and DeepSeek V4, and corrected prompt-cache support for applicable Bedrock Nova deployments.
+- Fixed Devin model variants with separate thinking and context-size options so all supported routing combinations and context limits are preserved.
+- Corrected Devin SWE-1.6 and SWE-1.6 Fast capability metadata so image attachments use the appropriate text-only fallback instead of being silently discarded.
+- Devin discovery now warns when the service returns an empty native model catalog, helping identify stale or incompatible CLI credentials.
+
+### Removed
+
+- Removed legacy DeepSeek V3 variants from the Novita catalog.
+
 ## [18.0.11] - 2026-08-29
 
 ### Fixed
@@ -869,7 +903,7 @@
 
 ### Fixed
 
-- Fixed direct Anthropic Claude Sonnet/Haiku 4.5 advisor/agent turns crashing every call with HTTP 400 `This model does not support the effort parameter.` The catalog classified the whole Claude 4.5 family on `anthropic-messages` (and `bedrock-converse-stream`) as `anthropic-budget-effort`, which made the Anthropic provider serialize `output_config.effort` alongside `thinking.budget_tokens`. Anthropic only honors `output_config.effort` on Opus 4.5 and adaptive (4.6+) Messages-API models, so Sonnet 4.5 / Haiku 4.5 rejected the field. `inferThinkingControlMode` now gates `anthropic-budget-effort` to `parsedModel.kind === "opus" && semverGte(version, "4.5")` on both Anthropic-routed APIs, so Sonnet 4.5 / Haiku 4.5 on direct Anthropic + Cloudflare-AI-Gateway + Vertex + GitLab-Duo + Copilot + Bedrock fall through to plain `mode: "budget"` (thinking budget still scales with the selected effort tier). Opus 4.5 keeps `anthropic-budget-effort`. `anthropic-budget-effort` also stays in use for Anthropic-compatible third-party backends that natively support the field (Umans GLM 5.2). ([#3497](https://github.com/can1357/oh-my-pi/issues/3497))
+- Fixed direct Anthropic Claude Sonnet/Haiku 4.5 advisor/agent turns crashing every call with HTTP 400 `This model does not support the effort parameter.` The catalog classified the whole Claude 4.5 family on `anthropic-messages` (and `bedrock-converse-stream`) as `anthropic-budget-effort`, which made the Anthropic provider serialize `output_config.effort` alongside `thinking.budget_tokens`. Anthropic only honors `output_config.effort` on Opus 4.5 and adaptive (4.6+) Messages-API models, so Sonnet 4.5 / Haiku 4.5 rejected the field. `inferThinkingControlMode` now gates `anthropic-budget-effort` to the structured Opus family at revision 4.5+ on both Anthropic-routed APIs, so Sonnet 4.5 / Haiku 4.5 on direct Anthropic + Cloudflare-AI-Gateway + Vertex + GitLab-Duo + Copilot + Bedrock fall through to plain `mode: "budget"` (thinking budget still scales with the selected effort tier). Opus 4.5 keeps `anthropic-budget-effort`. `anthropic-budget-effort` also stays in use for Anthropic-compatible third-party backends that natively support the field (Umans GLM 5.2). ([#3497](https://github.com/can1357/oh-my-pi/issues/3497))
 
 ## [16.1.17] - 2026-06-24
 
@@ -1004,7 +1038,7 @@
 - Fixed local Ollama (`provider: "ollama"`) reasoning turns still failing with HTTP 400 `invalid reasoning value: "minimal"` when the model was selected from a stale `~/.omp/models.db` cache row or a hand-written config: the `minimal → low` / `xhigh → max` remap was only stamped during fresh discovery, so cached and custom specs reached the wire unmapped. The remap now lives in the OpenAI chat-completions and Responses compat builders, so every `buildModel` (including cache loads, custom specs, and the `whenThinking` variant) backfills it — no `omp models refresh` required. Custom OpenAI-compatible providers registered under a non-`ollama` provider id still need their own `compat.reasoningEffortMap`.
 - Advertised Ollama Cloud GLM-5.2 reasoning efforts as high/xhigh-only and mapped `xhigh` to native max effort ([#2911](https://github.com/can1357/oh-my-pi/pull/2911) by [@serverinspector](https://github.com/serverinspector))
 - Fixed OpenRouter pseudo-API model construction so bundled OpenRouter models resolve shared OpenAI compatibility metadata instead of an undefined compat record.
-- Fixed custom/direct `xai-oauth` Responses model specs (e.g. `grok-build`) emitting `reasoning.effort` and hitting xAI's HTTP 400: `buildOpenAIResponsesCompat` now defaults `supportsReasoningEffort` to `false` for `xai-oauth` Grok models that are off the effort-capable allowlist (`grok-3-mini`/`grok-4.20-multi-agent`/`grok-4.3`), matching the curated discovery path; explicit `compat.supportsReasoningEffort` still overrides. The allowlist moved to a shared `isGrokReasoningEffortCapable` identity helper consumed by both the compat builder and provider-model curation so the two cannot drift.
+- Fixed custom/direct `xai-oauth` Responses model specs (e.g. `grok-build`) emitting `reasoning.effort` and hitting xAI's HTTP 400: `buildOpenAIResponsesCompat` now defaults `supportsReasoningEffort` to `false` for `xai-oauth` Grok models that are off the effort-capable allowlist (`grok-3-mini`/`grok-4.20-multi-agent`/`grok-4.3`), matching the curated discovery path; explicit `compat.supportsReasoningEffort` still overrides. The reviewed allowlist moved into shared compat rules consumed by both the compat builder and provider-model curation so the two cannot drift.
 
 ## [16.0.5] - 2026-06-17
 
@@ -1094,13 +1128,13 @@
 ### Changed
 
 - Kept non-tool-capable Fireworks serverless models in discovery results and marked them with `supportsTools: false` for fallback-aware handling
-- Extended `modelFamilyToken(modelId)` to classify Claude/OpenAI ids the structured parser misses (older dated forms such as `claude-3-5-sonnet-20241022` and `gpt-4o`), returning `anthropic`/`openai` instead of an empty token.
+- Extended structured classification to cover older Claude/OpenAI forms such as `claude-3-5-sonnet-20241022` and `gpt-4o`.
 
 ## [15.13.1] - 2026-06-15
 
 ### Added
 
-- Added `modelFamilyToken(modelId)` to `@oh-my-pi/pi-catalog/identity`: a coarse vendor-lineage token (`anthropic`/`openai`/`gemini`/`kimi`/…) for "are two models the same family?" comparisons, backed by `parseKnownModel` canonical-id normalization. Opaque and comparison-only; kind/variant collapsed onto the vendor token ([#2406](https://github.com/can1357/oh-my-pi/issues/2406))
+- Added coarse vendor-lineage classification (`anthropic`/`openai`/`gemini`/`kimi`/…) to `@oh-my-pi/pi-catalog/identity` for "are two models the same family?" comparisons, with namespace normalization and kind/variant collapse ([#2406](https://github.com/can1357/oh-my-pi/issues/2406))
 
 ### Changed
 
@@ -1124,7 +1158,7 @@
 ### Changed
 
 - Pinned zai `glm-5.2` to 1M context during catalog generation so endpoint discovery and older fallbacks cannot regress it to 200k.
-- Replaced the hand-maintained `zhipu-coding-plan` GLM reasoning allowlist and vision regex with a `parseGlmModel` family classifier in `identity/classify.ts` (variant + vision + version), surfaced as `isReasoningGlmModelId` / `isGlmVisionModelId`. Discovery now derives reasoning/vision capability from the GLM family instead of a per-id list, so newly-bumped integers (`glm-5.3`, `glm-6`, …) are covered automatically while `-flash`/`-preview` and the vision `…v` shape stay correctly classified.
+- Replaced the hand-maintained `zhipu-coding-plan` GLM reasoning allowlist and vision regex with structured GLM class, family, and revision facts. Discovery now derives reasoning/vision capability from the GLM family instead of a per-id list, so newly-bumped integers (`glm-5.3`, `glm-6`, …) are covered automatically while `-flash`/`-preview` and the vision `…v` shape stay correctly classified.
 
 ## [15.12.4] - 2026-06-13
 
@@ -1237,7 +1271,7 @@
 - Added `ResolvedAnthropicCompat.supportsSamplingParams` (Opus 4.7+/Fable/Mythos reject `temperature`/`top_p`/`top_k` with a 400), baked at build time from model identity so the request path stops re-parsing model ids.
 - Compat detection gained model-time flags so handlers stop sniffing baseUrl: completions `supportsReasoningParams`, `alwaysSendMaxTokens`, `isOpenRouterHost`, `isVercelGatewayHost`, `streamIdleTimeoutMs`, and a precomputed `whenThinking` alternate view (OpenCode `reasoning_content` gating, #1071/#1484); responses `strictResponsesPairing`, `supportsLongPromptCacheRetention`, `supportsReasoningEffort`; anthropic `officialEndpoint`, `requiresToolResultId`, `replayUnsignedThinking`.
 - New `@oh-my-pi/pi-catalog` package: the model catalog extracted from `@oh-my-pi/pi-ai`. Owns the bundled `models.json` and its generation pipeline (`scripts/generate-models.ts`), the core model data types (`Model`, `Api`, `ThinkingConfig`, `Effort`, `Usage`, compat interfaces), thinking metadata enrichment and generated policies (`model-thinking.ts`), the SQLite model cache and model manager, per-provider discovery factories (`provider-models/`), the discovery protocol clients (`discovery/`), and the new `CATALOG_PROVIDERS` table — the single source of truth for provider ids, default models, and discovery wiring (`KnownProvider`, `PROVIDER_DESCRIPTORS`, and `DEFAULT_MODEL_PER_PROVIDER` are derived from it).
-- New `identity/` module centralizing model-identity concerns that were previously duplicated across packages: family classification and version parsing (`identity/classify.ts`, extracted from pi-ai's `model-thinking` internals), canonical model equivalence with injected reference data (`identity/equivalence.ts`, from coding-agent's `model-equivalence`), proxy/reseller reference lookup (`identity/reference.ts`, from coding-agent's `model-registry`), bracket-affix and id-segment helpers (`identity/id.ts`), a single trailing-marker vocabulary with canonical vs reference flavors (`identity/markers.ts` — `search` stays reference-only so Perplexity's `sonar-pro-search` remains canonical-distinct), and provider priority ordering (`identity/priority.ts`).
+- New `identity/` module centralizing model-identity concerns that were previously duplicated across packages: structured taxonomy classification and revisions, proxy/reseller reference lookup (`identity/reference.ts`), bracket-affix and id-segment helpers (`identity/id.ts`), and provider priority ordering (`identity/priority.ts`).
 - Memoized bundled-reference accessors (`getBundledCanonicalReferenceData` / `getBundledModelReferenceIndex` in `identity/bundled.ts`): one lazy walk of the bundled catalog feeds both canonical equivalence and proxy-reference lookup, so consumers no longer hand-roll the glue.
 - `identity/selection.ts`: pure canonical-variant selection (`resolveCanonicalVariant`, `buildCanonicalModelOrder`, `CanonicalVariantPreferences`) extracted from the coding-agent registry — provider rank, then exact-id match, variant source, id length, and candidate order.
 
@@ -1249,14 +1283,14 @@
 - `Model`'s api parameter now defaults to `Api` instead of `any` (`Model<TApi extends Api = Api>`), so bare `Model` no longer behaves as `Model<any>` at call sites.
 - `ThinkingConfig` is now explicit and total: an ordered `efforts` array replaces the `minLevel`/`maxLevel`/`levels` range encoding, and the wire facts are baked alongside it — `effortMap` (anthropic-adaptive 4-tier vs 5-tier scale, shared with the OpenRouter completions remap) and `supportsDisplay` (adaptive `display` field support). Explicit spec thinking owns the capability surface (`mode`/`efforts`/`defaultLevel`) and wins over inference; missing wire facts are backfilled from identity so configs never need to know Anthropic's tier tables. Reasoning models that reject the wire effort param (`compat.supportsReasoningEffort: false` on openai-responses*) are encoded as `thinking: undefined` ("thinks, no control surface") instead of the removed `modelOmitsReasoningEffort` special case. `models.json` was re-baked in the new vocabulary behind a 3196-model behavioral parity gate, and the model cache schema bumped to v4 to invalidate old-shape rows.
 - `mapEffortToGoogleThinkingLevel(effort)` is now a static map (model parameter dropped — validation stays at the `requireSupportedEffort` call sites), and `mapEffortToAnthropicAdaptiveEffort` reads the baked `thinking.effortMap` instead of re-classifying the model id per request.
-- Generator-only policy code moved out of the runtime bundle into `scripts/generated-policies.ts`: `applyGeneratedModelPolicies` (now policy fixups + thinking re-bake via the shared deriver), `linkOpenAIPromotionTargets`, the Copilot context-window table, minimax/opencode-go compat fixups, and `CLOUDFLARE_FALLBACK_MODEL`. The anthropic id predicates (`hasOpus47ApiRestrictions`, `supportsMidConversationSystemMessages`, `isAnthropicFableOrMythosModel`) moved to `identity/family` for build-time use by the compat/thinking derivers only.
+- Generator-only policy code moved out of the runtime bundle into `scripts/generated-policies.ts`: `applyGeneratedModelPolicies` (now policy fixups + thinking re-bake via the shared deriver), `linkOpenAIPromotionTargets`, the Copilot context-window table, minimax/opencode-go compat fixups, and `CLOUDFLARE_FALLBACK_MODEL`. Anthropic generation checks moved to structured class, family, and revision facts for build-time use by the compat/thinking derivers only.
 
 ### Fixed
 
 - Fixed Anthropic official-endpoint detection to require strict HTTPS hostname matching so non-official or lookalike URLs are no longer treated as official Anthropic hosts
 - Fixed Ollama Cloud dynamic discovery so same-id matches from other providers no longer supply context-window or max-output-token limits for discovered models.
 - Wired `@oh-my-pi/pi-catalog` into the release publish package list, tarball install smoke test, and root `bun generate-models` script.
-- Fixed `supportsAdaptiveThinkingDisplay` only matching dash-form version ids: dotted ids (`claude-opus-4.7`) now classify through `identity/classify` like every other anthropic predicate, so six bundled dotted Opus 4.7/4.8 entries (github-copilot, vercel-ai-gateway, zenmux) regain adaptive `display` support; bare dated ids (`claude-opus-4-20250514` = Opus 4.0) stay excluded.
+- Fixed adaptive-display classification only matching dash-form version ids: dotted ids (`claude-opus-4.7`) now classify through the structured taxonomy, so six bundled dotted Opus 4.7/4.8 entries (github-copilot, vercel-ai-gateway, zenmux) regain adaptive `display` support; bare dated ids (`claude-opus-4-20250514` = Opus 4.0) stay excluded.
 - Fixed the OpenRouter anthropic adaptive-effort map misclassifying bare dated Opus ids (`claude-opus-4-20250514` parsed as version 4.20 → wrongly adaptive); the map now derives from the shared classifier and the shared 4-/5-tier tables.
 
 ### Removed

package/README.md

@@ -9,25 +9,26 @@ Model catalog for [oh-my-pi](https://github.com/can1357/oh-my-pi): bundled model
 | `models.json` + `models`        | Bundled model database (pricing, context windows, modalities, thinking support)                             |
 | `provider-models`               | Provider catalog descriptors (`CATALOG_PROVIDERS`), per-provider model resolution rules                     |
 | `discovery`                     | Runtime model discovery for OpenAI-compatible endpoints, Gemini, Codex, Cursor, Antigravity, Ollama         |
-| `identity`                      | Model id parsing and classification (family/version), reference resolution, equivalence, selection priority |
-| `model-thinking`                | Thinking/reasoning metadata and generated per-model policies                                                |
+| `compat/rules`                  | Checked-in KDL policy tree: taxonomy (classes/families/revisions), class/provider cascade rules, runtime behavior vocabulary; compiled by `bun run gen:compat` into the committed `rules.json` |
+| `compat`                        | The rule engine: `classifyModel` (taxonomy), `resolveModelPolicy` (cascade), behavior accessors (`api-routes`, `model-limits`, `exclude-models`, `pricing-peer`), collapse, and OpenAI/Anthropic wire builders that consume resolved records |
+| `identity`                      | Mechanical id utilities: reference resolution against the bundled index, dialects, selection priority, tokenizer families                                |
+| `model-thinking`                | Runtime thinking helpers (`getSupportedEfforts`, effort clamping/mapping, wire-id routing) over resolved model records                                   |
 | `model-manager` / `model-cache` | Runtime model registry with discovery refresh and on-disk caching                                           |
-| `variant-collapse`              | Collapsing provider-specific variants of the same underlying model                                          |
-| `compat`                        | Request/response compatibility fixups for OpenAI- and Anthropic-shaped APIs                                 |
 | `wire`                          | Wire-level helpers: Codex, Gemini headers, GitHub Copilot                                                   |
 | `effort`                        | Reasoning-effort level definitions                                                                          |
 
 Import from subpaths (`@oh-my-pi/pi-catalog/<module>`) or the root barrel.
 
-## models.json is generated
+## models.json and rules.json are generated
 
-Never edit `src/models.json` by hand — it is produced from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `scripts/generate-models.ts` and the resolvers in `src/provider-models/`. Regenerate with:
+Never edit `src/models.json` or `src/compat/rules.json` by hand. `models.json` is produced from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `scripts/generate-models.ts`; `rules.json` is compiled from the KDL tree in `src/compat/rules/`. Regenerate with:
 
 ```sh
-bun run gen:models
+bun run gen:compat   # src/compat/rules/**/*.kdl -> src/compat/rules.json
+bun run gen:models   # upstream sources + rules -> src/models.json
 ```
 
-To change an entry, fix the source: resolver overrides in `provider-models/openai-compat.ts`, provider entries in `provider-models/descriptors.ts`, generator fixups in `scripts/generate-models.ts`, or thinking policies in `model-thinking.ts`.
+Model- or provider-conditional policy (identity, effort ladders, wire quirks, modality/limit/pricing corrections, API routing, roster exclusions) lives in the KDL tree — see `src/compat/rules/README.md` for the grammar and axis vocabulary. TypeScript changes are only for transport mechanics: provider entries in `provider-models/descriptors.ts`, discovery/request plumbing in `provider-models/openai-compat.ts`, and generator wiring in `scripts/generate-models.ts`. Commit `rules.json` (and a rebaked `models.json` when values change) alongside the `.kdl` edit.
 
 ## Install
 

package/dist/types/build.d.ts

@@ -1,19 +1,24 @@
 /**
- * The single Model constructor. Resolution order is a dependency chain, each
- * step materialized exactly once per spec:
- *
- *   1. compat   — URL/provider/id detection resolved into a complete record;
- *   2. thinking — derived from identity + resolved compat (or trusted verbatim
- *                 when the spec carries explicit metadata);
+ * The single Model constructor. Resolution runs through the compat engine
+ * (`compat/resolve`): identity classification, cascade-rule axes, host
+ * detection, and spec overrides materialize exactly once per spec.
  *
  * Request handlers read fields — they never detect, parse ids, or allocate
  * compat per request.
  */
-import type { Api, CompatOf, Model, ModelSpec } from "./types.js";
+import type { Api, Model, ModelSpec } from "./types.js";
+/**
+ * Applies reviewed catalog-data value corrections (`cost-patch`,
+ * `limits-patch`, `long-context-cost`, `context-window-floor`,
+ * `input-modalities`) onto an upstream-sourced spec. Applied by
+ * `buildModel` to every upstream-sourced spec; user-authored overrides are
+ * recomposed after building by the override applicators, so explicit user
+ * limits and pricing still win.
+ */
+export declare function applyCatalogCorrections(model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">, catalog: Record<string, unknown>): void;
 /**
  * Build one model from an authored spec. Bundled models.json rows are fully
  * materialized by the generator and consumed directly (see `models.ts`), so
  * this only runs for discovered/custom/override specs.
  */
 export declare function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>;
-export declare function buildCompat(spec: ModelSpec<Api>): CompatOf<Api>;

package/dist/types/cline-pass-model-id.d.ts

@@ -0,0 +1,4 @@
+/** Convert a public ClinePass catalog id to the gateway's wire id. */
+export declare function toClinePassWireModelId(modelId: string): string;
+/** Convert a gateway ClinePass wire id to the public catalog id. */
+export declare function toClinePassPublicModelId(modelId: string): string;

package/dist/types/compat/anthropic.d.ts

@@ -1,4 +1,3 @@
-import type { ModelSpec, ResolvedAnthropicCompat } from "../types.js";
 /**
  * Official first-party Anthropic API. A missing baseUrl is official on purpose:
  * request dispatch falls back to `https://api.anthropic.com`. This is the one
@@ -8,11 +7,18 @@ import type { ModelSpec, ResolvedAnthropicCompat } from "../types.js";
  */
 export declare function isOfficialAnthropicApiUrl(baseUrl?: string): boolean;
 /**
- * Known non-official URLs that enforce Anthropic thinking signatures on replay.
+ * Azure AI Inference / Foundry Anthropic route
+ * (`<resource>.inference.ai.azure.com`, `<resource>.services.ai.azure.com`).
+ * Fronts Claude behind Azure identity and enforces Anthropic signatures on
+ * replay; it also rejects the top-level `strict` tool field.
+ */
+export declare function isAzureAnthropicRoute(baseUrl?: string): boolean;
+/**
+ * Known non-official URLs that enforce Anthropic thinking signatures on replay
+ * (GitHub Copilot, ZenMux, Cloudflare AI Gateway `/anthropic`, Google Vertex
+ * `publishers/anthropic`, AWS Bedrock, Azure Foundry).
  *
  * Runtime routing calls this with the effective URL because a model's resolved
  * compat can be stale after Foundry or a provider base-URL override reroutes it.
  */
 export declare function isAnthropicSigningProxyUrl(baseUrl?: string): boolean;
-/** Build the resolved anthropic-messages compat record for a model spec. */
-export declare function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat;

package/dist/types/compat/axes.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The closed compat-axis vocabulary: every KDL cascade directive, the resolved
+ * camelCase field it assigns, its value shape, and — for wire axes — the
+ * compat records it applies to.
+ *
+ * Single source of truth shared by the compile-time rule compiler
+ * (`scripts/compat-compiler`) and the runtime engine (`./resolve`). The
+ * compiler rejects any directive absent from this table; the runtime assigns
+ * a wire axis onto a model's compat record only when the model's API maps to
+ * one of the axis's declared records.
+ */
+import type { Effort } from "../effort.js";
+import type { ThinkingControlMode } from "../types.js";
+/** Value shape a directive accepts (see `rules/README.md`). */
+export type AxisShape = "scalar" | "array" | "object";
+/** Axis namespace: request-wire compat, thinking control surface, or catalog metadata. */
+export type AxisSet = "wire" | "thinking" | "catalog";
+/** Resolved compat record families a wire axis may be assigned onto. */
+export type CompatRecordName = "openai" | "openai-responses" | "anthropic" | "bedrock" | "devin" | "google";
+/** One axis definition: resolved key, namespace, shape, and applicability. */
+export interface AxisDef {
+    /** Resolved camelCase field the directive assigns. */
+    key: string;
+    set: AxisSet;
+    shape: AxisShape;
+    /** Wire axes only: records this key exists on. */
+    records?: readonly CompatRecordName[];
+    /** Closed value vocabulary for string scalars / string arrays. */
+    values?: readonly string[];
+    /**
+     * Object axes only: payload child names are literal wire JSON keys copied
+     * verbatim (`extra-body`). Default object payloads author kebab-case names
+     * that compile to camelCase resolved keys.
+     */
+    verbatimKeys?: true;
+}
+/** Effort tiers accepted by taxonomy collapse/override vocabulary (`Effort` ∪ `"off"`). */
+export declare const EFFORT_TIERS: readonly string[];
+/** Narrow a KDL string to an effort tier (`Effort` ∪ `"off"`). */
+export declare function isEffortTier(value: string): value is Effort | "off";
+/** Narrow a KDL string to a thinking control mode. */
+export declare function isThinkingMode(value: string): value is ThinkingControlMode;
+/**
+ * KDL directive → axis definition. Keys are the kebab-case directive
+ * spellings accepted inside `classes/*.kdl` and `providers/*.kdl` rule
+ * blocks.
+ */
+export declare const AXES: Readonly<Record<string, AxisDef>>;
+/** Records applicable to each API family; used by `resolve.ts` when applying wire axes. */
+export declare const API_COMPAT_RECORDS: Readonly<Record<string, readonly CompatRecordName[]>>;

package/dist/types/compat/behavior.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Conservative heuristic for a normalized, lowercase discovered model id with
+ * no exact bundled record: whether it likely rides the OpenAI Responses API.
+ */
+export declare function isLikelyOpenAIResponsesId(model: string): boolean;
+/**
+ * Additional catalog-declared operations for a discovered provider/model pair
+ * (e.g. `generate_image`), augmenting provider discovery metadata.
+ */
+export declare function modelOperationOverrides(provider: string, model: string): readonly string[];
+/**
+ * Splits a Cursor effort-suffixed OpenAI sibling id into its base id and
+ * declared effort tier. The family gate requires the declared marker
+ * (`gpt-`) followed immediately by an ASCII digit; matching stays
+ * case-sensitive to preserve Cursor wire-id behavior.
+ */
+export declare function cursorEffortSuffix(model: string): {
+    base: string;
+    tier: string;
+} | undefined;
+/** Fixed Cursor `requestedModel` parameters declared for an exact wire model. */
+export declare function cursorModelParameters(model: string): readonly {
+    id: string;
+    value: string;
+}[];
+/**
+ * The catalog-declared quota scope or display tier for a provider model id.
+ * Exact authored memberships win; provider-authored substring fallbacks
+ * preserve quota semantics for newly discovered ids.
+ */
+export declare function quotaTierFor(provider: string, model: string): string | undefined;
+/** Whether a provider has catalog-authored model quota scopes. */
+export declare function hasQuotaTierPolicy(provider: string): boolean;
+/** The provider-default wire model for a model-less hosted operation. */
+export declare function hostedDefaultModel(provider: string): string | undefined;
+/** One resolved API route for a provider model id. */
+export interface ApiRouteMatch {
+    /** Transport API the id rides. */
+    api: string;
+    /** Wire id after prefix stripping, when the route declares `strip-prefix`. */
+    requestModelId?: string;
+}
+/**
+ * Resolves the declared API route for a provider model id. Routes match in
+ * declaration order; a `strip-prefix` route with a prefix matcher strips the
+ * matched prefix off the wire id. Falls back to the node's `default` API.
+ */
+export declare function apiRouteFor(provider: string, model: string): ApiRouteMatch | undefined;
+/** Exact model ids named by a provider's api-routes rules (cache-migration drop lists). */
+export declare function apiRouteExactModelIds(provider: string): string[];
+/** Declared context-window / max-token pins for a provider model id. */
+export declare function modelLimitsFor(provider: string, model: string): {
+    context?: number;
+    maxTokens?: number;
+} | undefined;
+/** Whether a provider roster entry is a declared non-chat/unsupported SKU. */
+export declare function isExcludedModel(provider: string, model: string): boolean;
+/**
+ * Whether a provider is retired: its entire roster is excluded from the
+ * generated bundle and must never be resurrected from the previous snapshot.
+ */
+export declare function isRetiredProvider(provider: string): boolean;
+/** The declared subscription tier required to use a provider model id, if any. */
+export declare function planRequirementFor(provider: string, model: string): string | undefined;
+/** Cross-provider pricing-peer resolution for one provider model id. */
+export declare function pricingPeerFor(provider: string, model: string): {
+    peers: readonly string[];
+    peerId: string;
+} | undefined;

package/dist/types/compat/cascade.d.ts

@@ -0,0 +1,37 @@
+import type { CompiledCascade, ResolvedAxes, ResolveTarget } from "./types.js";
+/**
+ * Two equal-rank rules contest one axis for a target. CI-time for bundled
+ * targets (the parity sweep exercises every catalog row); fix with an
+ * explicit `priority=` in the KDL, never in code.
+ */
+export declare class AmbiguousOverlapError extends Error {
+    readonly provider: string;
+    readonly model: string;
+    readonly axis: string;
+    readonly first: string;
+    readonly second: string;
+    constructor(provider: string, model: string, axis: string, first: string, second: string);
+}
+/**
+ * Anchored `*`-wildcard match; both sides must be pre-lowercased. `*` spans
+ * any substring; non-wildcard text stays anchored in order.
+ */
+export declare function globMatch(pattern: string, value: string): boolean;
+/**
+ * Resolves wire, thinking, and catalog assignments for one structured target.
+ *
+ * Thinking axes are gated on `target.reasoning`, except that an exact model
+ * selector declaring `thinking-efforts` upgrades the target (a reviewed
+ * correction to stale capability metadata). Family and revision selectors
+ * never match targets missing that identity rank. Unmatched targets resolve
+ * to empty maps.
+ *
+ * @throws AmbiguousOverlapError when two equal-rank rules contest one axis.
+ */
+export declare function resolveCascade(target: ResolveTarget): ResolvedAxes;
+/**
+ * Resolves a target against an arbitrary compiled cascade (test seam and
+ * scratch evaluations); `resolveCascade` delegates here with the bundled
+ * rule index.
+ */
+export declare function resolveCascadeRules(cascade: CompiledCascade, target: ResolveTarget): ResolvedAxes;

package/dist/types/{variant-collapse.d.ts → compat/collapse.d.ts}

@@ -1,5 +1,5 @@
-import { Effort } from "./effort.js";
-import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "./types.js";
+import { Effort } from "../effort.js";
+import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "../types.js";
 /**
  * Structural bound for collapse inputs: both raw `ModelSpec`s and built
  * `Model`s qualify. (`Model.compat` is the resolved record, not the sparse
@@ -45,8 +45,14 @@ export interface EffortVariantFamily {
      * efforts fall back to `requestModelId ?? id`.
      */
     routing: Readonly<Partial<Record<Effort | "off", string>>>;
-    /** Explicit capability surface for the collapsed spec — no inference. */
-    thinking: Readonly<Omit<ThinkingConfig, "effortRouting" | "suppressWhenOff">>;
+    /**
+     * Explicit capability surface for the collapsed spec — no inference. Omit
+     * for single-wire-id renames on providers where effort is encoded in the
+     * upstream id itself (Devin): with one member and no routing there is no
+     * controllable surface, and the collapsed spec must carry no thinking
+     * rather than an effort ladder whose every tier resolves to one wire id.
+     */
+    thinking?: Readonly<Omit<ThinkingConfig, "effortRouting" | "suppressWhenOff">>;
     /** Thinking-off requests must explicitly suppress thinking on the wire. */
     suppressWhenOff?: boolean;
     /**
@@ -61,16 +67,21 @@ export interface EffortVariantFamily {
 }
 export interface VariantCollapseTable {
     families: readonly EffortVariantFamily[];
+    /**
+     * Provider-scoped selector aliases: short native-CLI names and dotted
+     * upstream spellings → logical model id. Unlike family members and
+     * `extraAliases` these are deliberately invisible to the bare-id lookup
+     * ({@link resolveBareVariantSelector}) and to the reverse index — a generic
+     * label like `gpt` or `opus` only means something once a provider is
+     * named, and must never hijack an unqualified selector or re-key config.
+     */
+    providerAliases?: Readonly<Record<string, string>>;
 }
-/** `google-antigravity` Gemini families, using each generation's native transport. */
-export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-/** `google-gemini-cli` Gemini families on the official CLI's level transport. */
-export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-export declare const DEVIN_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-/** `cursor` per-effort sibling families collapsed per service-tier lane: Grok 4.5/4.6 plus GPT-5.6 Luna/Sol/Terra. */
-export declare const CURSOR_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
-/** Provider id → hand collapse table. The CCA providers diverge on thinking transport. */
-export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCollapseTable>>;
+/**
+ * Return the reviewed collapse table compiled for `provider`, when declared.
+ * Discovery uses this accessor to preserve injectable table seams.
+ */
+export declare function reviewedCollapseTable(provider: string): VariantCollapseTable | undefined;
 /**
  * The global automatic rule: derive an `X` + `X-thinking` family for every
  * pair where both ids are live in `specs` (trailing or infix token). Gates:
@@ -78,35 +89,31 @@ export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCol
  * - known pricing must match — all-zero cost rows count as unknown
  *   (aggregators routinely ship them), but twins that BOTH carry real,
  *   differing prices are distinct SKUs and never merge,
- * - ids claimed by the provider's hand `table` are skipped (curation wins).
+ * - ids claimed by the provider's reviewed table are skipped (curation wins).
  * The capability surface prefers the thinking member's metadata, then the
  * bare member's, then the canonical deriver (aggregators often ship
  * `reasoning: false` and no thinking config on the twin), then a budget
  * default. `off` routes to the bare id; every supported effort routes to the
  * thinking id.
  */
-export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table?: VariantCollapseTable): EffortVariantFamily[];
+export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table?: VariantCollapseTable, provider?: string): EffortVariantFamily[];
 /**
  * True when `spec` is the output of collapsing rather than a raw upstream
  * member. `thinking.effortRouting` is written only by collapsing; the
- * `requestModelId` arm is scoped to the provider's hand-table family ids so
+ * `requestModelId` arm is scoped to the provider's reviewed-table family ids so
  * unrelated carriers (GitHub Copilot `-1m` context variants) never match.
  */
-export declare function isVariantCollapsedSpec(spec: VariantSpecLike): boolean;
-/**
- * Collapse every family in `table` found in `specs`. Non-member specs pass
- * through verbatim (by reference), order preserved; the collapsed spec
- * replaces the first occurrence of its family.
- */
-export declare function collapseEffortVariants<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table: VariantCollapseTable): TSpec[];
+export declare function isCollapsedVariantSpec(spec: VariantSpecLike): boolean;
 /**
- * Collapse a full mixed-provider list: per provider, the hand table, Cursor's
+ * Collapse a full mixed-provider list: per provider, the compiled reviewed table, Cursor's
  * conservative live effort-sibling rule, and the automatic `X`/`X-thinking`
  * pair rule. Used by the catalog generator; the runtime equivalent lives at
  * the model-manager merge point. Output is regrouped by provider — callers
  * re-sort.
  */
-export declare function collapseEffortVariantsAcrossProviders<TSpec extends VariantSpecLike>(specs: readonly TSpec[]): TSpec[];
+export declare function collapseVariants<TSpec extends VariantSpecLike>(specs: readonly TSpec[], opts?: {
+    table?: VariantCollapseTable;
+}): TSpec[];
 /**
  * Runtime entry point for already-built `Model` lists (the model-manager
  * merge point, coding-agent registry custom providers): collapses hand
@@ -114,16 +121,14 @@ export declare function collapseEffortVariantsAcrossProviders<TSpec extends Vari
  * logical specs so thinking wire defaults stay resolved. Untouched entries
  * pass through by reference.
  */
-export declare function collapseBuiltModelVariants<TApi extends Api>(models: readonly Model<TApi>[]): Model<TApi>[];
+export declare function collapseBuiltVariants<TApi extends Api>(models: readonly Model<TApi>[]): Model<TApi>[];
 /**
- * Resolve a retired effort-tier variant id (collapsed member, recycled id) to
- * its replacement model id for `provider` via hand-table or registered live
- * aliases. Returns `undefined` when the id is not a known alias; derived
- * `X-thinking` members also resolve through `stripThinkingVariantToken`.
- * Callers must try an exact model lookup first — a live model always wins over
- * an alias.
+ * Resolve a retired effort-tier variant id, registered live alias, or
+ * provider-scoped native alias to its replacement model id for `provider`.
+ * Returns `undefined` when the id is unknown. Callers must try an exact model
+ * lookup first because a live model always wins over an alias.
  */
-export declare function resolveVariantAlias(provider: Provider, modelId: string): string | undefined;
+export declare function resolveVariantSelector(provider: Provider, modelId: string): string | undefined;
 /** Bare-id alias hit: replacement id plus the providers declaring it. */
 export interface BareVariantAliasHit {
     id: string;
@@ -136,10 +141,10 @@ export interface BareVariantAliasHit {
  * on unrelated providers too (e.g. a retired Cursor tier id must not resolve
  * to `openai/gpt-5.4`).
  */
-export declare function resolveBareVariantAlias(modelId: string): BareVariantAliasHit | undefined;
+export declare function resolveBareVariantSelector(modelId: string): BareVariantAliasHit | undefined;
 /**
  * Reverse alias lookup: the retired ids that resolve to `modelId` for
- * `provider` via hand-table or registered live aliases. Used to re-key config
+ * `provider` via reviewed-table or registered live aliases. Used to re-key config
  * keyed by raw member ids (models.yml `modelOverrides`, suppressed selectors)
  * onto the collapsed model.
  */

package/dist/types/compat/openai.d.ts

@@ -1,28 +1,9 @@
-import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenRouterCompat } from "../types.js";
-/** Wire effort remap for first-party xAI Responses. */
-export declare function xaiResponsesReasoningEffortMap(modelId: string): NonNullable<OpenAICompat["reasoningEffortMap"]>;
-/**
- * Build the resolved chat-completions compat record for a model spec.
- * Provider takes precedence over URL-based detection since it's explicitly configured.
- */
-export declare function buildOpenAICompat(spec: ModelSpec<"openai-completions">): ResolvedOpenAICompat;
-interface OpenAIResponsesSpecLike {
-    id?: string;
-    provider: string;
-    name: string;
-    baseUrl: string;
-    reasoning?: boolean;
-    compat?: OpenAICompat;
-}
 /**
- * Build the resolved Responses-API compat record. Most shared OpenAI-compatible
- * capability defaults intentionally mirror chat-completions, while Responses-
- * only behavior (developer role, prompt cache, pairing strictness, image detail)
- * keeps endpoint-specific detection. Azure is detected by provider id as well
- * as URL — bundled `azure` models carry no baseUrl (the deployment host is per-
- * resource, resolved at runtime) — while OpenAI/Copilot developer-role and
- * prompt-cache detection stay URL-keyed, as the historical call sites were.
+ * OpenAI-side compat residue: the first-party xAI Responses effort remap used
+ * by the xai-oauth discovery mapper when curating sparse rows. Everything else
+ * that lived here (the chat-completions/Responses compat builders) moved into
+ * the compat engine (`./resolve`) and the KDL rules.
  */
-export declare function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat;
-export declare function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat;
-export {};
+import type { OpenAICompat } from "../types.js";
+/** Wire effort remap for first-party xAI Responses. */
+export declare function xaiResponsesReasoningEffortMap(modelId: string): NonNullable<OpenAICompat["reasoningEffortMap"]>;

package/dist/types/compat/resolve.d.ts

@@ -0,0 +1,15 @@
+import type { Api, CompatOf, ModelSpec, ThinkingConfig } from "../types.js";
+import type { ModelIdentity } from "./types.js";
+/** Result of resolving one model spec through the compat engine. */
+export interface ResolvedModelPolicy<TApi extends Api = Api> {
+    identity: ModelIdentity;
+    compat: CompatOf<TApi>;
+    thinking: ThinkingConfig | undefined;
+    /** Catalog-data axis assignments (longContext, priority, …) for generation. */
+    catalog: Record<string, unknown>;
+}
+/**
+ * Resolves the full policy surface for one model spec: structured identity,
+ * complete compat record, thinking metadata, and catalog-data corrections.
+ */
+export declare function resolveModelPolicy<TApi extends Api>(spec: ModelSpec<TApi>): ResolvedModelPolicy<TApi>;

package/dist/types/compat/revision.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Revision triples (`major.minor.patch`) extracted from model identifiers.
+ *
+ * The compat engine compares revisions as three unsigned 8-bit components;
+ * omitted components are zero (`4.6` ≡ `4.6.0`). Shared by the compile-time
+ * rule compiler and the runtime taxonomy/cascade.
+ */
+/** A parsed `major.minor.patch` revision. */
+export type Revision = readonly [number, number, number];
+/**
+ * Parses an explicit revision literal: one to three components separated by
+ * `.` or `-` (`"4.6"`, `"4-6-1"`). Returns undefined on malformed input.
+ */
+export declare function parseRevision(value: string): Revision | undefined;
+/**
+ * Extracts a leading revision from an identifier tail that begins with a
+ * digit: up to three components separated by `.` or by `-` followed by a
+ * digit (`"4-6-turbo"` → `[4, 6, 0]`). Mirrors o2 `parse_revision_prefix`.
+ * A component whose digits run directly into a letter is a parameter-count
+ * or size token (`qwen3-32b`, `llama-3.3-70b`), never a revision component.
+ */
+export declare function parseRevisionPrefix(value: string): Revision | undefined;
+/** Lexicographic triple comparison: negative, zero, or positive. */
+export declare function compareRevision(a: Revision, b: Revision): number;
+/** Renders a revision as its canonical `major.minor.patch` string. */
+export declare function formatRevision(revision: Revision): string;
+/** Comparison operator inside a `revision ">=2.5 <4"` cascade constraint. */
+export type RevisionOp = ">=" | ">" | "<=" | "<" | "=";
+/** One comparison term of a revision constraint conjunction. */
+export interface RevisionTerm {
+    op: RevisionOp;
+    revision: Revision;
+}
+/** Whether `revision` satisfies every term of the conjunction. */
+export declare function revisionSatisfies(revision: Revision, terms: readonly RevisionTerm[]): boolean;
+/**
+ * Parses a whitespace-separated conjunction of comparisons
+ * (`">=2.5 <3.8"`). Operands allow one to three dot-separated components.
+ * Returns undefined when empty or malformed.
+ */
+export declare function parseRevisionConstraint(expression: string): RevisionTerm[] | undefined;