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

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [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

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/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "18.1.3",
+	"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.3",
-		"@oh-my-pi/pi-utils": "18.1.3"
+		"@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.3",
+		"@oh-my-pi/pi-ai": "18.1.4",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

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/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/providers/google-antigravity.kdl

@@ -18,7 +18,7 @@ provider "google-antigravity" {
 				thinking-mode "budget"
 				thinking-suppress-when-off #true
 			}
-			revision ">=3.6 <3.8" {
+			revision ">=3.6" {
 				thinking-mode "google-level"
 				thinking-requires-effort #true
 			}

package/src/compat/rules/taxonomy/_collapse.kdl

@@ -24,11 +24,6 @@ collapse {
 	effort-family "cursor" "gpt-5.6-luna"
 	effort-family "cursor" "gpt-5.6-sol"
 	effort-family "cursor" "gpt-5.6-terra"
-	// Cloud Code Assist advertises `-tiered` aliases beside effort-suffixed
-	// Gemini Flash siblings. Fold each alias into the canonical routed family;
-	// its minimal/off tier is served by the `-low` SKU.
-	effort-family "google-antigravity" "gemini-3.6-flash" "gemini-3.6-flash-tiered"
-	effort-family "google-antigravity" "gemini-3.7-flash" "gemini-3.7-flash-tiered"
 	// `-fast` is a parallel SKU lane. It stays in the logical identifier while
 	// the effort token immediately before it selects the wire sibling.
 	effort-lane-suffix "-fast" "cursor"
@@ -36,22 +31,17 @@ collapse {
 	// Reviewed per-provider variant families: logical models served as
 	// per-effort/thinking sibling wire ids, with explicit routing, ladders,
 	// budgets, and wire facts. Ported verbatim from the legacy hand tables.
-	variant-family "google-antigravity" "gemini-3.6-flash" name="Gemini 3.6 Flash" {
-		members "gemini-3.6-flash-low" "gemini-3.6-flash-medium" "gemini-3.6-flash-high" "gemini-3.6-flash-tiered"
-		route "minimal" "gemini-3.6-flash-low"
-		route "low" "gemini-3.6-flash-low"
-		route "medium" "gemini-3.6-flash-medium"
-		route "high" "gemini-3.6-flash-high"
-		mode "google-level"
-		efforts "minimal" "low" "medium" "high"
-		requires-effort #true
-	}
-	variant-family "google-antigravity" "gemini-3.7-flash" name="Gemini 3.7 Flash" {
-		members "gemini-3.7-flash-low" "gemini-3.7-flash-medium" "gemini-3.7-flash-high" "gemini-3.7-flash-tiered"
-		route "minimal" "gemini-3.7-flash-low"
-		route "low" "gemini-3.7-flash-low"
-		route "medium" "gemini-3.7-flash-medium"
-		route "high" "gemini-3.7-flash-high"
+	//
+	// Cloud Code Assist serves every Gemini Flash generation from 3.6 on as
+	// `-low`/`-medium`/`-high` thinking-level SKUs plus a `-tiered` alias. One
+	// template per provider covers each revision discovery advertises; the
+	// minimal tier is served by the `-low` SKU (Gemini 3.7+ rejects MINIMAL).
+	variant-family "google-antigravity" "gemini-{rev}-flash" name="Gemini {rev} Flash" revision=">=3.6" {
+		members "gemini-{rev}-flash-low" "gemini-{rev}-flash-medium" "gemini-{rev}-flash-high" "gemini-{rev}-flash-tiered"
+		route "minimal" "gemini-{rev}-flash-low"
+		route "low" "gemini-{rev}-flash-low"
+		route "medium" "gemini-{rev}-flash-medium"
+		route "high" "gemini-{rev}-flash-high"
 		mode "google-level"
 		efforts "minimal" "low" "medium" "high"
 		requires-effort #true
@@ -143,22 +133,12 @@ collapse {
 		efforts "minimal" "low" "medium" "high"
 		preserve-absent-effort-routes #true
 	}
-	variant-family "google-gemini-cli" "gemini-3.6-flash" name="Gemini 3.6 Flash" {
-		members "gemini-3.6-flash-low" "gemini-3.6-flash-medium" "gemini-3.6-flash-high" "gemini-3.6-flash-tiered"
-		route "minimal" "gemini-3.6-flash-low"
-		route "low" "gemini-3.6-flash-low"
-		route "medium" "gemini-3.6-flash-medium"
-		route "high" "gemini-3.6-flash-high"
-		mode "google-level"
-		efforts "minimal" "low" "medium" "high"
-		requires-effort #true
-	}
-	variant-family "google-gemini-cli" "gemini-3.7-flash" name="Gemini 3.7 Flash" {
-		members "gemini-3.7-flash-low" "gemini-3.7-flash-medium" "gemini-3.7-flash-high" "gemini-3.7-flash-tiered"
-		route "minimal" "gemini-3.7-flash-low"
-		route "low" "gemini-3.7-flash-low"
-		route "medium" "gemini-3.7-flash-medium"
-		route "high" "gemini-3.7-flash-high"
+	variant-family "google-gemini-cli" "gemini-{rev}-flash" name="Gemini {rev} Flash" revision=">=3.6" {
+		members "gemini-{rev}-flash-low" "gemini-{rev}-flash-medium" "gemini-{rev}-flash-high" "gemini-{rev}-flash-tiered"
+		route "minimal" "gemini-{rev}-flash-low"
+		route "low" "gemini-{rev}-flash-low"
+		route "medium" "gemini-{rev}-flash-medium"
+		route "high" "gemini-{rev}-flash-high"
 		mode "google-level"
 		efforts "minimal" "low" "medium" "high"
 		requires-effort #true