@oh-my-pi/pi-catalog 18.1.2 → 18.1.4

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [18.1.4] - 2026-09-02
+
+### Changed
+
+- Enabled Cursor tool schema projection for supported models
+
+### Fixed
+
+- Antigravity and Gemini CLI now collapse every Gemini Flash generation from 3.6 on (`gemini-3.8-flash-low/-medium/-high` and the `-tiered` alias, and future revisions) into one routed `gemini-<rev>-flash` entry via a revision-templated `variant-family`, instead of surfacing raw per-level ids until a per-revision rule lands.
+
+## [18.1.3] - 2026-09-02
+
+### Added
+
+- Added support for Claude Fable 5.1
+
+### Changed
+
+- Updated pricing and context limits for various Claude models
+
+### Fixed
+
+- Claude Sonnet 5 no longer advertises unsupported mid-conversation system messages.
+- Custom GLM 5.2 models on `alibaba-coding-plan` (and other blanket-GLM hosts) no longer crash startup with `AmbiguousOverlapError` ([#10553](https://github.com/can1357/oh-my-pi/issues/10553)).
+- Gemini 3.7 Flash no longer offers the `minimal` thinking effort on direct google-level hosts (`google`, `google-vertex`, `opencode-zen`), which reject `thinkingLevel: MINIMAL` with a 400; budget and reasoning-effort resellers keep the tier ([#10543](https://github.com/can1357/oh-my-pi/issues/10543)).
+- Fixed Alibaba Token Plan discovery for `qwen3.8-flash` to include its context limits, reasoning support, and image input.
+- Z.AI GLM-5.3-Flash now uses the native API instead of failing through the unsupported Anthropic-compatible route ([#10539](https://github.com/can1357/oh-my-pi/issues/10539)).
+
 ## [18.1.2] - 2026-09-01
 
 ### Added

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

@@ -1,5 +1,6 @@
 import { Effort } from "../effort.js";
 import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "../types.js";
+import { type RevisionTerm } from "./revision.js";
 /**
  * Structural bound for collapse inputs: both raw `ModelSpec`s and built
  * `Model`s qualify. (`Model.compat` is the resolved record, not the sparse
@@ -65,8 +66,27 @@ export interface EffortVariantFamily {
     /** Retired/recycled selector ids that alias to this family without being members. */
     extraAliases?: readonly string[];
 }
+/**
+ * A reviewed family whose ids carry {@link REVISION_PLACEHOLDER}: one
+ * `gemini-{rev}-flash` entry stands for every Flash generation the provider
+ * serves with the same sibling layout. Concrete families with the same
+ * instantiated id take precedence.
+ */
+export interface VariantFamilyTemplate {
+    /** Family with placeholders still in every id and the display name. */
+    family: EffortVariantFamily;
+    /** Revisions the template applies to; unbounded when absent. */
+    revision?: readonly RevisionTerm[];
+    /**
+     * Matches the logical id, any member, or any extra alias (case-insensitive);
+     * one alternative per id, each capturing the revision.
+     */
+    pattern: RegExp;
+}
 export interface VariantCollapseTable {
     families: readonly EffortVariantFamily[];
+    /** Revision-templated families, instantiated against live ids. */
+    templates?: readonly VariantFamilyTemplate[];
     /**
      * Provider-scoped selector aliases: short native-CLI names and dotted
      * upstream spellings → logical model id. Unlike family members and

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

@@ -80,6 +80,13 @@ export interface CompiledEffortFamily {
 }
 /** Per-effort routing tier keys (`"off"` = thinking disabled). */
 export type VariantTier = Effort | "off";
+/**
+ * Revision placeholder in a templated `variant-family` (`gemini-{rev}-flash`).
+ * A family whose id carries it is instantiated once per live revision that
+ * discovery advertises, so new generations of a lineage collapse without a
+ * new reviewed entry.
+ */
+export declare const REVISION_PLACEHOLDER = "{rev}";
 /**
  * One reviewed provider-scoped variant family: a logical model whose provider
  * serves per-effort/thinking sibling wire ids, with explicit routing, ladder,
@@ -89,6 +96,11 @@ export interface CompiledVariantFamily {
     provider: string;
     id: string;
     name: string;
+    /**
+     * Revision constraint (`">=3.6"`) gating instantiation of a
+     * {@link REVISION_PLACEHOLDER} template; absent on concrete families.
+     */
+    revision?: string;
     /** Member wire ids in priority order. */
     members: string[];
     /** Preferred default wire id when live. */

package/dist/types/provider-models/descriptors.d.ts

@@ -502,7 +502,7 @@ export declare const CATALOG_PROVIDERS: readonly [{
     readonly id: "zai";
     readonly defaultModel: "glm-5.3";
     readonly envVars: readonly ["ZAI_API_KEY"];
-    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("../index.js").ModelManagerOptions<"anthropic-messages", unknown>;
+    readonly createModelManagerOptions: (config: ModelManagerConfig) => import("../index.js").ModelManagerOptions<"anthropic-messages" | "openai-completions", unknown>;
     readonly catalogDiscovery: {
         readonly label: "zAI";
     };

package/dist/types/provider-models/openai-compat.d.ts

@@ -673,6 +673,11 @@ export interface ModelsDevProviderDescriptor {
 }
 /** Generic mapper that converts models.dev data using provider descriptors. */
 export declare function mapModelsDevToModels(data: Record<string, unknown>, descriptors: readonly ModelsDevProviderDescriptor[]): ModelSpec<Api>[];
+/** Resolves the transport and endpoint for one Z.AI model catalog entry. */
+export declare function resolveZaiApi(modelId: string): {
+    api: "anthropic-messages" | "openai-completions";
+    baseUrl: string;
+};
 /** All provider descriptors for models.dev data mapping in generate-models.ts. */
 export declare const MODELS_DEV_PROVIDER_DESCRIPTORS: readonly ModelsDevProviderDescriptor[];
 /** Providers whose bundled catalog can receive additive models.dev updates at runtime. */

package/dist/types/provider-models/special.d.ts

@@ -70,4 +70,5 @@ export declare const DEVIN_STATIC_MODELS: readonly ModelSpec<"devin-agent">[];
 export declare function devinModelManagerOptions(config?: DevinModelManagerConfig): ModelManagerOptions<"devin-agent">;
 export interface ZaiModelManagerConfig {
 }
-export declare function zaiModelManagerOptions(_config?: ZaiModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
+/** Creates model-manager options for Z.AI's mixed native and Anthropic transports. */
+export declare function zaiModelManagerOptions(_config?: ZaiModelManagerConfig): ModelManagerOptions<"anthropic-messages" | "openai-completions">;

package/dist/types/types.d.ts

@@ -879,6 +879,8 @@ export interface Model<TApi extends Api = Api> {
      * inferring it from the transport API.
      */
     requiresGlyphTokenization?: boolean;
+    /** Whether this model requires Cursor's tool-schema combiner projection. */
+    requiresCursorToolSchemaProjection?: boolean;
     /**
      * Model id to send on the wire when it differs from `id`. Used by catalog
      * variants that present one upstream model under several local entries —
@@ -1033,7 +1035,7 @@ export interface Model<TApi extends Api = Api> {
  * vocabulary of `buildModel`. Identical to `Model` except `compat` carries the
  * sparse override shape and nothing is resolved yet.
  */
-export interface ModelSpec<TApi extends Api = Api> extends Omit<Model<TApi>, "compat" | "identity" | "compatConfig" | "requiresGlyphTokenization" | "supportsComputerUseConfig"> {
+export interface ModelSpec<TApi extends Api = Api> extends Omit<Model<TApi>, "compat" | "identity" | "compatConfig" | "requiresGlyphTokenization" | "requiresCursorToolSchemaProjection" | "supportsComputerUseConfig"> {
     /** Sparse compatibility overrides; resolved into `Model.compat` by `buildModel`. */
     compat?: CompatConfigOf<TApi>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.1.2",
+	"version": "18.1.4",
 	"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.1.2",
-		"@oh-my-pi/pi-utils": "18.1.2"
+		"@oh-my-pi/omptype": "18.1.4",
+		"@oh-my-pi/pi-utils": "18.1.4"
 	},
 	"devDependencies": {
 		"@bgotink/kdl": "0.4.0",
-		"@oh-my-pi/pi-ai": "18.1.2",
+		"@oh-my-pi/pi-ai": "18.1.4",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -32,7 +32,8 @@ function isInputModalities(value: unknown): value is ("text" | "image")[] {
  * Applies resolved catalog-data axes onto the model: reviewed metadata
  * corrections (`cost-patch`, `limits-patch`, `long-context-cost`,
  * `context-window-floor`) overwrite upstream values; selection metadata
- * (`priority`, `apply-patch-tool-type`, `service-tier-cost`) is rule-owned;
+ * (`priority`, `apply-patch-tool-type`, `service-tier-cost`,
+ * `requires-cursor-tool-schema-projection`) is rule-owned;
  * `context-promotion-target` fills only when the spec left it unset.
  */
 function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog: Record<string, unknown>): void {
@@ -51,6 +52,12 @@ function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog:
 	if (applyPatchToolType === "freeform" || applyPatchToolType === "function") {
 		model.applyPatchToolType = applyPatchToolType;
 	}
+	const requiresCursorToolSchemaProjection = catalog.requiresCursorToolSchemaProjection;
+	if (requiresCursorToolSchemaProjection === true) {
+		model.requiresCursorToolSchemaProjection = true;
+	} else {
+		delete model.requiresCursorToolSchemaProjection;
+	}
 	const contextPromotionTarget = catalog.contextPromotionTarget;
 	if (typeof contextPromotionTarget === "string" && model.contextPromotionTarget === undefined) {
 		model.contextPromotionTarget = contextPromotionTarget;

package/src/compat/axes.ts

@@ -262,6 +262,11 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"limits-patch": { key: "limitsPatch", set: "catalog", shape: "object" },
 	"long-context-cost": { key: "longContext", set: "catalog", shape: "object" },
 	"long-usage-limit-fallback": { key: "longUsageLimitFallback", set: "catalog", shape: "scalar" },
+	"requires-cursor-tool-schema-projection": {
+		key: "requiresCursorToolSchemaProjection",
+		set: "catalog",
+		shape: "scalar",
+	},
 	priority: { key: "priority", set: "catalog", shape: "scalar" },
 	"service-tier-cost": { key: "serviceTierCost", set: "catalog", shape: "object" },
 };

package/src/compat/collapse.ts

@@ -13,7 +13,9 @@
  * Families come from two sources:
  * - Reviewed `variant-family` nodes in `compat/rules/taxonomy/_collapse.kdl`
  *   (compiled into `rules.json`) for providers whose routing needs curation
- *   (Antigravity tier triplets, single-member renames, recycled ids).
+ *   (Antigravity tier triplets, single-member renames, recycled ids). A
+ *   family whose ids carry `{rev}` is a template, instantiated for every
+ *   revision the input advertises (`gemini-{rev}-flash` → `gemini-3.8-flash`).
  * - `deriveThinkingPairFamilies`: the global automatic rule — any live
  *   `X` + `X-thinking` pair (trailing or infix token) collapses into `X`,
  *   routing thinking-enabled requests to `X-thinking`. Gated on identical
@@ -36,8 +38,9 @@ import { buildModel } from "../build";
 import { Effort, THINKING_EFFORTS } from "../effort";
 import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "../types";
 import { resolveModelPolicy } from "./resolve";
+import { parseRevision, parseRevisionConstraint, type RevisionTerm, revisionSatisfies } from "./revision";
 import { collapseVariantId, collapseVocabulary, stripThinkingVariantSuffix } from "./taxonomy";
-import type { CompiledVariantFamily } from "./types";
+import { type CompiledVariantFamily, REVISION_PLACEHOLDER } from "./types";
 
 const VARIANT_ROUTING_KEYS: readonly (Effort | "off")[] = ["off", ...THINKING_EFFORTS];
 const DEFAULT_PAIR_EFFORTS: readonly Effort[] = [Effort.Minimal, Effort.Low, Effort.Medium, Effort.High];
@@ -107,8 +110,28 @@ export interface EffortVariantFamily {
 	extraAliases?: readonly string[];
 }
 
+/**
+ * A reviewed family whose ids carry {@link REVISION_PLACEHOLDER}: one
+ * `gemini-{rev}-flash` entry stands for every Flash generation the provider
+ * serves with the same sibling layout. Concrete families with the same
+ * instantiated id take precedence.
+ */
+export interface VariantFamilyTemplate {
+	/** Family with placeholders still in every id and the display name. */
+	family: EffortVariantFamily;
+	/** Revisions the template applies to; unbounded when absent. */
+	revision?: readonly RevisionTerm[];
+	/**
+	 * Matches the logical id, any member, or any extra alias (case-insensitive);
+	 * one alternative per id, each capturing the revision.
+	 */
+	pattern: RegExp;
+}
+
 export interface VariantCollapseTable {
 	families: readonly EffortVariantFamily[];
+	/** Revision-templated families, instantiated against live ids. */
+	templates?: readonly VariantFamilyTemplate[];
 	/**
 	 * Provider-scoped selector aliases: short native-CLI names and dotted
 	 * upstream spellings → logical model id. Unlike family members and
@@ -209,13 +232,104 @@ function compiledFamily(compiled: CompiledVariantFamily): EffortVariantFamily {
 	return family;
 }
 
+const REVISION_CAPTURE = String.raw`(\d+(?:\.\d+){0,2})`;
+
+/** One compiled `{rev}` family → runtime template with its id matcher. */
+function compiledTemplate(compiled: CompiledVariantFamily): VariantFamilyTemplate {
+	const family = compiledFamily(compiled);
+	const alternatives = [family.id, ...family.members, ...(family.extraAliases ?? [])].map(id =>
+		id
+			.split(REVISION_PLACEHOLDER)
+			.map(part => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+			.join(REVISION_CAPTURE),
+	);
+	const template: VariantFamilyTemplate = {
+		family,
+		pattern: new RegExp(`^(?:${alternatives.join("|")})$`, "i"),
+	};
+	if (compiled.revision !== undefined) {
+		const terms = parseRevisionConstraint(compiled.revision);
+		if (terms !== undefined) template.revision = terms;
+	}
+	return template;
+}
+
+/** Substitute the placeholder throughout one templated family. */
+function instantiateTemplate(template: VariantFamilyTemplate, rev: string): EffortVariantFamily | undefined {
+	if (template.revision !== undefined) {
+		const parsed = parseRevision(rev);
+		if (parsed === undefined || !revisionSatisfies(parsed, template.revision)) return undefined;
+	}
+	const fill = (id: string): string => id.replaceAll(REVISION_PLACEHOLDER, rev);
+	const source = template.family;
+	const routing: Partial<Record<Effort | "off", string>> = {};
+	for (const effort of VARIANT_ROUTING_KEYS) {
+		const target = source.routing[effort];
+		if (target !== undefined) routing[effort] = fill(target);
+	}
+	const family: EffortVariantFamily = {
+		...source,
+		id: fill(source.id),
+		name: fill(source.name),
+		members: source.members.map(fill),
+		routing,
+	};
+	if (source.defaultMember !== undefined) family.defaultMember = fill(source.defaultMember);
+	if (source.retiredMembers !== undefined) family.retiredMembers = source.retiredMembers.map(fill);
+	if (source.extraAliases !== undefined) family.extraAliases = source.extraAliases.map(fill);
+	return family;
+}
+
+/**
+ * The family a template yields for `id` (logical id, member, or alias), or
+ * undefined when no template matches or the revision is out of range.
+ */
+function templateFamilyFor(templates: readonly VariantFamilyTemplate[], id: string): EffortVariantFamily | undefined {
+	for (const template of templates) {
+		const match = template.pattern.exec(id);
+		if (match === null) continue;
+		let rev: string | undefined;
+		for (let group = 1; group < match.length && rev === undefined; group++) rev = match[group];
+		if (rev === undefined) continue;
+		const family = instantiateTemplate(template, rev);
+		if (family !== undefined) return family;
+	}
+	return undefined;
+}
+
+/**
+ * Concrete families for every revision present in `ids`, one per
+ * instantiated id, skipping ids a concrete family in `table` already owns.
+ */
+function instantiateTemplates(table: VariantCollapseTable, ids: Iterable<string>): EffortVariantFamily[] {
+	const templates = table.templates;
+	if (templates === undefined || templates.length === 0) return [];
+	const seen = new Set<string>();
+	for (const family of table.families) seen.add(family.id);
+	const out: EffortVariantFamily[] = [];
+	for (const id of ids) {
+		const family = templateFamilyFor(templates, id);
+		if (family === undefined || seen.has(family.id)) continue;
+		seen.add(family.id);
+		out.push(family);
+	}
+	return out;
+}
+
 /** Provider id → reviewed collapse table, built once from the compiled vocabulary. */
 function buildCompiledTables(): Readonly<Record<string, VariantCollapseTable>> {
 	const { variantFamilies, providerAliases } = collapseVocabulary();
-	const tables: Record<string, { families: EffortVariantFamily[]; providerAliases?: Record<string, string> }> = {};
+	const tables: Record<
+		string,
+		{ families: EffortVariantFamily[]; templates?: VariantFamilyTemplate[]; providerAliases?: Record<string, string> }
+	> = {};
 	for (const compiled of variantFamilies) {
-		tables[compiled.provider] ??= { families: [] };
-		tables[compiled.provider].families.push(compiledFamily(compiled));
+		const table = (tables[compiled.provider] ??= { families: [] });
+		if (compiled.id.includes(REVISION_PLACEHOLDER)) {
+			(table.templates ??= []).push(compiledTemplate(compiled));
+		} else {
+			table.families.push(compiledFamily(compiled));
+		}
 	}
 	for (const [provider, aliases] of Object.entries(providerAliases)) {
 		tables[provider] ??= { families: [] };
@@ -407,16 +521,14 @@ export function deriveThinkingPairFamilies<TSpec extends VariantSpecLike>(
 		if (baseId === undefined || baseId === spec.id) continue;
 		const base = byId.get(baseId);
 		if (!base) continue;
-		if (claimed) {
-			const forward = claimed.forward;
-			if (
-				forward.has(spec.id.toLowerCase()) ||
-				forward.has(baseId.toLowerCase()) ||
-				claimed.familyIds.has(spec.id) ||
-				claimed.familyIds.has(baseId)
-			) {
-				continue;
-			}
+		if (
+			claimed &&
+			(claimed.resolve(spec.id) !== undefined ||
+				claimed.resolve(baseId) !== undefined ||
+				claimed.isFamily(spec.id) ||
+				claimed.isFamily(baseId))
+		) {
+			continue;
 		}
 		if (spec.api !== base.api) continue;
 		const specPriced = spec.cost.input !== 0 || spec.cost.output !== 0;
@@ -483,7 +595,7 @@ export function isCollapsedVariantSpec(spec: VariantSpecLike): boolean {
 		return false;
 	}
 	const table = reviewedCollapseTable(spec.provider);
-	return table !== undefined && getAliasIndex(table).familyIds.has(spec.id);
+	return table !== undefined && getAliasIndex(table).isFamily(spec.id);
 }
 
 /**
@@ -641,7 +753,9 @@ function collapseWithTable<TSpec extends VariantSpecLike>(
 	/** spec ids that belong to a touched family (members + logical id). */
 	const familyIdBySpecId = new Map<string, string>();
 
-	for (const family of table.families) {
+	const instantiated = instantiateTemplates(table, byId.keys());
+	const families = instantiated.length === 0 ? table.families : [...table.families, ...instantiated];
+	for (const family of families) {
 		const retired =
 			family.retiredMembers !== undefined && family.retiredMembers.length > 0
 				? new Set(family.retiredMembers)
@@ -917,39 +1031,84 @@ function projectModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi>
 	return { ...spec, compat: compatConfig };
 }
 
+/**
+ * Alias index over a collapse table (or the live families observed at
+ * runtime). Templated families are materialized on first lookup of any id
+ * they match, so a revision discovery has never advertised still resolves.
+ */
 class VariantAliasIndex {
 	/** lowercased retired id → replacement model id. */
-	readonly forward = new Map<string, string>();
+	readonly #forward = new Map<string, string>();
 	/**
 	 * lowercased provider-scoped alias → replacement model id. Kept apart from
-	 * `forward` so bare-id and reverse lookups never see it.
+	 * `#forward` so bare-id and reverse lookups never see it.
 	 */
 	readonly providerScoped = new Map<string, string>();
 	/** replacement model id → retired ids that resolve to it. */
-	readonly reverse = new Map<string, string[]>();
+	readonly #reverse = new Map<string, string[]>();
 	/** Collapsed logical ids declared by the table or observed at runtime. */
-	readonly familyIds = new Set<string>();
-}
+	readonly #familyIds = new Set<string>();
+	readonly #templates: readonly VariantFamilyTemplate[];
 
-const dynamicAliasIndexes = new Map<string, VariantAliasIndex>();
-const kAliasIndex = Symbol("compat-collapse.aliasIndex");
+	constructor(templates: readonly VariantFamilyTemplate[] = []) {
+		this.#templates = templates;
+	}
 
-function createAliasIndex(): VariantAliasIndex {
-	return new VariantAliasIndex();
-}
+	/** Register `from` → `to`; false when `from` is already claimed. */
+	add(from: string, to: string): boolean {
+		if (from === to || this.#forward.has(from.toLowerCase())) return false;
+		this.#forward.set(from.toLowerCase(), to);
+		const sources = this.#reverse.get(to);
+		if (sources) {
+			sources.push(from);
+		} else {
+			this.#reverse.set(to, [from]);
+		}
+		return true;
+	}
 
-function addVariantAlias(index: VariantAliasIndex, from: string, to: string): boolean {
-	if (from === to || index.forward.has(from.toLowerCase())) return false;
-	index.forward.set(from.toLowerCase(), to);
-	const sources = index.reverse.get(to);
-	if (sources) {
-		sources.push(from);
-	} else {
-		index.reverse.set(to, [from]);
+	/** Register a family: its logical id plus every member and extra alias. */
+	addFamily(family: EffortVariantFamily): void {
+		this.#familyIds.add(family.id);
+		for (const member of family.members) this.add(member, family.id);
+		for (const alias of family.extraAliases ?? []) this.add(alias, family.id);
+	}
+
+	markFamily(id: string): void {
+		this.#familyIds.add(id);
+	}
+
+	/** Replacement model id for a retired/member id (case-insensitive). */
+	resolve(id: string): string | undefined {
+		const lower = id.toLowerCase();
+		this.#learn(lower);
+		return this.#forward.get(lower);
+	}
+
+	/** Whether `id` is a collapsed logical id of this index. */
+	isFamily(id: string): boolean {
+		this.#learn(id);
+		return this.#familyIds.has(id);
+	}
+
+	/** Retired ids that resolve to logical `id`. */
+	sourcesOf(id: string): readonly string[] | undefined {
+		this.#learn(id);
+		return this.#reverse.get(id);
+	}
+
+	/** Materialize the template family that owns `id`, once. */
+	#learn(id: string): void {
+		if (this.#templates.length === 0) return;
+		const family = templateFamilyFor(this.#templates, id);
+		if (family === undefined || this.#familyIds.has(family.id)) return;
+		this.addFamily(family);
 	}
-	return true;
 }
 
+const dynamicAliasIndexes = new Map<string, VariantAliasIndex>();
+const kAliasIndex = Symbol("compat-collapse.aliasIndex");
+
 /**
  * Persist aliases embedded in collapsed routing so generated catalog rows and
  * newly discovered families expose the same selector migrations as reviewed tables.
@@ -964,14 +1123,14 @@ function registerCollapsedVariantAliases(provider: Provider, specs: readonly Var
 		for (const effort of VARIANT_ROUTING_KEYS) {
 			const source = routing[effort];
 			if (!source || source === spec.id) continue;
-			index ??= createAliasIndex();
-			registered = addVariantAlias(index, source, spec.id) || registered;
+			index ??= new VariantAliasIndex();
+			registered = index.add(source, spec.id) || registered;
 		}
 		if (spec.requestModelId && spec.requestModelId !== spec.id) {
-			index ??= createAliasIndex();
-			registered = addVariantAlias(index, spec.requestModelId, spec.id) || registered;
+			index ??= new VariantAliasIndex();
+			registered = index.add(spec.requestModelId, spec.id) || registered;
 		}
-		if (registered) index?.familyIds.add(spec.id);
+		if (registered) index?.markFamily(spec.id);
 	}
 	if (index) dynamicAliasIndexes.set(providerId, index);
 }
@@ -980,20 +1139,16 @@ function resolveRegisteredVariantAlias(provider: Provider, normalizedModelId: st
 	const providerId = provider.toLowerCase();
 	const table = reviewedCollapseTable(provider) ?? reviewedCollapseTable(providerId);
 	return (
-		(table ? getAliasIndex(table).forward.get(normalizedModelId) : undefined) ??
-		dynamicAliasIndexes.get(providerId)?.forward.get(normalizedModelId)
+		(table ? getAliasIndex(table).resolve(normalizedModelId) : undefined) ??
+		dynamicAliasIndexes.get(providerId)?.resolve(normalizedModelId)
 	);
 }
 
 function getAliasIndex(table: VariantCollapseTable): VariantAliasIndex {
 	const cached: unknown = Reflect.get(table, kAliasIndex);
 	if (cached instanceof VariantAliasIndex) return cached;
-	const index = createAliasIndex();
-	for (const family of table.families) {
-		index.familyIds.add(family.id);
-		for (const member of family.members) addVariantAlias(index, member, family.id);
-		for (const alias of family.extraAliases ?? []) addVariantAlias(index, alias, family.id);
-	}
+	const index = new VariantAliasIndex(table.templates);
+	for (const family of table.families) index.addFamily(family);
 	for (const alias in table.providerAliases) {
 		const target = table.providerAliases[alias];
 		if (target !== undefined && alias !== target) index.providerScoped.set(alias.toLowerCase(), target);
@@ -1057,8 +1212,8 @@ export function resolveBareVariantSelector(modelId: string): BareVariantAliasHit
 export function getVariantAliasSources(provider: Provider, modelId: string): readonly string[] {
 	const providerId = provider.toLowerCase();
 	const table = reviewedCollapseTable(provider) ?? reviewedCollapseTable(providerId);
-	const staticSources = table ? getAliasIndex(table).reverse.get(modelId) : undefined;
-	const dynamicSources = dynamicAliasIndexes.get(providerId)?.reverse.get(modelId);
+	const staticSources = table ? getAliasIndex(table).sourcesOf(modelId) : undefined;
+	const dynamicSources = dynamicAliasIndexes.get(providerId)?.sourcesOf(modelId);
 	if (!staticSources) return dynamicSources ?? [];
 	if (!dynamicSources) return staticSources;
 	return [...new Set([...staticSources, ...dynamicSources])];

package/src/compat/resolve.ts

@@ -846,7 +846,7 @@ function resolveAnthropicPolicy(
 		allowAnthropicHeaderOverrides: false,
 		supportsEagerToolInputStreaming: official,
 		supportsLongCacheRetention: official,
-		supportsMidConversationSystem: official && facts.anthropicAdaptiveGenAtLeast("4.8"),
+		supportsMidConversationSystem: official && !facts.family("sonnet") && facts.anthropicAdaptiveGenAtLeast("4.8"),
 		supportsTurnScopedSystem: false,
 		supportsMidConversationToolChanges: false,
 		supportsPerMessageEffort: false,

package/src/compat/rules/README.md

@@ -116,13 +116,14 @@ collapse {
     effort-suffix "-minimal" tier="minimal"
     effort-suffix "-max" tier="max" except-bare-prefix="qwen"
     effort-lane-suffix "-fast" "cursor" bare-prefix="cursor-grok"
-    effort-family "google-antigravity" "gemini-3.7-flash" "gemini-3.7-flash-tiered"
+    effort-family "cursor" "gpt-5.6-luna"
     routing-variant-suffix "-wm" "openai-codex" "openai-codex-device"
     variant-family "devin" "claude-opus-5" name="Claude Opus 5" { /* reviewed routing */ }
+    variant-family "google-antigravity" "gemini-{rev}-flash" name="Gemini {rev} Flash" revision=">=3.6" { /* per-revision template */ }
     provider-alias "devin" "opus" "claude-opus-5"
 }
 ```
-`variant-family` declares one reviewed provider-scoped collapsed family: positional provider and logical id, `name=` display name, and a body of `members "a" "b" …` (wire ids in priority order), `route "<tier>" "<wire-id>"` per effort tier (`off` included), and optional `mode`, `efforts`, `default-level`, `default-member`, `retired-members`, `effort-budget "<tier>" <n>`, `requires-effort`, `suppress-when-off`, `no-thinking`, `preserve-absent-effort-routes`, and `extra-aliases`. `provider-alias` maps one provider-scoped selector spelling onto a logical id without making it a family member.
+`variant-family` declares one reviewed provider-scoped collapsed family: positional provider and logical id, `name=` display name, and a body of `members "a" "b" …` (wire ids in priority order), `route "<tier>" "<wire-id>"` per effort tier (`off` included), and optional `mode`, `efforts`, `default-level`, `default-member`, `retired-members`, `effort-budget "<tier>" <n>`, `requires-effort`, `suppress-when-off`, `no-thinking`, `preserve-absent-effort-routes`, and `extra-aliases`. A `{rev}` placeholder in the logical id makes the node a **template**: it is instantiated once per revision found in live ids (`gemini-{rev}-flash` matches `gemini-3.8-flash-low` → family `gemini-3.8-flash`), every wire id in the body and the `name=` carry the same placeholder, and an optional `revision=` constraint (`">=3.6"`) bounds the generations it applies to. A concrete family with the same instantiated id wins over the template. `provider-alias` maps one provider-scoped selector spelling onto a logical id without making it a family member.
 
 `thinking-suffix` accepts one non-empty suffix and no properties. `pair-token` declares bounded (possibly infix) tokens naming the thinking sibling of a live bare twin (`sonar-reasoning-pro` beside `sonar-pro`); it drives thinking-pair derivation only — never identity suffix collapse — and negated `no-`/`non-` forms never match. `effort-suffix` additionally requires `tier` with one of the effort values above, and may have `except-bare-prefix`. `routing-variant-suffix` takes one non-empty suffix followed by one or more provider IDs: a wire identifier carrying the suffix on one of those providers is a **routing variant** of its plain identifier — discovery derives base-model metadata from the plain bundled SKU while keeping the suffixed wire identifier for requests; routing variants never participate in effort collapse. `effort-lane-suffix` takes one non-empty lane suffix followed by one or more provider IDs, plus an optional `bare-prefix` gate: on a declared provider, an identifier ending in the lane suffix collapses the effort suffix wedged before the lane token while keeping the lane on the logical id. `effort-family` takes a provider, the canonical logical id, and zero or more exact aliases that fold onto it.
 

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

@@ -66,17 +66,32 @@ class "gemini" {
 			}
 		}
 	}
+	// Gemini 3.7 Flash is the one Flash revision whose native thinkingLevel does
+	// not accept `minimal` (400 THINKING_LEVEL_MINIMAL). Only the direct
+	// google-level transports emit `thinkingLevel` on the wire, so the tier is
+	// dropped there; budget (anthropic-messages) and reasoning_effort resellers
+	// never send the rejected value and keep the four-tier ladder. The collapsed
+	// google-antigravity / google-gemini-cli variants remap minimal -> LOW and
+	// carry their own explicit ladder, so they are unaffected.
+	// https://ai.google.dev/gemini-api/docs/generate-content/thinking#thinking-levels
+	on "google" "google-vertex" "opencode-zen" {
+		family "flash" {
+			revision ">=3.7 <3.8" {
+				thinking-efforts "low" "medium" "high"
+			}
+		}
+	}
 
-	// Gemini 3 tool calls require the sentinel signature on unsigned replay.
 	revision ">=3" {
 		// Replaces the Google multimodal function-response baseline.
 		multimodal-function-response #true
-		requires-skip-thought-signature #true
 		// Replaces the Gemini 3+ mandatory-reasoning fallback.
 		thinking-requires-effort #true
 	}
+	// Only public-Gemini-compatible transports accept the bypass sentinel for unsigned calls.
 	on "google" "opencode-zen" {
 		revision ">=3" {
+			requires-skip-thought-signature #true
 			supports-function-part-id #true
 		}
 	}

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

@@ -10,7 +10,10 @@ class "glm" {
 	// GLM-5.2 exposes the default lower tiers plus a genuine max on generic
 	// OpenAI-compatible hosts; the zai-dialect and Anthropic-route hosts
 	// (Z.ai, Zhipu, Umans, Ollama Cloud, Baseten) serve only high/max.
-	revision ">=5.2 <5.3" {
+	// priority breaks the intentional overlap with provider-level blanket GLM
+	// ladders authored for the pre-5.2 census (e.g. alibaba-coding-plan.kdl),
+	// so the 5.2 lineage ladder wins on generic hosts that lack a 5.2 residue.
+	revision ">=5.2 <5.3" priority=10 {
 		thinking-efforts "minimal" "low" "medium" "high" "max"
 	}
 	on "zai" "zhipu-coding-plan" {