@linxiraos/pi-catalog 1.1.6 → 1.1.8

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+## [1.1.8] - 2026-09-04
+
+- OMP sync v18.1.2–v18.1.5: declarative KDL auth contract compiler (`@bgotink/kdl` now a devDependency), provider auth definitions, and model-policy rule updates.
+- Restored the biome toolchain for catalog scripts after the v18.1.5 merge briefly adopted the upstream oxlint/oxfmt configuration.
+
 ## [1.1.6] - 2026-08-30
 
 - 同步上游 OMP v18.0.9（`cc14e04f075d`）。
@@ -10,12 +15,6 @@
 
 - 同步上游 OMP v18.0.5 / v18.0.6：新增 DeepInfra / Yolo-Auto 提供商标识。
 
-## [1.1.3] - 2026-08-25
-
-### Fixed
-
-- Republished as 1.1.3 to reset the latest tag after the broken 1.1.2 (no functional change over 1.1.1).
-
 ## [1.1.2] - 2026-08-25
 
 ### Fixed
@@ -43,3 +42,8 @@
 ### Changed
 
 - Reset the version to 1.0.0 and republished under the `@linxiraos/*` scope, breaking from the `@linxiraos` version lineage.
+- Bundled model metadata is prebuilt during generation, reducing catalog startup work.
+
+### Fixed
+
+- Fixed tool-call turn failures for `opencode-go/muse-spark-1.2` and related variants by ensuring API transport pins apply to live discovery and automatically inferring response routes for gateway-first OpenCode models ([#8957](https://github.com/can1357/oh-my-pi/issues/8957)).

package/README.md

@@ -9,25 +9,26 @@ Model catalog for [Zeta](https://github.com/Linxira-OS/linxira-zeta): bundled mo
 | `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 (`@linxiraos/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/auth-ids.d.ts

@@ -0,0 +1,4 @@
+/** Every provider with an `auth/<id>.kdl` policy. */
+export type AuthProviderId = "abliteration" | "aiand" | "aimlapi" | "alibaba-coding-plan" | "alibaba-token-plan" | "amazon-bedrock" | "anthropic" | "azure" | "baseten" | "bedrock-mantle" | "cerebras" | "cline-pass" | "cloudflare-ai-gateway" | "coreweave" | "cursor" | "deepinfra" | "deepseek" | "devin" | "exa" | "firepass" | "fireworks" | "github-copilot" | "gitlab-duo" | "gitlab-duo-agent" | "gmi-cloud" | "google" | "google-antigravity" | "google-gemini-cli" | "google-vertex" | "groq" | "huggingface" | "kagi" | "kilo" | "kimi-code" | "litellm" | "llama.cpp" | "lm-studio" | "meta" | "minimax" | "minimax-code" | "minimax-code-cn" | "mistral" | "moonshot" | "nanogpt" | "novita" | "nvidia" | "ollama" | "ollama-cloud" | "openai" | "openai-codex" | "openai-codex-device" | "opencode-go" | "opencode-zen" | "openrouter" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "sakana" | "siliconflow" | "siliconflow-cn" | "synthetic" | "tavily" | "together" | "umans" | "venice" | "vercel-ai-gateway" | "vllm" | "wafer-serverless" | "xai" | "xai-oauth" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "yolo-auto" | "zai" | "zai-coding-plan" | "zenmux" | "zhipu-coding-plan";
+/** Providers whose policy declares a `login` flow (the `/login` roster). */
+export type LoginProviderId = "abliteration" | "aiand" | "alibaba-coding-plan" | "alibaba-token-plan" | "anthropic" | "baseten" | "cerebras" | "cline-pass" | "cloudflare-ai-gateway" | "coreweave" | "cursor" | "deepinfra" | "deepseek" | "devin" | "exa" | "firepass" | "fireworks" | "github-copilot" | "gitlab-duo" | "gitlab-duo-agent" | "gmi-cloud" | "google-antigravity" | "google-gemini-cli" | "huggingface" | "kagi" | "kilo" | "kimi-code" | "litellm" | "llama.cpp" | "lm-studio" | "meta" | "minimax-code" | "minimax-code-cn" | "moonshot" | "nanogpt" | "novita" | "nvidia" | "ollama" | "ollama-cloud" | "openai-codex" | "openai-codex-device" | "opencode-go" | "opencode-zen" | "openrouter" | "parallel" | "perplexity" | "qianfan" | "qwen-portal" | "sakana" | "siliconflow" | "siliconflow-cn" | "synthetic" | "tavily" | "together" | "umans" | "venice" | "vercel-ai-gateway" | "vllm" | "wafer-serverless" | "xai" | "xai-oauth" | "xiaomi" | "xiaomi-token-plan-ams" | "xiaomi-token-plan-cn" | "xiaomi-token-plan-sgp" | "yolo-auto" | "zai" | "zai-coding-plan" | "zenmux" | "zhipu-coding-plan";

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

@@ -0,0 +1,7 @@
+import type { CompiledAuthProvider } from "./types.js";
+/** Every compiled auth provider in `/login` display order. */
+export declare function authProviders(): readonly CompiledAuthProvider[];
+/** The compiled auth policy for one provider id, if declared. */
+export declare function authPolicyFor(provider: string): CompiledAuthProvider | undefined;
+/** Every hook name referenced anywhere in the auth stratum, for registry completeness checks. */
+export declare function authHookNames(): Record<string, string[]>;

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,6 @@
-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";
+import { type RevisionTerm } from "./revision.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 +46,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;
     /**
@@ -59,18 +66,42 @@ export interface EffortVariantFamily {
     /** Retired/recycled selector ids that alias to this family without being members. */
     extraAliases?: readonly string[];
 }
+/**
+ * A reviewed family whose ids carry {@link REVISION_PLACEHOLDER}: one
+ * `gemini-{rev}-flash` entry stands for every Flash generation the provider
+ * serves with the same sibling layout. Concrete families with the same
+ * instantiated id take precedence.
+ */
+export interface VariantFamilyTemplate {
+    /** Family with placeholders still in every id and the display name. */
+    family: EffortVariantFamily;
+    /** Revisions the template applies to; unbounded when absent. */
+    revision?: readonly RevisionTerm[];
+    /**
+     * Matches the logical id, any member, or any extra alias (case-insensitive);
+     * one alternative per id, each capturing the revision.
+     */
+    pattern: RegExp;
+}
 export interface VariantCollapseTable {
     families: readonly EffortVariantFamily[];
+    /** Revision-templated families, instantiated against live ids. */
+    templates?: readonly VariantFamilyTemplate[];
+    /**
+     * 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 +109,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 +141,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 +161,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;