@oh-my-pi/pi-catalog 18.2.1 → 18.2.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [18.2.2] - 2026-09-16
+
+### Added
+
+- OpenAI-compatible model discovery now fills in reasoning-effort tiers for unrecognized models using the shared catalog’s published reasoning options, while preserving explicit discovery metadata and reviewed model rules.
+
+### Fixed
+
+- Fixed recovery of corrupted model caches so private backups are preserved and concurrent recovery cannot overwrite a cache that has already been restored.
+- Fixed pricing for Devin (SWE-2, SWE-1.7, and GLM-5.2 High) and Kimi Code models when upstream discovery omits cost information. SWE-2 now reflects its promotional pricing through December 31, 2026, then switches to list pricing on January 1, 2027.
+- Fixed pricing and chat routing for Devin Fusion models so composite models use their own headline rates and supported Fusion lanes connect directly instead of failing through an incompatible routing path.
+
 ## [18.2.1] - 2026-09-15
 
 ### Added

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

@@ -30,3 +30,13 @@ export declare function resolveCascade(target: ResolveTarget): ResolvedAxes;
  * mutable rule data. Bundled target lookups use {@link resolveCascade}.
  */
 export declare function resolveCascadeRules(cascade: CompiledCascade, target: ResolveTarget): ResolvedAxes;
+/**
+ * Whether the effort ladder this target resolves to comes from a rule scoped
+ * to the model's identity (a recognized class, family, revision, or an explicit
+ * model selector), rather than a provider/api-wide or fallback unknown-class
+ * rule that any unrecognized id at that provider inherits.
+ *
+ * Discovery reads this to tell reviewed tiers apart from a blanket default, so
+ * catalog-published tiers can correct the latter and never the former.
+ */
+export declare function hasModelScopedEffortsRule(target: ResolveTarget): boolean;

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

@@ -124,6 +124,14 @@ export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike
  * unrelated carriers (GitHub Copilot `-1m` context variants) never match.
  */
 export declare function isCollapsedVariantSpec(spec: VariantSpecLike): boolean;
+/**
+ * Whether a Cursor wire id names an extended tier that upstream serves only in
+ * max mode. The compiled taxonomy identifies `xhigh`/`extra-high`/`max`
+ * efforts and their optional service lanes. This is an inference, not an
+ * upstream marker: it is the only per-tier signal available for bundled rows
+ * and for routes live discovery never advertised.
+ */
+export declare function isCursorMaxModeWireId(wireModelId: string): boolean;
 /**
  * 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`

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

@@ -13,3 +13,13 @@ export interface ResolvedModelPolicy<TApi extends Api = Api> {
  * complete compat record, thinking metadata, and catalog-data corrections.
  */
 export declare function resolveModelPolicy<TApi extends Api>(spec: ModelSpec<TApi>): ResolvedModelPolicy<TApi>;
+/**
+ * Whether reviewed rules know THIS model's effort ladder, as opposed to it
+ * inheriting a provider-wide default or {@link resolveThinkingPolicy} falling
+ * through to the neutral wire ladder.
+ *
+ * Discovery uses this to tell "omp knows this model's tiers" apart from "omp
+ * is guessing them", so catalog-published tiers can correct the guess without
+ * ever overriding reviewed knowledge.
+ */
+export declare function hasModelScopedEffortLadder<TApi extends Api>(spec: ModelSpec<TApi>): boolean;

package/dist/types/types.d.ts

@@ -1013,6 +1013,16 @@ export interface Model<TApi extends Api = Api> {
     gitlabDuoWorkflowRootNamespaceId?: string;
     /** Cursor `max_mode` request flag returned by `GetUsableModels` for premium models that require max mode. */
     cursorMaxMode?: boolean;
+    /**
+     * Per-wire-id `max_mode` markers for the members a collapsed Cursor row
+     * routes to, recorded by `collapseVariants` from live `GetUsableModels`
+     * rows. {@link cursorMaxMode} on a collapsed row is an OR across members,
+     * so it cannot tell a `-low` route that needs no max mode from an Opus
+     * `-fast` route that does; transports look the routed wire id up here
+     * first. Absent on raw rows (their own `cursorMaxMode` already describes
+     * their single wire id) and on bundled snapshots that predate discovery.
+     */
+    cursorMaxModeRoutes?: Readonly<Record<string, boolean>>;
     cost: ModelCost;
     /** Premium Copilot requests charged per user-initiated request (defaults to 1). */
     premiumMultiplier?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.2.1",
+	"version": "18.2.2",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -35,12 +35,12 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.2.1",
-		"@oh-my-pi/pi-utils": "18.2.1"
+		"@oh-my-pi/omptype": "18.2.2",
+		"@oh-my-pi/pi-utils": "18.2.2"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.2.1",
+		"@oh-my-pi/pi-ai": "18.2.2",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -24,6 +24,41 @@ function objectPayload(value: unknown): object | undefined {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 
+/**
+ * Overwrite seeded fallback rates with the latest dated card whose
+ * `effectiveFrom` is already due. Leaves the seed unchanged when no card
+ * has started, and never attaches a `timeBased` tariff.
+ */
+function applyEffectiveFallbackRates(
+	cost: { input: number; output: number; cacheRead: number; cacheWrite: number },
+	effectiveRates: unknown,
+	now = Date.now(),
+): void {
+	const rates = objectPayload(effectiveRates);
+	if (rates === undefined) return;
+	let latestFrom = Number.NEGATIVE_INFINITY;
+	let latest: object | undefined;
+	for (const entry of Object.values(rates)) {
+		const payload = objectPayload(entry);
+		if (payload === undefined) continue;
+		const date = Reflect.get(payload, "effectiveFrom");
+		if (typeof date !== "string") continue;
+		const from = Date.parse(date);
+		if (!Number.isFinite(from) || from > now || from < latestFrom) continue;
+		latestFrom = from;
+		latest = payload;
+	}
+	if (latest === undefined) return;
+	const input = numberField(latest, "input");
+	if (input !== undefined) cost.input = input;
+	const output = numberField(latest, "output");
+	if (output !== undefined) cost.output = output;
+	const cacheRead = numberField(latest, "cacheRead");
+	if (cacheRead !== undefined) cost.cacheRead = cacheRead;
+	const cacheWrite = numberField(latest, "cacheWrite");
+	if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+}
+
 /** Narrow a compiled `input-modalities` axis value to the model input union. */
 function isInputModalities(value: unknown): value is ("text" | "image")[] {
 	return Array.isArray(value) && value.every(entry => entry === "text" || entry === "image");
@@ -139,6 +174,30 @@ export function applyCatalogCorrections(
 		const cacheWrite = numberField(patch, "cacheWrite");
 		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
 	}
+	const fallback = objectPayload(catalog.costFallback);
+	if (fallback !== undefined) {
+		const base = model.cost;
+		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		if (!hasTokenPrice) {
+			// Upstream reported no token price (plan-included or promo-free
+			// rows): seed the reviewed list price instead of overwriting real
+			// discovery data the way `cost-patch` would.
+			model.cost = { ...model.cost };
+			const input = numberField(fallback, "input");
+			if (input !== undefined) model.cost.input = input;
+			const output = numberField(fallback, "output");
+			if (output !== undefined) model.cost.output = output;
+			const cacheRead = numberField(fallback, "cacheRead");
+			if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+			const cacheWrite = numberField(fallback, "cacheWrite");
+			if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+			// Dated fallback rates overwrite the seeded numbers when they have
+			// already taken effect. They are not a recurring tariff: wrapping
+			// them in `timeBased` with empty peak windows would report
+			// permanent off-peak and never wake at the dated boundary.
+			applyEffectiveFallbackRates(model.cost, Reflect.get(fallback, "effectiveRates"));
+		}
+	}
 	if (catalog.timeBased !== undefined) {
 		model.cost = { ...model.cost, timeBased: materializeTimeBasedCost(catalog.timeBased) };
 	}

package/src/compat/axes.ts

@@ -288,6 +288,7 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"context-promotion-target": { key: "contextPromotionTarget", set: "catalog", shape: "scalar" },
 	"context-window-floor": { key: "contextWindowFloor", set: "catalog", shape: "scalar" },
 	"cost-patch": { key: "costPatch", set: "catalog", shape: "object" },
+	"cost-fallback": { key: "costFallback", set: "catalog", shape: "object" },
 	"delegation-bias": { key: "delegationBias", set: "catalog", shape: "scalar", values: DELEGATION_BIASES },
 	"edit-prompt-variant": { key: "editPromptVariant", set: "catalog", shape: "scalar", values: ["full", "compact"] },
 	"edit-revision": { key: "editRevision", set: "catalog", shape: "scalar" },

package/src/compat/cascade.ts

@@ -325,6 +325,30 @@ export function resolveCascadeRules(cascade: CompiledCascade, target: ResolveTar
 	return cloneAxes(resolveOverIndex(buildRuleIndex(cascade), target));
 }
 
+/**
+ * Whether the effort ladder this target resolves to comes from a rule scoped
+ * to the model's identity (a recognized class, family, revision, or an explicit
+ * model selector), rather than a provider/api-wide or fallback unknown-class
+ * rule that any unrecognized id at that provider inherits.
+ *
+ * Discovery reads this to tell reviewed tiers apart from a blanket default, so
+ * catalog-published tiers can correct the latter and never the former.
+ */
+export function hasModelScopedEffortsRule(target: ResolveTarget): boolean {
+	const winners: WinnerTable = {};
+	for (const { rule, rank } of rankRelevantRules(getRuleIndex(), prepareTarget(target))) {
+		contest(winners, rule.compiled.thinking, rank, rule, target);
+	}
+	const winner = winners.efforts?.rule.compiled;
+	if (winner === undefined) return false;
+	return (
+		(winner.class !== undefined && winner.class !== "unknown") ||
+		winner.family !== undefined ||
+		winner.revision !== undefined ||
+		winner.models !== undefined
+	);
+}
+
 function resolveOverIndex(index: RuleIndex, target: ResolveTarget): ResolvedAxes {
 	const ranked = rankRelevantRules(index, prepareTarget(target));
 	let reasoning = target.reasoning === true;

package/src/compat/collapse.ts

@@ -734,6 +734,80 @@ function reconcileDefaultMember<TSpec extends VariantSpecLike>(
 	return spec;
 }
 
+/**
+ * Whether a Cursor wire id names an extended tier that upstream serves only in
+ * max mode. The compiled taxonomy identifies `xhigh`/`extra-high`/`max`
+ * efforts and their optional service lanes. This is an inference, not an
+ * upstream marker: it is the only per-tier signal available for bundled rows
+ * and for routes live discovery never advertised.
+ */
+export function isCursorMaxModeWireId(wireModelId: string): boolean {
+	const effort = collapseVariantId("cursor", wireModelId).effort;
+	return effort === Effort.XHigh || effort === Effort.Max;
+}
+
+/**
+ * Recover Cursor's max-mode marker for a bundled collapsed row. The bundled
+ * snapshot may contain only the logical row, but its effort routing still
+ * records the wire ids, so {@link isCursorMaxModeWireId} preserves the
+ * transport invariant even when live discovery contributes no raw members.
+ */
+function reconcileCursorMaxModeFromRouting<TSpec extends VariantSpecLike>(spec: TSpec): TSpec {
+	if (spec.provider !== "cursor" || spec.cursorMaxMode === true) return spec;
+	const routing = spec.thinking?.effortRouting;
+	if (routing === undefined) return spec;
+	const hasMaxModeRoute = Object.values(routing).some(
+		(target): target is string => typeof target === "string" && isCursorMaxModeWireId(target),
+	);
+	return hasMaxModeRoute ? { ...spec, cursorMaxMode: true } : spec;
+}
+
+/**
+ * Index the discovered `max_mode` marker of every live Cursor member by its own
+ * wire id. The collapsed row's `cursorMaxMode` is an OR across members, so it
+ * says nothing per tier; the transport needs the marker addressable by the wire
+ * id it actually sends, because upstream marks tiers the slug cannot identify
+ * (the whole Opus `-fast` lane is max-mode, `-low-fast` included). Returns
+ * `undefined` when no member carries a marker, so unmarked rosters add no field.
+ */
+function cursorMaxModeRoutesOf<TSpec extends VariantSpecLike>(
+	provider: string,
+	memberSpecs: readonly TSpec[],
+): Record<string, boolean> | undefined {
+	if (provider !== "cursor") return undefined;
+	let routes: Record<string, boolean> | undefined;
+	for (const member of memberSpecs) {
+		if (member.cursorMaxMode === undefined) continue;
+		routes ??= {};
+		routes[member.id] = member.cursorMaxMode;
+	}
+	return routes;
+}
+
+/**
+ * Lift Cursor's max-mode markers from live member rows onto an already-collapsed
+ * snapshot. Bundled catalog and cache rows froze the flag from `memberSpecs[0]`
+ * — the `-none`/`-low` tier — so the committed `gpt-5.6-*` / `cursor-grok-*`
+ * rows carry `cursorMaxMode: false`. The existing-collapsed pass-through keeps
+ * the snapshot verbatim, so a live `GetUsableModels` roster that marks the
+ * `-xhigh`/`-max` tiers would be discarded and max-tier requests would keep
+ * sending `max_mode: false` on a max-mode-only wire id. The row-level flag
+ * mirrors the fresh-collapse aggregation: only the positive case is lifted, so
+ * a roster that marks nothing leaves the snapshot alone. The per-wire-id
+ * markers are merged on top of the snapshot's own so live rows win per route.
+ * Returns `spec` by reference when unchanged.
+ */
+function reconcileCursorMaxMode<TSpec extends VariantSpecLike>(spec: TSpec, memberSpecs: readonly TSpec[]): TSpec {
+	const routes = cursorMaxModeRoutesOf(spec.provider, memberSpecs);
+	const lifts = spec.cursorMaxMode !== true && memberSpecs.some(member => member.cursorMaxMode === true);
+	if (routes === undefined && !lifts) return spec;
+	return {
+		...spec,
+		...(lifts ? { cursorMaxMode: true } : {}),
+		...(routes === undefined ? {} : { cursorMaxModeRoutes: { ...spec.cursorMaxModeRoutes, ...routes } }),
+	};
+}
+
 /**
  * Collapse every family in `table` found in `specs`. Non-member specs pass
  * through verbatim (by reference), order preserved; the collapsed spec
@@ -776,7 +850,9 @@ function collapseWithTable<TSpec extends VariantSpecLike>(
 			// Recycled extraAliases rows are healed in a later pass.
 			const refreshed =
 				existing !== undefined && existingCollapsed
-					? reconcileDefaultMember(refreshCollapsedThinking(reconciled ?? existing, family, retired), family)
+					? reconcileCursorMaxModeFromRouting(
+							reconcileDefaultMember(refreshCollapsedThinking(reconciled ?? existing, family, retired), family),
+						)
 					: reconciled;
 			if (refreshed !== undefined && refreshed !== existing) {
 				familyIdBySpecId.set(family.id, family.id);
@@ -788,20 +864,26 @@ function collapseWithTable<TSpec extends VariantSpecLike>(
 		for (const id of rawPresent) familyIdBySpecId.set(id, family.id);
 		if (existing) familyIdBySpecId.set(family.id, family.id);
 
+		const memberSpecs: TSpec[] = [];
+		for (const id of rawPresent) {
+			const member = byId.get(id);
+			if (member !== undefined) memberSpecs.push(member);
+		}
+
 		if (existingCollapsed && reconciled !== undefined) {
 			// Mixed input: the collapsed entry wins; stale raw members are deduped
 			// away. Retired targets are re-pointed first, then the default wire id
 			// prefers the family's declared member when live and otherwise falls
-			// back to the first member the account actually advertised.
-			replacement.set(family.id, reconcileDefaultMember(reconciled, family, new Set(rawPresent)));
+			// back to the first member the account actually advertised. The live
+			// members still own `cursorMaxMode`: the snapshot froze it from the
+			// lowest tier.
+			replacement.set(
+				family.id,
+				reconcileCursorMaxMode(reconcileDefaultMember(reconciled, family, new Set(rawPresent)), memberSpecs),
+			);
 			continue;
 		}
 
-		const memberSpecs: TSpec[] = [];
-		for (const id of rawPresent) {
-			const member = byId.get(id);
-			if (member !== undefined) memberSpecs.push(member);
-		}
 		const firstMember = memberSpecs[0];
 		if (firstMember === undefined) continue;
 		const presentSet = new Set(rawPresent);
@@ -836,6 +918,14 @@ function collapseWithTable<TSpec extends VariantSpecLike>(
 		if (memberSpecs.some(spec => spec.input.includes("text"))) input.push("text");
 		if (memberSpecs.some(spec => spec.input.includes("image"))) input.push("image");
 
+		// `cursorMaxMode` gates the `max_mode` request flag. The collapsed row
+		// otherwise inherits `memberSpecs[0]`, so a family whose max-mode member
+		// is not the first one would advertise `false` and send `max_mode: false`
+		// on a max-mode wire id. Only the positive case is aggregated — an
+		// unmarked family keeps whatever the first member carried. The OR loses
+		// which tier needed it, so the members' own markers are kept per wire id.
+		const cursorMaxMode = memberSpecs.some(spec => spec.cursorMaxMode === true) ? true : undefined;
+		const cursorMaxModeRoutes = cursorMaxModeRoutesOf(firstMember.provider, memberSpecs);
 		const collapsed: TSpec = {
 			...firstMember,
 			id: family.id,
@@ -844,6 +934,8 @@ function collapseWithTable<TSpec extends VariantSpecLike>(
 			input,
 			contextWindow: maxOrNull(memberSpecs.map(spec => spec.contextWindow)),
 			maxTokens: maxOrNull(memberSpecs.map(spec => spec.maxTokens)),
+			...(cursorMaxMode === undefined ? {} : { cursorMaxMode }),
+			...(cursorMaxModeRoutes === undefined ? {} : { cursorMaxModeRoutes }),
 		};
 		// The default wire id is the family's declared `defaultMember` when live,
 		// else the highest-priority live member. Omitted when it equals the

package/src/compat/resolve.ts

@@ -34,7 +34,7 @@ import type {
 import { isAnthropicSigningProxyUrl, isAzureAnthropicRoute, isOfficialAnthropicApiUrl } from "./anthropic";
 import { applyCompatOverrides } from "./apply";
 import { API_COMPAT_RECORDS, AXES, type CompatRecordName } from "./axes";
-import { resolveCascade } from "./cascade";
+import { hasModelScopedEffortsRule, resolveCascade } from "./cascade";
 import { compareRevision, parseRevision, type Revision } from "./revision";
 import { classifyModel, stripThinkingVariantSuffix } from "./taxonomy";
 import type { ModelIdentity, ResolvedAxes, ResolveTarget } from "./types";
@@ -1271,3 +1271,16 @@ export function resolveModelPolicy(spec: ModelSpec<Api>): ResolvedModelPolicy<Ap
 		catalog: axes.catalog,
 	};
 }
+
+/**
+ * Whether reviewed rules know THIS model's effort ladder, as opposed to it
+ * inheriting a provider-wide default or {@link resolveThinkingPolicy} falling
+ * through to the neutral wire ladder.
+ *
+ * Discovery uses this to tell "omp knows this model's tiers" apart from "omp
+ * is guessing them", so catalog-published tiers can correct the guess without
+ * ever overriding reviewed knowledge.
+ */
+export function hasModelScopedEffortLadder<TApi extends Api>(spec: ModelSpec<TApi>): boolean {
+	return hasModelScopedEffortsRule(buildResolveTarget(spec, resolveIdentity(spec)));
+}

package/src/compat/rules/providers/devin.kdl

@@ -39,4 +39,50 @@ provider "devin" {
 			supports-parallel-tool-calls #true
 		}
 	}
+
+
+	// Devin omits cost dimensions for plan-included models on lower tiers
+	// (PRO reports $0 for SWE-2, SWE-1.7, and GLM-5.2 High). `cost-fallback`
+	// seeds the enterprise-tier list price only when upstream reports no
+	// token price, so accounts whose discovery does carry dimensions keep
+	// their real rates.
+
+	// SWE-2: enterprise promo is 75% off list through 2026-12-31; list
+	// pricing ($3/$15, $0.30 cache read) applies from 2027-01-01.
+	models "swe-2*" {
+		cost-fallback {
+			input 0.75
+			output 3.75
+			cache-read 0.075
+			cache-write 0.75
+			effective-rates {
+				list-price {
+					effective-from "2027-01-01T00:00:00Z"
+					input 3
+					output 15
+					cache-read 0.3
+					cache-write 3
+				}
+			}
+		}
+	}
+
+	// SWE-1.7 and GLM-5.2 High: plan-included on PRO, no published promo
+	// schedule — enterprise list is the only published per-token price.
+	models "swe-1-7" "swe-1-7-medium" {
+		cost-fallback {
+			input 0.5
+			output 2.5
+			cache-read 0.2
+			cache-write 0.5
+		}
+	}
+	models "glm-5-2" {
+		cost-fallback {
+			input 1.4
+			output 4.4
+			cache-read 0.26
+			cache-write 1.4
+		}
+	}
 }

package/src/compat/rules/providers/kimi-code.kdl

@@ -39,4 +39,52 @@ provider "kimi-code" {
 		thinking-efforts "minimal" "low" "medium" "high"
 		thinking-format "zai"
 	}
+
+	// /coding/v1/models carries no pricing. `cost-fallback` seeds the public
+	// Moonshot list price only when discovery reports $0, so a future priced
+	// envelope keeps its real rates. `kimi-for-coding` is K2.8 Preview — no
+	// public API SKU exists yet, so it uses the K2.7 Code line rate.
+	models "k3" "k3-256k" {
+		cost-fallback {
+			input 3.0
+			output 15.0
+			cache-read 0.3
+		}
+	}
+	models "kimi-for-coding" {
+		cost-fallback {
+			input 0.95
+			output 4.0
+			cache-read 0.19
+		}
+	}
+	models "kimi-for-coding-highspeed" {
+		cost-fallback {
+			input 1.9
+			output 8.0
+			cache-read 0.38
+		}
+	}
+	// Moonshot K2 list (`kimi-k2-0711-preview` / `kimi-k2-0905-preview`), not K2.6.
+	models "kimi-k2" {
+		cost-fallback {
+			input 0.6
+			output 2.5
+			cache-read 0.15
+		}
+	}
+	models "kimi-k2.5" {
+		cost-fallback {
+			input 0.6
+			output 3.0
+			cache-read 0.1
+		}
+	}
+	models "kimi-k2-turbo-preview" {
+		cost-fallback {
+			input 2.4
+			output 10.0
+			cache-read 0.6
+		}
+	}
 }