@oh-my-pi/pi-catalog 18.10.3 → 18.10.4

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [18.10.4] - 2026-10-13
+
+### Added
+
+- Added Muse Code's subscription-only Muse Wonder Full and Wonder contributor tiers with the `max` effort, recording API-equivalent cost instead of $0: Wonder Full at Muse Wonder's $4 input / $0.20 cached / $20 output per 1M tokens, contributor tiers at the measured $1.60 / $0.08 / $8 ([#15522](https://github.com/can1357/oh-my-pi/pull/15522) by [@eggpeat](https://github.com/eggpeat))
+- Added the `classifier-cot-extraction` rule axis, set for Claude, marking models whose classifier refuses earlier reasoning quoted back into their input ([#15436](https://github.com/can1357/oh-my-pi/pull/15436) by [@will-bogusz](https://github.com/will-bogusz))
+- Added Gemini 4 Argon pricing on Cursor ($2 input / $0.10 cached / $10 output per 1M tokens) and Google Antigravity, which now uses Google's first-party rate instead of showing $0 ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Added scheduled list-price changes to `cost-patch`, as `cost-fallback` already allowed: a dated `effective-rates` card sets the price from its date, and each request is priced at the card in force when it was made, even on models loaded before the change, on rebuilt models, and on Cursor lanes priced from a sibling's card. A malformed dated card now fails the model build instead of silently keeping the old price. `getEffectiveTokenCost` returns that card for price displays, and `hasRecurringTariff` tells these dated-only schedules apart from peak/off-peak tariffs, which alone show a status-line arrow ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+
+### Changed
+
+- Devin models with a long-context price tier (GPT-5.4 through 5.6 standard lanes, GPT-6 through 6.1, Gemini Pro, and Grok 4.5 through 4.7) now default to a 272K or 200K context window, where that pricing starts; run `/extended-context on` to use the full window at long-context rates ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Devin SWE-2, SWE-1.7, and GLM-5.2 fallback pricing no longer charges cache writes at the input rate, since Devin publishes no cache-write rate for them ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Google Antigravity now lists Gemini 4 Argon once, with selectable low, medium, and high thinking levels, instead of a separate entry per thinking tier ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Gemini 4 Argon on Google, Vertex, Google Antigravity, and Cursor moves to Google's $4 input / $0.20 cached / $20 output list price on 2026-12-01 (midnight US Pacific), including requests on models loaded before then, without a catalog update ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+- Devin SWE-2's promotional fallback price now ends on 2027-01-01 for requests on models loaded before then too ([#15620](https://github.com/can1357/oh-my-pi/pull/15620) by [@eggpeat](https://github.com/eggpeat))
+
+### Fixed
+
+- Fixed Devin Claude and GPT-5.6 through GPT-6 models pricing prompt-cache writes at $0; they now use Devin's published rate of 1.25x input, and Adaptive uses its input rate ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Devin GPT-5.4 through GPT-6.1, Gemini Pro, and Grok 4.5 through 4.7 models missing the long-context price tiers Devin publishes above 272K and 200K prompt tokens ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Devin Fusion pairings ignoring their lead model's rules, including its cache-write rate and long-context tier ([#14891](https://github.com/can1357/oh-my-pi/pull/14891) by [@eggpeat](https://github.com/eggpeat)).
+- Fixed Kilo and NanoGPT models showing stale or missing prices (for example Gemini 4 Argon at $4/$20 instead of $2/$10, and many models at $0); prices now come from each gateway's live model list ([#15623](https://github.com/can1357/oh-my-pi/pull/15623) by [@eggpeat](https://github.com/eggpeat))
+- Fixed NanoGPT models showing their raw id as the name and no context window (disabling auto-compaction) when the bundled catalog lacked them; names, context windows and output limits now come from NanoGPT's live model list ([#15623](https://github.com/can1357/oh-my-pi/pull/15623) by [@eggpeat](https://github.com/eggpeat))
+
+### Removed
+
+- Removed the Codex `toolMode` model field (`code_mode_only`); Codex discovery no longer maps `tool_mode`
+
 ## [18.10.3] - 2026-10-12
 
 ### Breaking Changes

package/README.md

@@ -47,12 +47,14 @@ The `models` subpath (also exported from the root) provides timestamp-aware pric
 | `calculateCost(model, usage, timestamp?)`                         | Updates and returns `usage.cost` using `model.cost`.                                                      |
 | `calculateUsageCost(cost, usage, timestamp?)`                     | Updates and returns `usage.cost` using a `ModelCost`.                                                     |
 | `calculateUncachedInputCost(cost, promptInputTokens, timestamp?)` | Returns the cost of a fully uncached prompt.                                                              |
-| `getTimeBasedPricingPeriod(cost, timestamp?)`                     | Returns `"peak"`, `"off-peak"`, or `undefined` without a schedule.                                        |
+| `getEffectiveTokenCost(cost, timestamp?)`                         | Returns the base card in force: the latest due effective rate, else the row's own legs.                  |
+| `getTimeBasedPricingPeriod(cost, timestamp?)`                     | Returns `"peak"`, `"off-peak"`, or `undefined` without a recurring tariff.                                |
+| `hasRecurringTariff(schedule)`                                    | Whether a `TimeBasedCost` carries a peak/off-peak tariff rather than only dated rate cards.               |
 | `getNextTimeBasedPricingTransition(cost, timestamp?)`             | Returns the next actual peak/off-peak change strictly after the timestamp, or `undefined` if none exists. |
 
 Timestamps are Unix milliseconds; omitted timestamps use the current time for scheduled pricing. Flat token prices are unaffected. Pricing selects the latest applicable effective rate card, then its long-context tier, then the peak/off-peak multiplier. A transition query concerns the recurring tariff, not dated rate-card changes.
 
-`ModelCost.timeBased` is optional typed metadata (`TimeBasedCost`): `offPeakMultiplier`, `peakWindows` (UTC `weekdays`, Sunday = 0, and start-inclusive/end-exclusive `startMinute`/`endMinute`), and optional `effectiveRates`. Each effective rate is a complete `TokenCost` with an `effectiveFrom` Unix-millisecond timestamp and optional `longContext` tier, replacing the base card from that instant.
+`ModelCost.timeBased` is optional typed metadata (`TimeBasedCost`): `offPeakMultiplier`, `peakWindows` (UTC `weekdays`, Sunday = 0, and start-inclusive/end-exclusive `startMinute`/`endMinute`), and optional `effectiveRates`. Each effective rate is a complete `TokenCost` with an `effectiveFrom` Unix-millisecond timestamp and optional `longContext` tier, replacing the base card from that instant. A schedule with no peak windows at a 1x off-peak multiplier has no recurring tariff, only dated rate cards: `cost-patch`/`cost-fallback` `effective-rates` compile to one, so a row built before a scheduled price change still prices later requests at the new card.
 
 Pass the request-start timestamp when estimating request usage, then preserve the resulting monetary amounts rather than repricing history at display time. OMP does this using the assistant message timestamp; it is an estimation convention, not a claim about server billing across boundaries. Prefer monetary costs reported by a provider when available.
 

package/dist/types/build.d.ts

@@ -9,8 +9,9 @@
 import { type Api, type Model, type ModelSpec } from "./types.js";
 /**
  * Applies reviewed catalog-data value corrections (`cost-patch`,
- * `cache-read-at-input-rate`, `limits-patch`, `long-context-cost`,
- * `context-window-floor`, `input-modalities`) onto an upstream-sourced spec. Applied by
+ * `cache-read-at-input-rate`, `cache-write-rate`, `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.

package/dist/types/models.d.ts

@@ -1,5 +1,5 @@
 import MODELS from "./models.json";
-import type { Api, KnownProvider, Model, ModelCost, ModelPricingStatus, Usage } from "./types.js";
+import type { Api, KnownProvider, Model, ModelCost, ModelPricingStatus, TimeBasedCost, TokenCost, Usage } from "./types.js";
 export type GeneratedProvider = keyof typeof MODELS;
 /** Whether `provider` has bundled rows in models.json (e.g. a provider id authored in KDL). */
 export declare function isGeneratedProvider(provider: string): provider is GeneratedProvider;
@@ -8,6 +8,21 @@ export declare function getBundledProviders(): KnownProvider[];
 export declare function getBundledModels(provider: GeneratedProvider): Model<Api>[];
 /** Resolve display semantics without mistaking an absent rate card for a free model. */
 export declare function getModelPricingStatus(model: Pick<Model<Api>, "cost" | "pricingStatus">): ModelPricingStatus;
+/**
+ * The base token card in force at `timestamp` (Unix ms, default now): the
+ * latest due `timeBased` effective rate, else the row's own legs. Price
+ * displays read this rather than the scalar legs, which keep the card current
+ * when the row was built while bundles, caches, and long sessions outlive it.
+ * Applies no long-context tier or peak/off-peak multiplier.
+ */
+export declare function getEffectiveTokenCost(cost: ModelCost, timestamp?: number): TokenCost;
+/**
+ * Whether a schedule carries a recurring peak/off-peak tariff. A schedule with
+ * no peak windows at a 1x off-peak multiplier only carries dated rate cards
+ * (`cost-patch`/`cost-fallback` `effective-rates`): its price changes on a
+ * date, never by time of day.
+ */
+export declare function hasRecurringTariff(schedule: TimeBasedCost): boolean;
 /** Return the recurring UTC tariff period, independently of its monetary multiplier. */
 export declare function getTimeBasedPricingPeriod(cost: ModelCost, timestamp?: number): "peak" | "off-peak" | undefined;
 /** Return the next actual peak/off-peak change strictly after the Unix-ms timestamp. */

package/dist/types/pricing.d.ts

@@ -1,5 +1,41 @@
-import type { TimeBasedCost } from "./types.js";
+import type { EffectiveTokenCost, ModelCost, TimeBasedCost, TokenCost } from "./types.js";
 /** Validate serialized schedules before admitting cached model rows. */
 export declare function isTimeBasedCost(value: unknown): value is TimeBasedCost;
 /** KDL object children are named records; normalize them once while constructing the model. */
 export declare function materializeTimeBasedCost(value: unknown): TimeBasedCost;
+/**
+ * The latest `effectiveRates` card of a materialized schedule due at
+ * `timestamp`, or undefined before the first one (or without a schedule).
+ */
+export declare function dueEffectiveRate(schedule: TimeBasedCost | undefined, timestamp: number): EffectiveTokenCost | undefined;
+/** A `cost-patch`/`cost-fallback` dated card: the legs it overwrites from `effectiveFrom` (Unix ms). */
+export interface DatedCostCard extends Partial<TokenCost> {
+    effectiveFrom: number;
+}
+/**
+ * Parse the compiled `effective-rates` block of a `cost-patch` or
+ * `cost-fallback` payload into dated cards, ascending by date. Throws on a
+ * malformed card, so a typo in a rule fails the build instead of silently
+ * leaving the old price in force.
+ */
+export declare function parseDatedCostCards(costAxis: unknown, axis: "cost-patch" | "cost-fallback"): DatedCostCard[];
+/**
+ * Earliest instant a rate card can name (the `Date` range minimum). A leading
+ * card from here holds the price in force before the first dated change.
+ */
+export declare const EARLIEST_EFFECTIVE_FROM = -8640000000000000;
+/** A schedule of dated rate cards alone: no peak windows, no off-peak discount. */
+export declare const NO_RECURRING_TARIFF: TimeBasedCost;
+/**
+ * A flat card plus its dated overrides as a request-time `ModelCost`: the
+ * card due at `now` in the scalar legs, and every period (a leading card for
+ * the base price, then each dated card over the previous one) in a
+ * `timeBased` schedule without a recurring tariff. The plain card when no
+ * dated card exists.
+ */
+export declare function datedCost(base: TokenCost, cards: readonly DatedCostCard[], now?: number): ModelCost;
+/**
+ * Overwrite `cost` legs with the latest dated card due at `now`. Leaves
+ * `cost` unchanged before the first card.
+ */
+export declare function applyDueDatedCostCard(cost: TokenCost, cards: readonly DatedCostCard[], now?: number): void;

package/dist/types/types.d.ts

@@ -1401,8 +1401,6 @@ export interface Model<TApi extends Api = Api> {
     preferWebsockets?: boolean;
     /** Codex Responses Lite transport: send the lite marker and carry instructions/tools as input items (mirrors codex-rs `use_responses_lite`). */
     useResponsesLite?: boolean;
-    /** Codex Code Mode restriction: model expects tools routed through a programmatic exec surface (mirrors codex-rs `tool_mode`). */
-    toolMode?: "code_mode_only";
     /**
      * Service-tier ids the provider advertises for this model (Codex discovery
      * `service_tiers[].id`, e.g. `priority`, `ultrafast`). Absent when the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.10.3",
+	"version": "18.10.4",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"keywords": [
 		"ai",
@@ -93,12 +93,12 @@
 		"gen:proto": "bun scripts/generate-protocols.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.10.3",
-		"@oh-my-pi/pi-utils": "18.10.3"
+		"@oh-my-pi/omptype": "18.10.4",
+		"@oh-my-pi/pi-utils": "18.10.4"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.10.3",
+		"@oh-my-pi/pi-ai": "18.10.4",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -10,8 +10,16 @@
 import { resolveDiscoveryApi, resolveModelPolicy } from "./compat/resolve";
 import type { ModelIdentity } from "./compat/types";
 import { resolveModelTokenizer } from "./model-tokenizer";
-import { materializeTimeBasedCost } from "./pricing";
-import { type Api, MODEL_KINDS, type Model, type ModelSpec } from "./types";
+import {
+	applyDueDatedCostCard,
+	type DatedCostCard,
+	dueEffectiveRate,
+	EARLIEST_EFFECTIVE_FROM,
+	materializeTimeBasedCost,
+	NO_RECURRING_TARIFF,
+	parseDatedCostCards,
+} from "./pricing";
+import { type Api, type EffectiveTokenCost, MODEL_KINDS, type Model, type ModelCost, type ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
 function numberField(source: object, key: string): number | undefined {
@@ -24,41 +32,6 @@ 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");
@@ -164,52 +137,65 @@ function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog:
 	}
 }
 
+/** The parsed dated cards of a row's `cost-patch` and `cost-fallback`. */
+interface DatedCostCards {
+	patch: readonly DatedCostCard[];
+	fallback: readonly DatedCostCard[];
+}
+
 /**
- * Applies reviewed catalog-data value corrections (`cost-patch`,
- * `cache-read-at-input-rate`, `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.
+ * The row's corrected price card at `now`: `cost-patch`, then `cost-fallback`
+ * (each with its dated card due at `now`), then the long-context tier and
+ * cache-rate derivations, all from the upstream card.
  */
-export function applyCatalogCorrections(
-	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+function correctedCost(
+	upstream: ModelCost,
 	catalog: Record<string, unknown>,
-): void {
+	cards: DatedCostCards,
+	now: number,
+): ModelCost {
+	let cost: ModelCost = { ...upstream };
+	const upstreamCard =
+		upstream.timeBased?.effectiveRates?.[0]?.effectiveFrom === EARLIEST_EFFECTIVE_FROM
+			? dueEffectiveRate(upstream.timeBased, now)
+			: undefined;
+	if (upstreamCard !== undefined) {
+		// A row rebuilt from an already built one (dynamic merges, overrides)
+		// carries the dated schedule compiled below. Its leading card covers all
+		// history, so the scalar legs only ever held the card due at the first
+		// build; start from the card due now instead.
+		const { effectiveFrom: _effectiveFrom, ...card } = upstreamCard;
+		const { longContext: _longContext, ...base } = cost;
+		cost = { ...base, ...card };
+	}
 	const patch = objectPayload(catalog.costPatch);
 	if (patch !== undefined) {
-		model.cost = { ...model.cost };
 		const input = numberField(patch, "input");
-		if (input !== undefined) model.cost.input = input;
+		if (input !== undefined) cost.input = input;
 		const output = numberField(patch, "output");
-		if (output !== undefined) model.cost.output = output;
+		if (output !== undefined) cost.output = output;
 		const cacheRead = numberField(patch, "cacheRead");
-		if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+		if (cacheRead !== undefined) cost.cacheRead = cacheRead;
 		const cacheWrite = numberField(patch, "cacheWrite");
-		if (cacheWrite !== undefined) model.cost.cacheWrite = cacheWrite;
+		if (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+		applyDueDatedCostCard(cost, cards.patch, now);
 	}
 	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;
+		const hasTokenPrice = cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.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;
+			if (input !== undefined) cost.input = input;
 			const output = numberField(fallback, "output");
-			if (output !== undefined) model.cost.output = output;
+			if (output !== undefined) cost.output = output;
 			const cacheRead = numberField(fallback, "cacheRead");
-			if (cacheRead !== undefined) model.cost.cacheRead = cacheRead;
+			if (cacheRead !== undefined) 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 (cacheWrite !== undefined) cost.cacheWrite = cacheWrite;
+			applyDueDatedCostCard(cost, cards.fallback, now);
 		}
 	}
 	const longContext = objectPayload(catalog.longContext);
@@ -221,20 +207,19 @@ export function applyCatalogCorrections(
 		const output = numberField(longContext, "output");
 		const cacheRead = numberField(longContext, "cacheRead");
 		const cacheWrite = numberField(longContext, "cacheWrite");
-		const base = model.cost;
-		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		const hasTokenPrice = cost.input !== 0 || cost.output !== 0 || cost.cacheRead !== 0 || cost.cacheWrite !== 0;
 		if (inputThreshold !== undefined && multiplier !== undefined && hasTokenPrice) {
 			// Multiplier form: tier rates derive from the row's final base card,
 			// after `cost-patch`/`cost-fallback` corrected the live list price.
-			model.cost = {
-				...base,
+			cost = {
+				...cost,
 				longContext: {
 					inputThreshold,
 					...(inclusive && { inputThresholdInclusive: true }),
-					input: base.input * multiplier,
-					output: base.output * multiplier,
-					cacheRead: base.cacheRead * multiplier,
-					cacheWrite: base.cacheWrite * multiplier,
+					input: cost.input * multiplier,
+					output: cost.output * (numberField(longContext, "outputMultiplier") ?? multiplier),
+					cacheRead: cost.cacheRead * multiplier,
+					cacheWrite: cost.cacheWrite * multiplier,
 				},
 			};
 		} else if (
@@ -244,19 +229,94 @@ export function applyCatalogCorrections(
 			cacheRead !== undefined &&
 			cacheWrite !== undefined
 		) {
-			model.cost = { ...model.cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
+			cost = { ...cost, longContext: { inputThreshold, input, output, cacheRead, cacheWrite } };
 		}
 	}
 	if (catalog.cacheReadAtInputRate === true) {
-		const { longContext } = model.cost;
-		model.cost = {
-			...model.cost,
-			cacheRead: model.cost.input,
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheRead: cost.input,
 			...(longContext && { longContext: { ...longContext, cacheRead: longContext.input } }),
 		};
 	}
-	if (catalog.timeBased !== undefined) {
-		model.cost = { ...model.cost, timeBased: materializeTimeBasedCost(catalog.timeBased) };
+	const cacheWriteRate = catalog.cacheWriteRate;
+	if (typeof cacheWriteRate === "number") {
+		const { longContext } = cost;
+		cost = {
+			...cost,
+			cacheWrite: cost.input * cacheWriteRate,
+			...(longContext && { longContext: { ...longContext, cacheWrite: longContext.input * cacheWriteRate } }),
+		};
+	}
+	return cost;
+}
+
+/**
+ * Every price period the dated `cost-patch`/`cost-fallback` cards define, for
+ * request-time selection (`calculateUsageCost`): a row built before a change
+ * still bills requests after it at the new price, and a leading card keeps
+ * earlier requests at the old one on rows built after it. Undefined when no
+ * card changes the price (no cards, or a fallback the upstream price outranks).
+ */
+function scheduledRates(
+	upstream: ModelCost,
+	catalog: Record<string, unknown>,
+	cards: DatedCostCards,
+): EffectiveTokenCost[] | undefined {
+	const dates = [...cards.patch, ...cards.fallback].map(card => card.effectiveFrom).sort((a, b) => a - b);
+	if (dates.length === 0) return undefined;
+	const periods: EffectiveTokenCost[] = [];
+	let previousPrice: string | undefined;
+	for (const effectiveFrom of [EARLIEST_EFFECTIVE_FROM, ...dates]) {
+		const { input, output, cacheRead, cacheWrite, longContext } = correctedCost(
+			upstream,
+			catalog,
+			cards,
+			effectiveFrom,
+		);
+		const price = { input, output, cacheRead, cacheWrite, ...(longContext && { longContext }) };
+		const key = JSON.stringify(price);
+		if (key === previousPrice) continue;
+		previousPrice = key;
+		periods.push({ effectiveFrom, ...price });
+	}
+	return periods.length > 1 ? periods : undefined;
+}
+
+/**
+ * Applies reviewed catalog-data value corrections (`cost-patch`,
+ * `cache-read-at-input-rate`, `cache-write-rate`, `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 function applyCatalogCorrections(
+	model: Pick<ModelSpec<Api>, "cost" | "contextWindow" | "maxTokens" | "input">,
+	catalog: Record<string, unknown>,
+): void {
+	const upstream = model.cost;
+	const cards: DatedCostCards = {
+		patch: parseDatedCostCards(catalog.costPatch, "cost-patch"),
+		fallback: parseDatedCostCards(catalog.costFallback, "cost-fallback"),
+	};
+	// The card due now is the row's displayed price; the dated schedule rides
+	// along so rows reused past a change (bundles, caches, long sessions) still
+	// bill each request at the card in force when it was made.
+	model.cost = correctedCost(upstream, catalog, cards, Date.now());
+	const recurring = catalog.timeBased === undefined ? undefined : materializeTimeBasedCost(catalog.timeBased);
+	const dated = scheduledRates(upstream, catalog, cards);
+	if (dated !== undefined) {
+		if (recurring?.effectiveRates !== undefined) {
+			throw new Error(
+				"Dated cost-patch/cost-fallback effective-rates cannot combine with time-based-cost effective-rates",
+			);
+		}
+		model.cost = { ...model.cost, timeBased: { ...(recurring ?? NO_RECURRING_TARIFF), effectiveRates: dated } };
+	} else if (recurring !== undefined) {
+		model.cost = { ...model.cost, timeBased: recurring };
 	}
 	const limitsPatch = objectPayload(catalog.limitsPatch);
 	if (limitsPatch !== undefined) {

package/src/compat/axes.ts

@@ -370,6 +370,19 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		shape: "scalar",
 		values: [true, false],
 	},
+	/**
+	 * The model's input classifier refuses requests that reproduce assistant
+	 * reasoning as quoted text (`reasoning_extraction`), so reasoning must not
+	 * be replayed as text into its input: compaction archives, summarizer
+	 * transcripts and demoted interrupted turns leave it out. Declared per class
+	 * in `classes/*.kdl`.
+	 */
+	"classifier-cot-extraction": {
+		key: "classifierCotExtraction",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false],
+	},
 	"clamp-context-override": { key: "clampContextOverride", set: "catalog", shape: "scalar" },
 	"context-promotion-target": { key: "contextPromotionTarget", set: "catalog", shape: "scalar" },
 	"context-window-floor": { key: "contextWindowFloor", set: "catalog", shape: "scalar" },
@@ -391,6 +404,14 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 		shape: "scalar",
 		values: [true, false],
 	},
+	/**
+	 * The host bills cache writes at this multiple of the row's live `input`
+	 * price, for hosts whose discovery reports cache-write tokens but no
+	 * cache-write rate. It replaces any `cacheWrite` the row carries, including
+	 * a `cost-patch`/`cost-fallback` value and an absolute long-context tier's
+	 * `cacheWrite` (rebased on the tier's `input`).
+	 */
+	"cache-write-rate": { key: "cacheWriteRate", set: "catalog", shape: "scalar" },
 	/**
 	 * How the model line bills a replayed signed thinking block as input:
 	 * `output` bills the reasoning its signature carries, at the size the turn

package/src/compat/resolve.ts

@@ -119,11 +119,24 @@ class IdentityFacts {
 	}
 }
 
+/**
+ * The id a spec resolves identity and rules under: its own, unless that names
+ * no model and the row sends a model that does on the wire. A Devin Fusion
+ * pairing runs only its lead, so the lead's reviewed rules (cache-write rate,
+ * long-context tier) apply to it at build time.
+ */
+function policyModelId<TApi extends Api>(spec: ModelSpec<TApi>): string {
+	const wireId = spec.requestModelId;
+	if (wireId === undefined || wireId === spec.id) return spec.id;
+	if (classifyModel(spec.provider, spec.id).class !== "unknown") return spec.id;
+	return classifyModel(spec.provider, wireId).class === "unknown" ? spec.id : wireId;
+}
+
 function resolveIdentity<TApi extends Api>(spec: ModelSpec<TApi>): ModelIdentity {
 	// Strict on purpose: ambiguous identity is a rule-authoring defect surfaced
 	// at build/CI time, never silently degraded to `unknown`. Discovery
 	// normalization opts into leniency through `classifyModel` directly.
-	return classifyModel(spec.provider, spec.id);
+	return classifyModel(spec.provider, policyModelId(spec));
 }
 
 // ---------------------------------------------------------------------------
@@ -1305,7 +1318,7 @@ function buildResolveTarget<TApi extends Api>(
 		provider: providerType,
 		api: spec.api,
 		class: identity.class,
-		model: spec.id,
+		model: policyModelId(spec),
 		reasoning: Boolean(spec.reasoning),
 	};
 	if (identity.family !== undefined) target.family = identity.family;

package/src/compat/rules/README.md

@@ -196,6 +196,8 @@ An `on-api` nested inside `on` under a class requires both the selected provider
 
 A `models` string without `*` is an exact, case-sensitive match against the provider-relative model identifier. A string containing `*` is an anchored, ASCII-case-insensitive wildcard match. Prefer taxonomy ranks; retain exact/glob lists only when they isolate the census member set exactly, and keep a `// residue:` comment explaining why ranks do not.
 
+A row whose own id classifies as `unknown` but whose `requestModelId` does not resolves under the wire id: classification and `models` matching both use it, so the model the row sends gets its own rules. Devin Fusion pairings (`fusion-<lead>-sidekick-*`) resolve as their lead this way.
+
 `priority=N` is an optional signed integer property on the block that owns axis assignments. Its default is zero. Use it only to resolve an intentional equal-specificity overlap; do not use it to encode declaration order.
 
 `buildDiscoveredModel(spec, providerType)` resolves the catalog `discovery-api` axis before materializing compatibility. It preserves the credential-bearing provider ID and records `providerType` as the backend used for provider selectors on subsequent rebuilds. Ordinary `buildModel` preserves its input API. This lets custom-named llama.cpp deployments reuse the same rules without model-specific discovery code.
@@ -213,7 +215,9 @@ The three value shapes are:
 - **Object**: no arguments and a child block, including an empty block. Child names are kebab-case: an axis-directive spelling compiles to its resolved axis key (`template-reasoning-effort` → `qwenTemplateReasoningEffort`), anything else converts mechanically (`input-threshold` → `inputThreshold`); camelCase names are a compile error. `extra-body` payloads (top-level or nested) are the exception — their child names are literal wire JSON keys copied verbatim (`enable_thinking`). Each child is either one scalar or another object; arrays are not representable inside an object payload.
 
 A rule cannot assign the same resolved axis twice in one block.
-One object axis carries a computed form: `long-context-cost` accepts either the absolute rates (`input-threshold` + `input`/`output`/`cache-read`/`cache-write`) or `input-threshold` + `multiplier` (with optional `input-threshold-inclusive`), which derives the tier from the row's base price at build time, after `cost-patch` and `cost-fallback`, so the rule tracks upstream list-price updates (xAI's SuperGrok 200K tier). Rows without a token price carry no tier. An empty `long-context-cost {}` adds no tier; a more specific rule uses it to opt a host out of a broader rule's band (GitHub Copilot's Haiku 5.5 rows, whose long tier is the `-1m` sibling).
+One object axis carries a computed form: `long-context-cost` accepts either the absolute rates (`input-threshold` + `input`/`output`/`cache-read`/`cache-write`) or `input-threshold` + `multiplier` (with optional `input-threshold-inclusive`, and `output-multiplier` when the tier raises output by a different factor than the other legs), which derives the tier from the row's base price at build time, after `cost-patch` and `cost-fallback`, so the rule tracks upstream list-price updates (xAI's SuperGrok 200K tier). Rows without a token price carry no tier. An empty `long-context-cost {}` adds no tier; a more specific rule uses it to opt a host out of a broader rule's band (GitHub Copilot's Haiku 5.5 rows, whose long tier is the `-1m` sibling).
+
+`cost-patch` and `cost-fallback` accept an optional `effective-rates` block of named dated cards, each with a distinct ISO UTC `effective-from` (`YYYY-MM-DDTHH:mm:ssZ` or with three fractional-second digits) and any of `input`/`output`/`cache-read`/`cache-write` as nonnegative rates; a malformed card fails `buildModel` rather than leaving the old price in force. A card overwrites those legs from its date: for `cost-patch` over whatever upstream reports, for `cost-fallback` only when it seeded the row. A patch may carry the dated cards alone, leaving the upstream price in place until the first one starts; pin the current price beside them when upstream may later report the new one, or a row built after that loses the earlier period (Gemini 4 Argon's 2026-12-01 list-price increase in [`classes/gemini.kdl`](classes/gemini.kdl) pins both). `buildModel` sets the row's legs to the card due when it is built, and compiles every price period into `ModelCost.timeBased.effectiveRates` (complete cards, long-context tier and cache-rate derivations included, with a leading card for the price before the first change) under a schedule with no peak windows and a 1x off-peak multiplier. Requests are therefore priced at the card in force when they were made, even on rows built before a change (bundles, caches, long sessions); price displays read `getEffectiveTokenCost`, which selects the same card, and such a schedule reports no peak/off-peak period. Rebuilding a row that already carries such a schedule (dynamic merges, overrides) starts from the card due at the rebuild, and Cursor lanes priced from a sibling slug's card keep that card's schedule, scaled by the lane's multiplier. Cards that leave the price unchanged (a fallback the upstream price outranks) add no schedule. A rule cannot combine these cards with `time-based-cost` `effective-rates`; it may add them to a recurring `time-based-cost` tariff without its own.
 
 `context-window-authoritative #true` preserves a host's supplied context window through runtime model selection instead of applying inferred expansion or reference-price-tier caps. Explicit user context overrides still apply afterward. It applies to rows materialized through `buildModel` (discovery and regenerated bundles). See [`providers/factory-droid.kdl`](providers/factory-droid.kdl).
 

package/src/compat/rules/classes/anthropic.kdl

@@ -25,6 +25,9 @@
 // https://platform.claude.com/docs/en/build-with-claude/preserved-thinking#switching-models
 class "anthropic" {
 	prompt-cache-lookback 20
+	// Claude's input classifier refuses requests that quote earlier reasoning
+	// back as text (`reasoning_extraction`, issue #6093).
+	classifier-cot-extraction #true
 	thinking-replay-tokens "output"
 	// verified: billing matched this formula on Opus 4.7+ and Fable 5.1.
 	image-tokenization {

package/src/compat/rules/classes/gemini.kdl

@@ -81,6 +81,34 @@ class "gemini" {
 			}
 		}
 	}
+	// Gemini 4 Argon's introductory list price ($2/$10, $0.10 cached) ends
+	// 2026-11-30; from 2026-12-01 Google bills $4/$20, $0.20 cached, on the
+	// Gemini API and Vertex global endpoint alike. Cloud Billing days start at
+	// midnight US Pacific. Both cards are pinned over whatever stencil.so or
+	// the bundled pricing peer reports: the switch needs no regeneration, and
+	// a row built after upstream catches up still prices earlier requests at
+	// the introductory rate.
+	// https://ai.google.dev/gemini-api/docs/pricing
+	// https://cloud.google.com/vertex-ai/generative-ai/pricing
+	on "google" "google-vertex" "google-antigravity" {
+		models "gemini-4-argon" {
+			cost-patch {
+				input 2
+				output 10
+				cache-read 0.1
+				cache-write 0
+				effective-rates {
+					list-price {
+						effective-from "2026-12-01T08:00:00Z"
+						input 4
+						output 20
+						cache-read 0.2
+						cache-write 0
+					}
+				}
+			}
+		}
+	}
 
 	revision ">=3" {
 		// Replaces the Google multimodal function-response baseline.

package/src/compat/rules/classes/meta.kdl

@@ -9,8 +9,10 @@ class "meta" {
 		thinking-efforts "minimal" "low" "medium" "high" "xhigh" "max"
 		thinking-mode "effort"
 	}
-	// Meta documents `max` for Muse Wonder (dev.meta.ai/docs/reasoning).
-	models "muse-wonder-1.0" {
+	// Meta documents `max` for Muse Wonder (dev.meta.ai/docs/reasoning); the
+	// Muse Code-only Wonder Full and contributor tiers accept it too (verified
+	// 2026-10-12).
+	models "muse-wonder-1.0" "muse-wonder-1.0-contributor" "muse-wonder-full-1.0" "muse-wonder-full-1.0-contributor" {
 		thinking-efforts "minimal" "low" "medium" "high" "xhigh" "max"
 		thinking-mode "effort"
 	}