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

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/context-window.ts

@@ -6,8 +6,11 @@ import { resolveModelPolicy } from "./resolve";
  * Rule-owned maxima by provider/id/api. Resolve once per process rather than
  * walking the static policy cascade on every catalog rebuild. Null caches the
  * absence of a curated maximum; undefined means the key has not been resolved.
+ * Bounded: one entry per distinct model; the wire-id set is bounded.
  */
 const ruleMaximumCache = new Map<string, number | null>();
+const clampOverrideCache = new Map<string, boolean>();
+const RULE_POLICY_CACHE_MAX = 8192;
 
 /**
  * Extended-context capacity. Curated maxima correct stale lower discovery
@@ -20,6 +23,7 @@ export function resolveMaxContextWindow(model: Model): number | undefined {
 	if (curated === undefined) {
 		const maximum = resolveModelPolicy(toModelSpec(model)).catalog.maxContextWindow;
 		curated = typeof maximum === "number" && Number.isFinite(maximum) && maximum > 0 ? maximum : null;
+		if (ruleMaximumCache.size >= RULE_POLICY_CACHE_MAX) ruleMaximumCache.clear();
 		ruleMaximumCache.set(key, curated);
 	}
 
@@ -49,7 +53,13 @@ export function codexOverrideCeiling(model: Model): number | undefined {
  * it here keeps provider deployment contracts out of TypeScript.
  */
 export function clampsContextOverride(model: Model): boolean {
-	return resolveModelPolicy(toModelSpec(model)).catalog.clampContextOverride === true;
+	const key = `${model.provider} ${model.id} ${model.api}`;
+	const cached = clampOverrideCache.get(key);
+	if (cached !== undefined) return cached;
+	const clamps = resolveModelPolicy(toModelSpec(model)).catalog.clampContextOverride === true;
+	if (clampOverrideCache.size >= RULE_POLICY_CACHE_MAX) clampOverrideCache.clear();
+	clampOverrideCache.set(key, clamps);
+	return clamps;
 }
 
 /**

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";
@@ -305,7 +305,11 @@ interface OpenAIDetection {
 	isOpenRouter: boolean;
 }
 
-function detectOpenAI(spec: ModelSpec<"openai-completions" | "openrouter">, facts: IdentityFacts): OpenAIDetection {
+function detectOpenAI(
+	spec: ModelSpec<"openai-completions" | "openrouter">,
+	facts: IdentityFacts,
+	reasoningCapable: boolean,
+): OpenAIDetection {
 	const provider = spec.provider;
 	const baseUrl = spec.baseUrl;
 	const hostModel = { provider, baseUrl };
@@ -315,7 +319,7 @@ function detectOpenAI(spec: ModelSpec<"openai-completions" | "openrouter">, fact
 	const isXiaomiHost = modelMatchesHost(hostModel, "xiaomi");
 	const isDirectDeepseekApi = modelMatchesHost(hostModel, "deepseekDirect");
 	const isDeepseekFamily = modelMatchesHost(hostModel, "deepseekFamily") || facts.is("deepseek");
-	const isDeepseekReasoning = isDeepseekFamily && Boolean(spec.reasoning);
+	const isDeepseekReasoning = isDeepseekFamily && reasoningCapable;
 	const isLocalOpenAICompatBackend =
 		PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true &&
 		(LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true || hasLocalLoopbackBaseUrl(baseUrl));
@@ -348,6 +352,7 @@ function detectOpenAI(spec: ModelSpec<"openai-completions" | "openrouter">, fact
 function detectOpenAICompat(
 	spec: ModelSpec<"openai-completions" | "openrouter">,
 	d: OpenAIDetection,
+	reasoningCapable: boolean,
 ): ResolvedOpenAICompat {
 	const provider = spec.provider;
 	const baseUrl = spec.baseUrl;
@@ -435,12 +440,12 @@ function detectOpenAICompat(
 			? GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS
 			: facts.is("mimo") && hostMatchesUrl(baseUrl, "xiaomi")
 				? 300_000
-				: spec.reasoning &&
+				: reasoningCapable &&
 					  facts.is("kimi") &&
 					  (facts.family("k3") || facts.family("k2.7-code")) &&
 					  hostMatchesUrl(baseUrl, "moonshotNative")
 					? 300_000
-					: spec.reasoning && facts.is("deepseek") && hostMatchesUrl(baseUrl, "deepseekDirect")
+					: reasoningCapable && facts.is("deepseek") && hostMatchesUrl(baseUrl, "deepseekDirect")
 						? 300_000
 						: d.isLocalServingBackend
 							? LOCAL_OPENAI_COMPAT_STREAM_IDLE_TIMEOUT_MS
@@ -476,13 +481,14 @@ function detectOpenAICompat(
 		// provider rule without changing Copilot Responses rows.
 		supportsReasoningParams: provider !== "github-copilot",
 		supportsSamplingParams: !(facts.is("openai") && (facts.family("o-series") || facts.revGte("5"))),
-		supportsPenaltyAndStopParams: !(isGrok && Boolean(spec.reasoning)),
+		supportsPenaltyAndStopParams: !(isGrok && reasoningCapable),
 		reasoningEffortMap: {},
 		supportsUsageInStreaming: !isCerebrasHost,
 		alwaysSendMaxTokens: facts.is("kimi"),
 		disableReasoningOnForcedToolChoice:
 			!d.isClinePass && ((facts.is("kimi") && !isMoonshotKimiK3) || isAnthropicModel),
-		disableReasoningOnToolChoice: !d.isClinePass && isDeepseekFamily && Boolean(spec.reasoning) && !d.isOpenRouter,
+		disableReasoningOnToolChoice: !d.isClinePass && isDeepseekFamily && reasoningCapable && !d.isOpenRouter,
+		disableReasoningWithTools: false,
 		supportsToolChoice: d.isClinePass || !d.isDirectDeepseekReasoning,
 		supportsForcedToolChoice:
 			!d.requiresEnabledThinking && !(d.isOpenCodeHost && d.isDeepseekReasoning) && !(d.isClinePass && isQwen),
@@ -506,12 +512,12 @@ function detectOpenAICompat(
 		reasoningContentField: d.isClinePass ? "reasoning" : "reasoning_content",
 		requiresReasoningContentForToolCalls:
 			(facts.is("kimi") && !d.isOpenCodeProvider) ||
-			(isDeepseekFamily && Boolean(spec.reasoning)) ||
+			(isDeepseekFamily && reasoningCapable) ||
 			d.isXiaomiMimo ||
-			(d.isOpenRouter && Boolean(spec.reasoning)),
+			(d.isOpenRouter && reasoningCapable),
 		requiresReasoningContentForAllAssistantTurns:
-			((isDeepseekFamily && Boolean(spec.reasoning)) || d.isXiaomiMimo) && !d.isOpenRouter,
-		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !spec.reasoning) && !d.isXiaomiMimo,
+			((isDeepseekFamily && reasoningCapable) || d.isXiaomiMimo) && !d.isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !reasoningCapable) && !d.isXiaomiMimo,
 		replayReasoningContent: d.isLocalOpenAICompatBackend,
 		qwenPreserveThinking:
 			(thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && d.isLocalOpenAICompatBackend,
@@ -577,6 +583,11 @@ const DSML_HEALING_PROVIDERS: Record<string, true> = {
 	nanogpt: true,
 	"opencode-go": true,
 	openrouter: true,
+	// Transparent gateways / user-configured hosts forward the upstream model's
+	// native chat template unchanged, so a deepseek-classed model behind them
+	// still emits DSML tool-call envelopes and needs the DSML healer.
+	litellm: true,
+	nous: true,
 };
 
 /**
@@ -635,7 +646,7 @@ function fixupOpenAICompat(
 		compat.omitReasoningEffort = true;
 	}
 
-	const axisWhenThinking = spec.reasoning ? objectPayload(axes.wire.whenThinking) : undefined;
+	const axisWhenThinking = compatReasoning(spec, axes) ? objectPayload(axes.wire.whenThinking) : undefined;
 	const whenThinkingPolicy =
 		spec.compat?.whenThinking ??
 		axisWhenThinking ??
@@ -662,8 +673,9 @@ function resolveOpenAICompletionsPolicy(
 	facts: IdentityFacts,
 	axes: ResolvedAxes,
 ): ResolvedOpenAICompat {
-	const d = detectOpenAI(spec, facts);
-	const compat = detectOpenAICompat(spec, d);
+	const reasoningCapable = compatReasoning(spec, axes);
+	const d = detectOpenAI(spec, facts, reasoningCapable);
+	const compat = detectOpenAICompat(spec, d, reasoningCapable);
 	applyWireAxes(compat, axes.wire, "openai-completions");
 	applyCompatOverrides(compat, spec.compat);
 	overlayEffortMapAxis(compat, axes, spec.compat);
@@ -689,7 +701,7 @@ function resolveOpenAIResponsesPolicy(
 	const supportsPromptCacheBreakpoints =
 		isOfficialOpenAIEndpoint(provider, baseUrl) && facts.is("openai") && facts.revGte("5.6");
 	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] = isOpenRouter ? "openrouter" : "openai";
-	const reasoningCapable = Boolean(spec.reasoning);
+	const reasoningCapable = compatReasoning(spec, axes);
 	const isLocalServingBackend =
 		(PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true && LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true) ||
 		hasLocalLoopbackBaseUrl(baseUrl);
@@ -729,6 +741,7 @@ function resolveOpenAIResponsesPolicy(
 		filterReasoningHistory: isOpenRouter && isAnthropicModel,
 		disableReasoningOnForcedToolChoice: facts.is("kimi"),
 		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		disableReasoningWithTools: false,
 		supportsToolChoice: true,
 		supportsForcedToolChoice: provider !== "opencode-go" && provider !== "opencode-zen",
 		supportsNamedToolChoice: true,
@@ -860,7 +873,8 @@ function resolveAnthropicPolicy(
 		supportsSamplingParams: !facts.anthropicAdaptiveGenAtLeast("4.7"),
 		requiresToolResultId: false,
 		requiresThinkingEnabled,
-		replayUnsignedThinking: !signingEndpoint && (Boolean(spec.reasoning) || modelMatchesHost(spec, "deepseekFamily")),
+		replayUnsignedThinking:
+			!signingEndpoint && (compatReasoning(spec, axes) || modelMatchesHost(spec, "deepseekFamily")),
 		escapeBuiltinToolNames: false,
 		injectClaudeCodeInstruction: true,
 		stripImageInput: false,
@@ -884,7 +898,7 @@ function resolveBedrockPolicy(spec: ModelSpec<"bedrock-converse-stream">, axes:
 		promptCacheMaximumCheckpoints: 0,
 	};
 	// Reasoning capability is a mechanism gate; adaptive-lineage duration is rule-owned.
-	compat.streamIdleTimeoutMs = spec.reasoning ? BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS : undefined;
+	compat.streamIdleTimeoutMs = compatReasoning(spec, axes) ? BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS : undefined;
 	applyWireAxes(compat, axes.wire, "bedrock-converse-stream");
 	applyCompatOverrides(compat, spec.compat);
 	return compat;
@@ -1047,6 +1061,18 @@ function readRuleThinking(axes: ResolvedAxes): RuleThinking {
 	return out;
 }
 
+/**
+ * Compat-time reasoning capability. `axes.reasoning` also promotes targets on
+ * any exact `thinking-efforts` rule (the cascade's thinking-axis gate), but
+ * compat may only be repaired where the provider contract opted in with
+ * `thinking-upgrade-neutral`; everywhere else a spec that reports no reasoning
+ * stays the authoritative capability surface.
+ */
+function compatReasoning<TApi extends Api>(spec: ModelSpec<TApi>, axes: ResolvedAxes): boolean {
+	if (spec.reasoning) return true;
+	return axes.reasoning && readRuleThinking(axes).upgradeNeutral === true;
+}
+
 /** Identity-derived `requiresEffort` default (mandatory-reasoning lineages). */
 function impliesMandatoryReasoning(facts: IdentityFacts, modelId: string): boolean {
 	if (facts.identity.thinkingVariant) return true;
@@ -1245,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/README.md

@@ -288,15 +288,17 @@ behavior {
         route "openai-completions" prefix="openai/" strip-prefix=#true
     }
     model-limits provider="github-copilot" { limits "gpt-5.6" context=272000 max-tokens=128000 }
+    exclude-discovery-modes "embedding" "moderation" provider="litellm"
     exclude-models provider="nanogpt" substring="embed" substring="tts"
     plan-requirement provider="openai-codex" { tier "pro" substring="-spark" }
+    retry-reset-timezone provider="zai" offset="+08:00"
     pricing-peer provider="google-antigravity" peers="google" "google-vertex" {
         alias "gemini-3-pro" peer-id="gemini-3-pro-preview"
     }
 }
 ```
 
-Matcher properties on `route` / `exclude-models` / `tier` nodes are `exact=` / `prefix=` / `substring=` / `glob=`, repeatable. `strip-prefix=#true` on a prefix route strips the matched prefix off the wire id. Values are copied verbatim from the TS constants they replaced; runtime accessors live in `src/compat/behavior.ts`.
+`exclude-discovery-modes` takes one or more exact, case-sensitive upstream mode strings plus `provider=`; discovery mappers preserve missing, malformed, and unknown modes unless the provider policy explicitly lists them. Matcher properties on `route` / `exclude-models` / `tier` nodes are `exact=` / `prefix=` / `substring=` / `glob=`, repeatable. `strip-prefix=#true` on a prefix route strips the matched prefix off the wire id. Values are copied verbatim from the TS constants they replaced; runtime accessors live in `src/compat/behavior.ts`.
 
 ## Auth grammar
 

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

@@ -84,7 +84,15 @@ class "deepseek" {
 	models "*v4.1-flash*" priority=10 {
 		strip-image-input #false
 	}
-	on "ollama-cloud" "nvidia" "deepseek" "fireworks" "nanogpt" "opencode-go" "openrouter" {
+	// V4.1 Flash is natively multimodal (vision encoder + projector, image-text
+	// pre-training) but its release id carries no `vision` token to key on.
+	// Same priority as the V4.1 Flash carve-out: the OpenCode Go provider rule
+	// declares the same value for its `deepseek-flash` lane and would otherwise
+	// tie at equal rank.
+	models "deepseek-flash" priority=10 {
+		strip-image-input #false
+	}
+	on "ollama-cloud" "nvidia" "deepseek" "fireworks" "nanogpt" "opencode-go" "openrouter" "litellm" "nous" {
 		stream-markup-healing-pattern "dsml"
 	}
 	thinking-loop-guard "deepseek"

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

@@ -1,6 +1,12 @@
 // Model-lineage compat for "kimi"; regenerated from the frozen census using class taxonomy selectors.
 
 class "kimi" {
+	// Kimi chat templates can revise bytes they have already streamed: a leaned-on
+	// thinking opener reclassifies visible text as reasoning, and native
+	// section/tool-call tokens are carved out of the visible channel mid-stream.
+	// Declared revision-possible so finished prose stays in the live viewport
+	// instead of retiring into native scrollback ahead of the turn.
+	stream-revision "possible"
 	// Replaces the K2.6 reasoning stream-idle baseline on OpenAI-compatible routes.
 	on "baseten" "cline-pass" "cloudflare-ai-gateway" "coreweave" "deepinfra" "firepass" "fireworks" \
 		"huggingface" "moonshot" "novita" "nvidia" "opencode-go" "opencode-zen" "openrouter" \

package/src/compat/rules/providers/alibaba-token-plan.kdl

@@ -114,10 +114,17 @@ provider "alibaba-token-plan" {
 	models "deepseek-v4-pro" {
 		thinking-format "qwen"
 	}
-	// residue: taxonomy ranks and exact globs do not isolate these models.
-	models "qwen3.8-max" {
-		thinking-default-level "xhigh"
-		thinking-efforts "low" "medium" "xhigh"
+	// Max Preview rides only Alibaba's binary enable_thinking toggle: it stays on
+	// the Qwen dialect and must not emit an unsupported reasoning_effort field.
+	models "qwen3.8-max-preview" {
+		thinking-efforts "low" "high" "xhigh"
+		thinking-requires-effort #true
+	}
+	// Max and Flash steer thinking depth through the OpenAI reasoning_effort
+	// control and replay reasoning_content across turns (preserve_thinking
+	// defaults on for both).
+	models "qwen3.8-max" "qwen3.8-flash" {
+		replay-reasoning-content #true
 		when-thinking {
 			extra-body {
 				enable_thinking #true
@@ -125,9 +132,10 @@ provider "alibaba-token-plan" {
 			thinking-format "openai"
 		}
 	}
-	// residue: taxonomy ranks and exact globs do not isolate these models.
-	models "qwen3.8-max-preview" {
-		thinking-efforts "low" "high" "xhigh"
-		thinking-requires-effort #true
+	// Max exposes a distinct low/medium/xhigh ladder; Flash retains its
+	// provider-authored minimal/low/medium/high ladder.
+	models "qwen3.8-max" {
+		thinking-default-level "xhigh"
+		thinking-efforts "low" "medium" "xhigh"
 	}
 }

package/src/compat/rules/providers/amazon-bedrock.kdl

@@ -3,7 +3,15 @@
 provider "amazon-bedrock" {
 	default-model "us.anthropic.claude-opus-4-8"
 
+	// The Converse assembler positions content blocks by wire index
+	// (`amazon-bedrock.ts`), so a block can land above text already rendered.
+	stream-revision "possible"
 	class "anthropic" {
+		family "fable" {
+			revision ">=5.1 <5.2" {
+				thinking-efforts "low" "medium" "high" "xhigh" "max"
+			}
+		}
 		family "opus" {
 			revision ">=4.6 <4.7" {
 				thinking-mode "anthropic-adaptive"
@@ -42,4 +50,26 @@ provider "amazon-bedrock" {
 	models "moonshot.kimi-k2-thinking" {
 		thinking-requires-effort #true
 	}
+	// The Qwen rows arrive with maxTokens copied from the upstream context
+	// window (262000 on a 262144 window), so a request that does not set an
+	// output budget of its own asks Bedrock for more than the model accepts
+	// and gets a 400 back ("you requested 262000 output tokens"). AWS
+	// publishes the real caps on the model cards — 8K for Qwen3-Next 80B A3B
+	// and Qwen3 VL 235B A22B, 16K for Qwen3 Coder Next — and the context
+	// windows already match, so only the output side needs patching (#12089).
+	models "qwen.qwen3-next-80b-a3b" {
+		limits-patch {
+			max-tokens 8000
+		}
+	}
+	models "qwen.qwen3-vl-235b-a22b" {
+		limits-patch {
+			max-tokens 8000
+		}
+	}
+	models "qwen.qwen3-coder-next" {
+		limits-patch {
+			max-tokens 16000
+		}
+	}
 }

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

@@ -19,4 +19,10 @@ provider "azure" {
 	models "gpt-5.1-codex-mini" {
 		thinking-efforts "medium" "high"
 	}
+	// Azure Chat Completions rejects Astra reasoning whenever function tools are
+	// present; the documented escape hatch is an explicit `none` effort.
+	models "gpt-6-astra*" {
+		disable-reasoning-with-tools #true
+		reasoning-disable-mode "none-effort"
+	}
 }

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

@@ -16,6 +16,16 @@ provider "cerebras" {
 		input-modalities "text" "image"
 	}
 	thinking-mode "effort"
+	// Cerebras accepts OpenAI `reasoning_effort`, not Qwen-native thinking
+	// fields such as `enable_thinking`.
+	class "qwen" {
+		thinking-format "openai"
+	}
+	// Qwen 3.8 accepts low/medium/high; `none` is its wire-only off value.
+	models "qwen-3.8-27b" {
+		thinking-efforts "low" "medium" "high"
+		reasoning-disable-mode "none-effort"
+	}
 	// residue: taxonomy ranks and exact globs do not isolate these models.
 	models "zai-glm-4.7" {
 		thinking-efforts "minimal" "low" "medium" "high" "xhigh"

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

@@ -1,10 +1,13 @@
 // Command Code Provider API deployment contract. Model capabilities and effort
 // ladders follow command-code@1.44.0: the thinking-efforts below reproduce the
 // bundle's 36-id effort registry 1:1 (verified against its effort map), plus
-// the 5 Muse Spark lineage ids whose ladder OMP's classes/meta.kdl carries.
-// Every other served id exposes no effort dial upstream (`modelSupports-
-// ReasoningEffort` is false for them in the CLI), so a missing ladder here
-// is a deliberate absence, not a gap.
+// the 5 Muse Spark lineage ids whose ladder OMP's classes/meta.kdl carries and
+// `deepseek/deepseek-v4.1-flash`, which postdates that bundle (see its rule).
+// Every id the 1.44.0 census serves without an effort dial keeps a missing
+// ladder here as a deliberate absence, not a gap (`modelSupportsReasoning-
+// Effort` is false for those ids in that bundle). Later bundles (1.53.0) hand
+// dials to a few further ids — MiniMaxAI/MiniMax-M3 and meta/muse-spark-1.3's
+// `max` — which stay out of this change.
 provider "commandcode" {
 	default-model "claude-sonnet-4-6"
 	env "COMMAND_CODE_API_KEY" "COMMANDCODE_API_KEY"
@@ -54,6 +57,19 @@ provider "commandcode" {
 		supports-reasoning-effort #true
 		thinking-efforts "low" "high" "max"
 	}
+	// `deepseek/deepseek-v4.1-flash` postdates command-code@1.44.0, so it is
+	// absent from that bundle's effort registry; command-code@1.53.0 lists it
+	// in the same low/high/max group as Kimi K3 and GLM-5.3, and the live docs
+	// model table carries the same scale plus image input.
+	models "deepseek/deepseek-v4.1-flash" {
+		supports-reasoning-effort #true
+		thinking-efforts "low" "high" "max"
+		// The class's `token="vision"` exemption misses this id (its name
+		// carries no `vision` token) even though the deployment serves it with
+		// image input, so the opt-out is explicit here.
+		strip-image-input #false
+		input-modalities "text" "image"
+	}
 	models "google/gemini-3.1-flash-lite" "google/gemini-3.5-flash" \
 		"google/gemini-3.5-flash-lite" "google/gemini-3.6-flash" "google/gemini-3.7-flash" \
 		"google/gemini-3.8-flash" "gpt-5.4-mini" "xai/grok-4.5" {

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

@@ -11,6 +11,15 @@ provider "cursor" {
 	class "anthropic" {
 		family "fable" {
 			requires-cursor-tool-schema-projection #true
+			// Cursor advertised Context window 300k (Max 1M recovered elsewhere).
+			context-window-floor 300000
+		}
+		family "opus" {
+			revision ">=5 <6" {
+				// Cursor advertised Claude Opus 5 Context window 300k; Max 1M
+				// stays recovered on labeled/maxMode rows via Math.max.
+				context-window-floor 300000
+			}
 		}
 	}
 	// GetUsableModels advertises no input modalities or context windows.
@@ -21,11 +30,34 @@ provider "cursor" {
 			input-modalities "text" "image"
 			context-window-floor 1000000
 		}
+		family "k2.7-code" {
+			// Cursor advertised Kimi K2.7 Code Context window 262k.
+			context-window-floor 262000
+		}
+	}
+	class "xai" {
+		family "grok" {
+			revision ">=4.5 <4.7" {
+				// Cursor advertised Grok 4.5/4.6 Context window 256k (product
+				// cap; not xAI native 500k). Max context is unmarked.
+				context-window-floor 256000
+			}
+		}
+	}
+	class "openai" {
+		revision ">=5.6 <5.7" {
+			// Cursor advertised GPT-5.6 Sol/Terra/Luna Context window 272k;
+			// raises unlabeled -fast variants from the 200k default.
+			context-window-floor 272000
+		}
 	}
 	models "k3" "*/k3" {
 		input-modalities "text" "image"
 		context-window-floor 1000000
 	}
+	models "default" {
+		context-window-floor 256000
+	}
 	// Cursor-only families verified to accept selectedImages even though the
 	// roster carries no modality metadata.
 	models "cursor-grok-4" "cursor-grok-4.*" "cursor-grok-4-*" "cursor-grok-4:*" "cursor-grok-4_*" {

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

@@ -17,8 +17,8 @@ provider "deepseek" {
 	// First-party peak USD / 1M tokens; all other UTC hours receive 50% off.
 	// Source: https://api-docs.deepseek.com/quick_start/pricing (2026-09-10).
 	// residue: the pricing page's Flash-priced names, not a taxonomy family: the
-	// bare alias carries no family, and the retired `v4-flash`/`-vision-exp` ids
-	// are still accepted and billed at the Flash card.
+	// retired `v4-flash`/`-vision-exp` ids are still accepted and billed at the
+	// Flash card.
 	models "deepseek-flash" "deepseek-v4-flash" "deepseek-v4-flash-vision-exp" {
 		clamp-output-to-model-max #true
 		time-based-cost {
@@ -43,9 +43,9 @@ provider "deepseek" {
 			cache-write 0
 		}
 	}
-	// residue: upstream discovery has not seeded the bare alias's limits; the
-	// pricing page documents this SKU (DeepSeek-V4.1-Flash) as 1M context / 384K
-	// output, and without them the agent cannot enforce its context budget.
+	// residue: the pricing page documents this SKU (DeepSeek-V4.1-Flash) as 1M
+	// context / 384K output; pinned as a reviewed correction so the documented
+	// window survives an upstream metadata gap.
 	models "deepseek-flash" {
 		limits-patch {
 			context-window 1000000