@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/__tests__/anvil-models.test.ts

@@ -0,0 +1,1408 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  canAnvilModelSpawnGeminiThinker,
+  DEFAULT_ANVIL_MODEL_ID,
+  DEFAULT_ANVIL_WEB_MODEL_ID,
+  FALLBACK_ANVIL_MODEL_ID,
+  ANVIL_WEB_DEEMPHASIZED_MODEL_IDS,
+  ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+  ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+  ANVIL_DESKTOP_SESSION_LIMITS,
+  ANVIL_FABLE_5_MODEL_ID,
+  ANVIL_ENABLE_MIMO_MODELS_IN_UI,
+  ANVIL_GLM_V52_MODEL_ID,
+  ANVIL_GPT_5_6_LUNA_MAX_PRICE,
+  ANVIL_GPT_5_6_LUNA_MODEL_ID,
+  ANVIL_GPT_5_6_LUNA_PROVIDER_ROUTE,
+  ANVIL_GPT_5_6_LUNA_REASONING_EFFORT,
+  ANVIL_KIMI_K3_ECO_MODEL_ID,
+  ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+  ANVIL_MUSE_SPARK_REASONING_EFFORT,
+  getAnvilModelReasoningEffort,
+  MUSE_SPARK_12_CONTRIBUTOR_UPSTREAM_MODEL_ID,
+  MUSE_SPARK_FALLBACK_AFTER_MS,
+  MUSE_SPARK_FALLBACK_MODEL_ID,
+  MUSE_SPARK_FALLBACK_NOTICE,
+  isMuseSparkModelId,
+  LIMITED_ANVIL_MODEL_ID,
+  LIMITED_ANVIL_MODEL_IDS,
+  ANVIL_MIMO_V25_MODEL_ID,
+  ANVIL_MODELS,
+  ANVIL_WEB_GOD_ONLY_MODELS,
+  ANVIL_WEB_ALL_MODELS,
+  ANVIL_WEB_MODELS,
+  ANVIL_WEB_RETIRED_PICKER_MODEL_IDS,
+  ANVIL_WEB_STANDARD_MODEL_IDS,
+  SUPPORTED_ANVIL_MODELS,
+  getAnvilDeploymentAvailabilityLabel,
+  getAnvilDesktopSessionBucket,
+  getAnvilModel,
+  getAnvilModelImageSupport,
+  getAnvilWebModel,
+  getAnvilModelsForAccessTier,
+  getRecommendedAnvilModelId,
+  getRecommendedAnvilWebModelId,
+  isAnvilWebDeemphasizedModelId,
+  isAnvilDeploymentHours,
+  isAnvilGlmV52ModelId,
+  isAnvilGpt56LunaModelId,
+  isAnvilLimitedOfferModelId,
+  isAnvilSessionModelAllowedForAccessTier,
+  isAnvilSessionModelAvailable,
+  isAnvilTracedModelId,
+  isAnvilWebGeoExemptModelId,
+  isAnvilWebSelectableModelId,
+  isAnvilModelId,
+  isAnvilMultimodalModelId,
+  isAnvilModelAllowedForAccessTier,
+  isAnvilPremiumModelId,
+  isAnvilWebGodOnlyModelId,
+  isAnvilWebRememberableModelId,
+  isAnvilWebModelAllowedForLimitedTier,
+  isAnvilWebModelId,
+  isAnvilWebMultimodalModelId,
+  isAnvilWebPremiumModelId,
+  resolveRememberedAnvilWebModel,
+  isSupportedAnvilModelId,
+  isAnvilSessionModelId,
+  resolveAnvilWebModel,
+  resolveAnvilWebModelForLimitedTier,
+  resolveAnvilModelForAccessTier,
+  resolveAnvilSessionModelForAccessTier,
+  getAnvilModelSupersededBy,
+  migrateSupersededAnvilModelPreference,
+} from '../constants/anvil-models'
+import type { AnvilModelOption } from '../constants/anvil-models'
+import { minimaxModels } from '../constants/model-config'
+
+const ANVIL_KIMI_MODEL_ID = 'moonshotai/kimi-k2.7-code'
+// Both removed 2026-08-04. Held as literals, not imported constants, so these
+// guards keep asserting on the WIRE ids even if a constant of the same name is
+// ever reintroduced.
+const ANVIL_MIMO_V25_PRO_MODEL_ID = 'mimo/mimo-v2.5-pro'
+const ANVIL_CROF_GLM_V52_MODEL_ID = 'crof/glm-5.2'
+
+const MINIMAX_M3_MODEL_ID = minimaxModels.minimaxM3
+
+describe('anvil model availability', () => {
+  test('defaults to V4 Pro and falls back to V4 Flash for new clients', () => {
+    // The two constants answer different questions, and since the CLI/Desktop
+    // default moved to the premium V4 Pro 08/13 GA build (2026-08-12) they name
+    // different models again: the default is what we RECOMMEND, the fallback is
+    // what is always joinable when the premium pool is spent.
+    expect(DEFAULT_ANVIL_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(FALLBACK_ANVIL_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    // The default is premium, so every surface that offers it has to know the
+    // live quota — that is the whole reason the fallback exists separately.
+    expect(isAnvilPremiumModelId(DEFAULT_ANVIL_MODEL_ID)).toBe(true)
+    expect(isAnvilPremiumModelId(FALLBACK_ANVIL_MODEL_ID)).toBe(false)
+  })
+
+  test('desktop concurrency splits full access into 1 premium and 3 unlimited sessions', () => {
+    expect(
+      getAnvilDesktopSessionBucket(
+        ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+        'full',
+      ),
+    ).toBe('premium')
+    expect(
+      getAnvilDesktopSessionBucket(
+        ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+        'full',
+      ),
+    ).toBe('unlimited')
+    expect(ANVIL_DESKTOP_SESSION_LIMITS).toEqual({
+      premium: 1,
+      unlimited: 3,
+    })
+    expect(
+      getAnvilDesktopSessionBucket(
+        ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+        'limited',
+      ),
+    ).toBe('premium')
+  })
+
+  test('DeepSeek Pro carries the AI-training warning before selection', () => {
+    const deepseek = ANVIL_MODELS.find(
+      (m) => m.id === ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    expect((deepseek as { warning?: string } | undefined)?.warning).toBe(
+      'May use data for AI training',
+    )
+  })
+
+  test('DeepSeek Flash carries the AI-training warning before selection', () => {
+    const deepseek = ANVIL_MODELS.find(
+      (m) => m.id === ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+    )
+    expect((deepseek as { warning?: string } | undefined)?.warning).toBe(
+      'May use data for AI training',
+    )
+  })
+
+  test('only the DeepSeek family is trace-stored in free mode; M3 has no warning', () => {
+    const m3 = ANVIL_MODELS.find((m) => m.id === MINIMAX_M3_MODEL_ID)
+    expect((m3 as { warning?: string } | undefined)?.warning).toBeUndefined()
+    // The DeepSeek family discloses AI training and IS stored.
+    expect(isAnvilTracedModelId(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)).toBe(
+      true,
+    )
+    expect(isAnvilTracedModelId(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)).toBe(
+      true,
+    )
+    // Everything else (incl. M3 on Fireworks) is NOT stored.
+    expect(isAnvilTracedModelId(MINIMAX_M3_MODEL_ID)).toBe(false)
+    expect(isAnvilTracedModelId(ANVIL_KIMI_MODEL_ID)).toBe(false)
+    expect(isAnvilTracedModelId(ANVIL_MIMO_V25_MODEL_ID)).toBe(false)
+    expect(isAnvilTracedModelId(null)).toBe(false)
+  })
+
+  test('trace storage follows machine-readable data-use metadata', () => {
+    const models: readonly AnvilModelOption[] = SUPPORTED_ANVIL_MODELS
+    for (const model of models) {
+      expect(isAnvilTracedModelId(model.id)).toBe(
+        model.dataUse === 'training',
+      )
+      expect(model.warning !== undefined).toBe(model.dataUse === 'training')
+    }
+  })
+
+  test('DeepSeek V4 Flash is selectable and non-premium', () => {
+    expect(ANVIL_MODELS.map((model) => model.id)).toContain(
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+    )
+    expect(isAnvilModelId(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)).toBe(true)
+    expect(isAnvilPremiumModelId(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)).toBe(
+      false,
+    )
+  })
+
+  test('MiMo 2.5 remains supported and follows the UI rollout flag', () => {
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).toContain(
+      ANVIL_MIMO_V25_MODEL_ID,
+    )
+
+    if (ANVIL_ENABLE_MIMO_MODELS_IN_UI) {
+      expect(ANVIL_MODELS.map((model) => model.id)).toContain(
+        ANVIL_MIMO_V25_MODEL_ID,
+      )
+    } else {
+      expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(
+        ANVIL_MIMO_V25_MODEL_ID,
+      )
+    }
+
+    expect(isAnvilPremiumModelId(ANVIL_MIMO_V25_MODEL_ID)).toBe(false)
+    expect(getAnvilModelImageSupport(ANVIL_MIMO_V25_MODEL_ID)).toBe(true)
+  })
+
+  test('MiMo 2.5 Pro is fully removed from Anvil', () => {
+    // Retired from the client pickers 2026-07-31, server half removed
+    // 2026-08-04 once the tail had decayed from ~170 to ~33 daily users. Same
+    // two-stage shape Kimi K2.7 Code went through. Paid/BYOK MiMo Pro is
+    // unaffected; it never resolves through these helpers.
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_MIMO_V25_PRO_MODEL_ID,
+    )
+    expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_MIMO_V25_PRO_MODEL_ID,
+    )
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_MIMO_V25_PRO_MODEL_ID,
+    )
+    expect(isAnvilModelId(ANVIL_MIMO_V25_PRO_MODEL_ID)).toBe(false)
+    expect(isSupportedAnvilModelId(ANVIL_MIMO_V25_PRO_MODEL_ID)).toBe(
+      false,
+    )
+    expect(isAnvilSessionModelId(ANVIL_MIMO_V25_PRO_MODEL_ID)).toBe(false)
+    expect(isAnvilPremiumModelId(ANVIL_MIMO_V25_PRO_MODEL_ID)).toBe(false)
+    // The non-Pro model must not be caught by the removal: the ids share a
+    // prefix, and anvilModelIdMatches only tolerates dated suffixes.
+    expect(isAnvilSessionModelId(ANVIL_MIMO_V25_MODEL_ID)).toBe(true)
+  })
+
+  test('reports image support only for known Anvil models', () => {
+    expect(
+      getAnvilModelImageSupport(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(false)
+    expect(getAnvilModelImageSupport(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(
+      getAnvilModelImageSupport('vendor/new-vision-model'),
+    ).toBeUndefined()
+
+    for (const model of SUPPORTED_ANVIL_MODELS) {
+      expect(isAnvilMultimodalModelId(model.id)).toBe(model.multimodal)
+    }
+    for (const model of ANVIL_WEB_ALL_MODELS) {
+      expect(isAnvilWebMultimodalModelId(model.id)).toBe(model.multimodal)
+    }
+  })
+
+  test('Kimi K2.7 Code is fully removed from Anvil', () => {
+    // Removed 2026-07-31 (client pickers went first, on 2026-07-30). The server
+    // half is gone too, so a stale client selection is no longer admitted —
+    // that tail was still spending ~$2.3k/day. Paid/BYOK Kimi is unaffected;
+    // it never resolves through these helpers.
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_KIMI_MODEL_ID,
+    )
+    expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_KIMI_MODEL_ID,
+    )
+    expect(
+      getAnvilModelsForAccessTier('full').map((m) => m.id),
+    ).not.toContain(ANVIL_KIMI_MODEL_ID)
+    expect(isAnvilModelId(ANVIL_KIMI_MODEL_ID)).toBe(false)
+    expect(isSupportedAnvilModelId(ANVIL_KIMI_MODEL_ID)).toBe(false)
+    expect(getAnvilWebModel(ANVIL_KIMI_MODEL_ID).id).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+    expect(isAnvilPremiumModelId(ANVIL_KIMI_MODEL_ID)).toBe(false)
+    expect(
+      isAnvilModelAllowedForAccessTier(ANVIL_KIMI_MODEL_ID, 'full'),
+    ).toBe(false)
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_KIMI_MODEL_ID, 'full'),
+    ).toBe(FALLBACK_ANVIL_MODEL_ID)
+    // Session admission no longer accepts it either, so live stale sessions
+    // resolve to the fallback instead of continuing on Kimi.
+    expect(
+      isAnvilSessionModelAllowedForAccessTier(
+        ANVIL_KIMI_MODEL_ID,
+        'full',
+      ),
+    ).toBe(false)
+    expect(
+      resolveAnvilSessionModelForAccessTier(ANVIL_KIMI_MODEL_ID, 'full', {
+        includeGodOnly: false,
+      }),
+    ).toBe(FALLBACK_ANVIL_MODEL_ID)
+    // Retired K2.6 is no longer a anvil model; stale saved selections must
+    // fall back rather than be admitted.
+    expect(isSupportedAnvilModelId('moonshotai/kimi-k2.6')).toBe(false)
+    expect(
+      isAnvilModelAllowedForAccessTier('moonshotai/kimi-k2.6', 'full'),
+    ).toBe(false)
+    expect(
+      resolveAnvilModelForAccessTier('moonshotai/kimi-k2.6', 'full'),
+    ).not.toBe('moonshotai/kimi-k2.6')
+  })
+
+  test('both HY3 routes are fully removed from Anvil', () => {
+    // HY3 was withdrawn from the Web picker during the initial rollout and left
+    // in ANVIL_WEB_RETIRED_PICKER_MODEL_IDS, which is a client-side filter
+    // and therefore not a gate at all — the same mistake that let the CrofAI
+    // GLM route be farmed. Removed outright 2026-08-04, along with the
+    // god-only paid OpenRouter route.
+    //
+    // As of 2026-08-07 the wire-id CONSTANTS are gone too: hy3-fallback.ts and
+    // the Atlas Cloud adapter that was its paid lane have been deleted, so
+    // nothing routes `tencent/hy3` on any path, paid or free. The slugs are
+    // spelled out literally here precisely because no constant remains to
+    // import — that is the point of the test.
+    for (const hy3Id of ['tencent/hy3:free', 'tencent/hy3']) {
+      expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(hy3Id)
+      expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+        hy3Id,
+      )
+      expect(ANVIL_WEB_MODELS.map((model) => model.id)).not.toContain(hy3Id)
+      expect(
+        ANVIL_WEB_GOD_ONLY_MODELS.map((model) => model.id),
+      ).not.toContain(hy3Id)
+      expect(ANVIL_WEB_ALL_MODELS.map((model) => model.id)).not.toContain(
+        hy3Id,
+      )
+
+      expect(isAnvilModelId(hy3Id)).toBe(false)
+      expect(isSupportedAnvilModelId(hy3Id)).toBe(false)
+      expect(isAnvilWebModelId(hy3Id, { includeGodOnly: true })).toBe(false)
+      expect(isAnvilWebGodOnlyModelId(hy3Id)).toBe(false)
+      expect(isAnvilSessionModelId(hy3Id)).toBe(false)
+      // No pool may meter it, in either direction: premium would hand it out
+      // free, and standard would leave it unlimited.
+      expect(isAnvilWebPremiumModelId(hy3Id)).toBe(false)
+      expect(isAnvilPremiumModelId(hy3Id)).toBe(false)
+      expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(hy3Id)
+      // A stale saved selection downgrades rather than resolving to itself.
+      expect(resolveAnvilWebModel(hy3Id, { includeGodOnly: true })).toBe(
+        FALLBACK_ANVIL_MODEL_ID,
+      )
+      expect(getAnvilWebModel(hy3Id).id).toBe(FALLBACK_ANVIL_MODEL_ID)
+    }
+  })
+
+  test('the picker-retirement list is empty, and that is deliberate', () => {
+    // Both former occupants (HY3, CrofAI GLM 5.2) were farmed or left publicly
+    // advertised precisely because a picker-only retirement is a UI change, not
+    // a gate. If this fails, something was parked here instead of removed —
+    // check that the id being reachable by a direct API caller is actually
+    // harmless before accepting it.
+    expect(ANVIL_WEB_RETIRED_PICKER_MODEL_IDS).toEqual([])
+    for (const model of ANVIL_WEB_ALL_MODELS) {
+      expect(isAnvilWebSelectableModelId(model.id)).toBe(true)
+    }
+  })
+
+  test('GLM 5.2 is referral-only and reachable by exactly one model id', () => {
+    // The earned route stays selectable — removing the other GLM route must
+    // never take this one down with it.
+    expect(isAnvilWebSelectableModelId(ANVIL_GLM_V52_MODEL_ID)).toBe(true)
+    // Every other web model is unaffected.
+    expect(
+      isAnvilWebSelectableModelId(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(true)
+  })
+
+  test('CLI access-tier resolver preserves GLM at every tier', () => {
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_GLM_V52_MODEL_ID, 'full'),
+    ).toBe(ANVIL_GLM_V52_MODEL_ID)
+    // Since bounties (2026-08-03), GLM survives the limited-tier coercion: a
+    // bounty-earned session is redeemable in every region. The entitlement
+    // gate moved DOWN into the GLM quota pool, which at limited tier counts
+    // ONLY grants minted redeemable_at_limited_tier — referral GLM still buys
+    // a limited-tier user nothing. Coercing here instead would rewrite a
+    // deliberate pick to DeepSeek and strand the session they earned.
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_GLM_V52_MODEL_ID, 'limited'),
+    ).toBe(ANVIL_GLM_V52_MODEL_ID)
+    // Everything else still collapses to the limited model.
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_KIMI_MODEL_ID, 'limited'),
+    ).toBe(LIMITED_ANVIL_MODEL_ID)
+  })
+
+  test('the CrofAI GLM 5.2 wire id is fully removed', () => {
+    // Retired from the pickers 2026-07-30 and deleted 2026-08-04. The picker
+    // retirement was client-side only, so hand-written API callers kept
+    // admitting sessions on this id and drawing GLM 5.2 from the free daily
+    // PREMIUM pool instead of the earned GLM pool — 12-49 distinct accounts a
+    // day, five days after it was supposedly unreachable. No shipped client
+    // ever bundled it, so deleting it breaks nothing.
+    //
+    // The invariant this guards: GLM 5.2 must have exactly ONE wire id. The
+    // quota pool is chosen by model id, so a second id is a second entitlement.
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_CROF_GLM_V52_MODEL_ID,
+    )
+    expect(ANVIL_WEB_ALL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_CROF_GLM_V52_MODEL_ID,
+    )
+    expect(isAnvilWebModelId(ANVIL_CROF_GLM_V52_MODEL_ID)).toBe(false)
+    expect(isAnvilSessionModelId(ANVIL_CROF_GLM_V52_MODEL_ID)).toBe(false)
+    // Critically: it must not be metered by the free daily premium pool, which
+    // is the door this whole removal closes.
+    expect(isAnvilWebPremiumModelId(ANVIL_CROF_GLM_V52_MODEL_ID)).toBe(
+      false,
+    )
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(
+      ANVIL_CROF_GLM_V52_MODEL_ID,
+    )
+    // A stale saved selection downgrades to the always-available fallback.
+    expect(resolveAnvilWebModel(ANVIL_CROF_GLM_V52_MODEL_ID)).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+    // The earned route is untouched.
+    expect(isAnvilGlmV52ModelId(ANVIL_GLM_V52_MODEL_ID)).toBe(true)
+    expect(isAnvilSessionModelId(ANVIL_GLM_V52_MODEL_ID)).toBe(true)
+  })
+
+  test('GLM 5.2 is never remembered as the default model', () => {
+    // GLM runs out long before the rest of the picker, so remembering it would
+    // strand a new thread / app / page load on a model that fails admission.
+    expect(isAnvilWebRememberableModelId(ANVIL_GLM_V52_MODEL_ID)).toBe(
+      false,
+    )
+    expect(resolveRememberedAnvilWebModel(ANVIL_GLM_V52_MODEL_ID)).toBe(
+      DEFAULT_ANVIL_WEB_MODEL_ID,
+    )
+    // Retired picker models self-heal to the always-available fallback, while
+    // god-only models remain rememberable when the caller opts in.
+    expect(
+      resolveRememberedAnvilWebModel(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(resolveRememberedAnvilWebModel(ANVIL_KIMI_MODEL_ID)).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+    expect(
+      resolveRememberedAnvilWebModel(ANVIL_KIMI_K3_ECO_MODEL_ID, {
+        includeGodOnly: true,
+      }),
+    ).toBe(ANVIL_KIMI_K3_ECO_MODEL_ID)
+    // A retired/unknown saved id keeps the pre-existing resolution: the
+    // always-available fallback, not the premium default.
+    expect(resolveRememberedAnvilWebModel('some/retired-model')).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+  })
+
+  test('every Web picker model falls into exactly one quota group', () => {
+    // The Web/Cloud picker groups rows by these two predicates (referral GLM,
+    // premium) and treats the remainder as Standard. Each group is metered by a
+    // different pool, so a model matching both — or a premium model matching
+    // neither and silently landing in the free Standard group — is a quota bug,
+    // not a cosmetic one.
+    for (const model of ANVIL_WEB_MODELS) {
+      const groups = [
+        isAnvilGlmV52ModelId(model.id),
+        isAnvilWebPremiumModelId(model.id),
+      ].filter(Boolean)
+      expect({ id: model.id, groups: groups.length }).toEqual({
+        id: model.id,
+        // Zero groups means the Standard pool, which is only correct for a
+        // model that is not marked premium.
+        groups: model.premium ? 1 : 0,
+      })
+    }
+  })
+
+  test('the removed CrofAI GLM 5.2 id is admitted at no access tier', () => {
+    for (const tier of ['limited', 'full'] as const) {
+      expect(
+        isAnvilSessionModelAllowedForAccessTier(
+          ANVIL_CROF_GLM_V52_MODEL_ID,
+          tier,
+        ),
+      ).toBe(false)
+    }
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(ANVIL_CROF_GLM_V52_MODEL_ID),
+    ).toBe(false)
+    expect(isAnvilWebGeoExemptModelId(ANVIL_CROF_GLM_V52_MODEL_ID)).toBe(
+      false,
+    )
+    expect(
+      resolveAnvilWebModelForLimitedTier(ANVIL_CROF_GLM_V52_MODEL_ID),
+    ).toBe(LIMITED_ANVIL_MODEL_ID)
+  })
+
+  test('bounty GLM 5.2 survives the Web limited-tier coercion', () => {
+    // Regression: this coercion ran BEFORE the quota pool got a say, so a
+    // limited-region user who had earned a bounty session had their pick
+    // rewritten to the flash model and could never spend the reward. The
+    // entitlement gate is the GLM pool (bounty grants only) — not this
+    // allowlist, which is purely about what the picker may display.
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(ANVIL_GLM_V52_MODEL_ID),
+    ).toBe(true)
+    expect(
+      resolveAnvilWebModelForLimitedTier(ANVIL_GLM_V52_MODEL_ID),
+    ).toBe(ANVIL_GLM_V52_MODEL_ID)
+
+    // The CrofAI GLM route is a paid premium model, NOT the earned one, and
+    // must stay coerced away — the two ids are easy to confuse.
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(ANVIL_CROF_GLM_V52_MODEL_ID),
+    ).toBe(false)
+  })
+
+  test('Kimi K3 is a god-only Anvil Web/Cloud test model', () => {
+    // The wire id must keep the `crof/` prefix and the `-eco` build suffix:
+    // isCrofModel keys off the exact id, and CrofAI also serves a full
+    // `kimi-k3` at twice the price. See kimi-k3-god-only.test.ts.
+    expect(ANVIL_KIMI_K3_ECO_MODEL_ID).toBe('crof/kimi-k3-eco')
+
+    expect(ANVIL_WEB_GOD_ONLY_MODELS.map((model) => model.id)).toContain(
+      ANVIL_KIMI_K3_ECO_MODEL_ID,
+    )
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_KIMI_K3_ECO_MODEL_ID,
+    )
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_KIMI_K3_ECO_MODEL_ID,
+    )
+
+    expect(isAnvilWebModelId(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(false)
+    expect(
+      isAnvilWebModelId(ANVIL_KIMI_K3_ECO_MODEL_ID, {
+        includeGodOnly: true,
+      }),
+    ).toBe(true)
+    expect(isAnvilWebGodOnlyModelId(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(
+      true,
+    )
+    expect(isAnvilWebPremiumModelId(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(
+      true,
+    )
+    // Never reachable from the CLI/Desktop picker or a limited-tier browser.
+    expect(isAnvilPremiumModelId(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(false)
+    expect(isAnvilModelId(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(false)
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(ANVIL_KIMI_K3_ECO_MODEL_ID),
+    ).toBe(false)
+
+    expect(resolveAnvilWebModel(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+    expect(
+      resolveAnvilWebModel(ANVIL_KIMI_K3_ECO_MODEL_ID, {
+        includeGodOnly: true,
+      }),
+    ).toBe(ANVIL_KIMI_K3_ECO_MODEL_ID)
+
+    const model = getAnvilWebModel(ANVIL_KIMI_K3_ECO_MODEL_ID)
+    // 'Kimi K3', not 'Kimi K3 Eco' — deliberate, see kimi-k3-god-only.test.ts.
+    expect(model.displayName).toBe('Kimi K3')
+    expect(model.tagline).toBe('Via CrofAI')
+    expect(model.experimental).toBe(true)
+    expect(model.multimodal).toBe(false)
+    expect(getAnvilModelImageSupport(ANVIL_KIMI_K3_ECO_MODEL_ID)).toBe(
+      false,
+    )
+  })
+
+  test('Ling 3.0 Flash and Greg 2 are fully removed from Anvil', () => {
+    // All three were god-only test rows, removed 2026-08-07. Spelled literally
+    // because no constant remains to import.
+    for (const removedId of [
+      'inclusionai/ling-3.0-flash:free',
+      'crof/greg-2-ultra',
+      'crof/greg-2-super',
+    ]) {
+      expect(ANVIL_WEB_ALL_MODELS.map((model) => model.id)).not.toContain(
+        removedId,
+      )
+      expect(
+        ANVIL_WEB_GOD_ONLY_MODELS.map((model) => model.id),
+      ).not.toContain(removedId)
+      expect(isAnvilWebModelId(removedId, { includeGodOnly: true })).toBe(
+        false,
+      )
+      expect(isAnvilWebGodOnlyModelId(removedId)).toBe(false)
+      expect(isAnvilSessionModelId(removedId)).toBe(false)
+      // No pool may still meter them, in either direction.
+      expect(isAnvilWebPremiumModelId(removedId)).toBe(false)
+      expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(removedId)
+      expect(resolveAnvilWebModel(removedId, { includeGodOnly: true })).toBe(
+        FALLBACK_ANVIL_MODEL_ID,
+      )
+    }
+  })
+
+  test('KAT Coder Pro V2 is fully retired from Anvil Web and Cloud', () => {
+    const retiredKatModelId = 'kwaipilot/kat-coder-pro-v2'
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).not.toContain(
+      retiredKatModelId,
+    )
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      retiredKatModelId,
+    )
+    expect(isAnvilWebModelId(retiredKatModelId)).toBe(false)
+    expect(isAnvilWebPremiumModelId(retiredKatModelId)).toBe(false)
+    expect(resolveAnvilWebModel(retiredKatModelId)).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+  })
+
+  test('MiniMax M2.7 support is fully removed', () => {
+    const legacyMinimaxM27 = 'minimax/minimax-m2.7'
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      legacyMinimaxM27,
+    )
+    expect(isAnvilModelId(legacyMinimaxM27)).toBe(false)
+    expect(isSupportedAnvilModelId(legacyMinimaxM27)).toBe(false)
+    expect(isAnvilModelAllowedForAccessTier(legacyMinimaxM27, 'full')).toBe(
+      false,
+    )
+    // Old clients with a saved M2.7 selection resolve to the fallback model.
+    expect(resolveAnvilModelForAccessTier(legacyMinimaxM27, 'full')).toBe(
+      FALLBACK_ANVIL_MODEL_ID,
+    )
+  })
+
+  test('MiniMax M3 is a selectable premium model on the standard daily pool', () => {
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).toContain(
+      MINIMAX_M3_MODEL_ID,
+    )
+    expect(ANVIL_MODELS.map((model) => model.id)).toContain(
+      MINIMAX_M3_MODEL_ID,
+    )
+    expect(getAnvilModelsForAccessTier('full').map((m) => m.id)).toContain(
+      MINIMAX_M3_MODEL_ID,
+    )
+    expect(isAnvilModelId(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(isSupportedAnvilModelId(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(isAnvilPremiumModelId(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(isAnvilWebPremiumModelId(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(
+      isAnvilModelAllowedForAccessTier(MINIMAX_M3_MODEL_ID, 'full'),
+    ).toBe(true)
+    // DeepSeek V4 Pro is the recommended default (2026-08-12), so it leads the
+    // picker list, with the unlimited Flash fallback right behind it and Luna
+    // ahead of M3.
+    expect(ANVIL_MODELS[0]!.id).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(ANVIL_MODELS[1]!.id).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    expect(ANVIL_MODELS[2]!.id).toBe(ANVIL_GPT_5_6_LUNA_MODEL_ID)
+    expect(ANVIL_MODELS[3]!.id).toBe(MINIMAX_M3_MODEL_ID)
+  })
+
+  test('the recommended default leads ANVIL_MODELS, with Flash second', () => {
+    // ANVIL_MODELS order IS the picker row order, and it went stale once
+    // when the default flipped without reordering — the rows led with Flash
+    // while the recommendation already named Pro. Pin the two lead positions
+    // to the constants that drive the recommendation, so a future default
+    // change can't silently leave this list behind.
+    expect(ANVIL_MODELS[0]!.id).toBe(DEFAULT_ANVIL_MODEL_ID)
+    expect(ANVIL_MODELS[1]!.id).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+  })
+
+  test('GPT-5.6 Luna is a premium model on every full-access surface', () => {
+    // The wire id must stay OpenRouter's own slug: getChatCompletionsProvider
+    // has no Luna branch, so it only reaches OpenRouter by falling through to
+    // the default route with the slug intact.
+    expect(ANVIL_GPT_5_6_LUNA_MODEL_ID).toBe('openai/gpt-5.6-luna')
+
+    // CLI/Desktop picker, Web/Cloud picker, and the session/chat layers.
+    expect(ANVIL_MODELS.map((model) => model.id)).toContain(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+    )
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).toContain(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+    )
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).toContain(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+    )
+    expect(getAnvilModelsForAccessTier('full').map((m) => m.id)).toContain(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+    )
+    // Everyone on the tier can pick it — it is not god-only and not retired.
+    expect(isAnvilWebGodOnlyModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(
+      false,
+    )
+    expect(isAnvilWebSelectableModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(
+      true,
+    )
+
+    // Metered by the SHARED daily premium pool on every surface, not a pool of
+    // its own and never the free standard browser pool.
+    expect(isAnvilPremiumModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(true)
+    expect(isAnvilWebPremiumModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(
+      true,
+    )
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+    )
+    expect(isAnvilGlmV52ModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(false)
+    // Dated snapshots can't dodge the premium quota or the pinned routing.
+    expect(
+      isAnvilPremiumModelId(`${ANVIL_GPT_5_6_LUNA_MODEL_ID}-20260709`),
+    ).toBe(true)
+    expect(
+      isAnvilGpt56LunaModelId(`${ANVIL_GPT_5_6_LUNA_MODEL_ID}-20260709`),
+    ).toBe(true)
+    expect(isAnvilGpt56LunaModelId(ANVIL_MIMO_V25_MODEL_ID)).toBe(false)
+
+    const model = getAnvilWebModel(ANVIL_GPT_5_6_LUNA_MODEL_ID)
+    expect(model.displayName).toBe('GPT-5.6 Luna')
+    // OpenAI's API does not train on request data, so no warning and no
+    // trace storage — and it accepts images.
+    expect(model.dataUse).toBe('service')
+    expect(model.warning).toBeUndefined()
+    expect(isAnvilTracedModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(false)
+    expect(getAnvilModelImageSupport(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toBe(
+      true,
+    )
+    // Cheap per token, so it is not one of the muted "costly premium" rows.
+    expect(
+      isAnvilWebDeemphasizedModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID),
+    ).toBe(false)
+
+    // Limited regions stay geo-gated to the two limited-tier models.
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(ANVIL_GPT_5_6_LUNA_MODEL_ID),
+    ).toBe(false)
+    expect(
+      isAnvilModelAllowedForAccessTier(
+        ANVIL_GPT_5_6_LUNA_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(false)
+  })
+
+  test('GPT-5.6 Luna carries its pinned OpenAI route, price ceiling, and effort', () => {
+    // These three constants are the contract web/src/llm-api/openrouter.ts
+    // enforces on every Luna request.
+    expect(ANVIL_GPT_5_6_LUNA_PROVIDER_ROUTE).toBe('openai')
+    expect(ANVIL_GPT_5_6_LUNA_REASONING_EFFORT).toBe('high')
+
+    // The ceiling is a cost fence, and both bounds are load-bearing. OpenRouter
+    // compares strictly, so a ceiling AT OpenAI's $0.10/$0.60 list price 404s
+    // every request ("No endpoints found that satisfy the max price") — that
+    // shipped on 2026-07-30 and took Luna down until it was raised. It must
+    // also stay well under the $1.00/$6.00 Azure/Bedrock charge, which is the
+    // 10x route the fence exists to block.
+    const { prompt, completion } = ANVIL_GPT_5_6_LUNA_MAX_PRICE
+    expect(prompt).toBeGreaterThan(0.1)
+    expect(completion).toBeGreaterThan(0.6)
+    expect(prompt).toBeLessThan(1.0)
+    expect(completion).toBeLessThan(6.0)
+  })
+
+  test('limited access exposes DeepSeek V4 Flash and non-Pro MiMo 2.5', () => {
+    expect(LIMITED_ANVIL_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    expect(LIMITED_ANVIL_MODEL_IDS).toEqual([
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+      ANVIL_MIMO_V25_MODEL_ID,
+    ])
+    expect(getAnvilModelsForAccessTier('limited').map((m) => m.id)).toEqual([
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+      ANVIL_MIMO_V25_MODEL_ID,
+    ])
+    expect(
+      isAnvilModelAllowedForAccessTier(
+        ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(true)
+    expect(
+      isAnvilModelAllowedForAccessTier(MINIMAX_M3_MODEL_ID, 'limited'),
+    ).toBe(false)
+    expect(
+      isAnvilModelAllowedForAccessTier(
+        ANVIL_MIMO_V25_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(true)
+    expect(
+      isAnvilModelAllowedForAccessTier(
+        ANVIL_MIMO_V25_PRO_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(false)
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_MIMO_V25_MODEL_ID, 'limited'),
+    ).toBe(ANVIL_MIMO_V25_MODEL_ID)
+    expect(
+      resolveAnvilModelForAccessTier(MINIMAX_M3_MODEL_ID, 'limited'),
+    ).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+  })
+
+  test('recommends a joinable, in-tier model for the picker hero', () => {
+    // Full access → DeepSeek V4 Pro 08/13 (the recommended default since
+    // 2026-08-12). It is premium, so the hero HAS to flip once the daily pool
+    // runs dry — the assertions below are what keep the CLI/Desktop hero
+    // joinable at every point in a user's day.
+    expect(getRecommendedAnvilModelId('full')).toBe(
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    expect(getRecommendedAnvilModelId(undefined)).toBe(
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    expect(
+      getRecommendedAnvilModelId('full', { premiumExhausted: true }),
+    ).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    expect(
+      isAnvilPremiumModelId(
+        getRecommendedAnvilModelId('full', { premiumExhausted: true }),
+      ),
+    ).toBe(false)
+    // Limited access → DeepSeek V4 Flash, which is in the limited model set.
+    expect(getRecommendedAnvilModelId('limited')).toBe(
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+    )
+    expect(
+      getAnvilModelsForAccessTier('limited').some(
+        (m) => m.id === getRecommendedAnvilModelId('limited'),
+      ),
+    ).toBe(true)
+  })
+
+  test('every surface recommends DeepSeek V4 Pro, on two separate constants', () => {
+    // The browser surfaces took Pro on 2026-08-12 (Luna held it from
+    // 2026-08-04) and the CLI/Desktop pickers followed the same day: the 08/13
+    // GA build wins the agentic benchmarks these surfaces run, so there is no
+    // longer a surface where a different model is the better first pick. They
+    // stay TWO constants because they have diverged before and may again.
+    expect(DEFAULT_ANVIL_WEB_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(DEFAULT_ANVIL_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(getRecommendedAnvilWebModelId('full')).toBe(
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    expect(getRecommendedAnvilWebModelId(undefined)).toBe(
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    )
+    // The recommendation must never be a model the picker also argues against.
+    expect(
+      getAnvilModelSupersededBy(
+        DEFAULT_ANVIL_WEB_MODEL_ID,
+        ANVIL_WEB_MODELS.map((model) => model.id),
+      ),
+    ).toBeUndefined()
+    // Pro is premium, so the pool CAN run dry — the recommended pick has to
+    // stay joinable, and limited tier can't name it at all.
+    expect(getRecommendedAnvilWebModelId('limited')).toBe(
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+    )
+    expect(
+      getRecommendedAnvilWebModelId('full', { premiumExhausted: true }),
+    ).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    expect(
+      isAnvilPremiumModelId(
+        getRecommendedAnvilWebModelId('full', { premiumExhausted: true }),
+      ),
+    ).toBe(false)
+    // The web default must be a real, selectable web model.
+    expect(isAnvilWebModelId(DEFAULT_ANVIL_WEB_MODEL_ID)).toBe(true)
+    // …and one the limited tier is coerced OFF of, since it is premium.
+    expect(
+      isAnvilWebModelAllowedForLimitedTier(DEFAULT_ANVIL_WEB_MODEL_ID),
+    ).toBe(false)
+  })
+
+  test('de-emphasizes nothing, and never the default', () => {
+    // The list is empty as of 2026-08-12. MiniMax M3 was the last entry and
+    // left when it became the ONLY muted row: the compact treatment folds the
+    // tagline onto the name line, which among full-size rows reads as a broken
+    // row rather than a quiet one. M3 keeps its supersededBy notice, so the
+    // steering survives — see the test below.
+    expect(ANVIL_WEB_DEEMPHASIZED_MODEL_IDS).toEqual([])
+    expect(isAnvilWebDeemphasizedModelId(MINIMAX_M3_MODEL_ID)).toBe(false)
+    expect(
+      isAnvilWebDeemphasizedModelId(`${ANVIL_KIMI_MODEL_ID}-20260301`),
+    ).toBe(false)
+    expect(
+      isAnvilWebDeemphasizedModelId(DEFAULT_ANVIL_WEB_MODEL_ID),
+    ).toBe(false)
+    expect(
+      isAnvilWebDeemphasizedModelId(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID),
+    ).toBe(false)
+    expect(isAnvilWebDeemphasizedModelId(null)).toBe(false)
+    // V4 Pro left the list on 2026-08-12 too: its 08/13 GA build wins the
+    // quality half of the de-emphasis test again, and price alone is not
+    // grounds.
+    expect(
+      isAnvilWebDeemphasizedModelId(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(false)
+    // De-emphasis is presentation only: anything added back stays selectable.
+    for (const id of ANVIL_WEB_DEEMPHASIZED_MODEL_IDS) {
+      expect(isAnvilWebModelId(id)).toBe(true)
+      expect(isAnvilModelAllowedForAccessTier(id, 'full')).toBe(true)
+    }
+  })
+
+  test('points users off MiniMax M3 to V4 Flash', () => {
+    // Flash-0731 overtook M3 on 2026-07-31, so M3 carries a notice and a switch
+    // target rather than being removed — it is still selectable.
+    const all = ANVIL_MODELS.map((model) => model.id)
+    const superseded = getAnvilModelSupersededBy(MINIMAX_M3_MODEL_ID, all)
+    expect(superseded?.modelId).toBe(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID)
+    expect(superseded!.notice.length).toBeGreaterThan(0)
+    expect(superseded!.actionLabel.length).toBeGreaterThan(0)
+    // M3 remains a real, selectable model — this is a nudge, not a retirement.
+    expect(all).toContain(MINIMAX_M3_MODEL_ID)
+    // The recommended default is never itself marked superseded.
+    expect(
+      getAnvilModelSupersededBy(DEFAULT_ANVIL_MODEL_ID, all),
+    ).toBeUndefined()
+  })
+
+  test('points users off GPT-5.6 Luna to V4 Pro, without muting Luna', () => {
+    const all = ANVIL_MODELS.map((model) => model.id)
+    const superseded = getAnvilModelSupersededBy(
+      ANVIL_GPT_5_6_LUNA_MODEL_ID,
+      all,
+    )
+    expect(superseded?.modelId).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+    expect(superseded!.notice.length).toBeGreaterThan(0)
+    expect(superseded!.actionLabel.length).toBeGreaterThan(0)
+    // The notice names the dated build, so it points at a row on screen.
+    expect(superseded!.notice).toContain('08/13')
+    // Luna stays selectable, and stays UNMUTED: it is cheaper than the model it
+    // now points at, and de-emphasis is this product's cost signal. Muting it
+    // would have the list imply a price that runs the other way.
+    expect(all).toContain(ANVIL_GPT_5_6_LUNA_MODEL_ID)
+    expect(
+      isAnvilWebDeemphasizedModelId(ANVIL_GPT_5_6_LUNA_MODEL_ID),
+    ).toBe(false)
+    // A saved Luna pick migrates to Pro rather than being stranded.
+    expect(
+      migrateSupersededAnvilModelPreference(
+        ANVIL_GPT_5_6_LUNA_MODEL_ID,
+        all,
+      ),
+    ).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+  })
+
+  test('stops steering users off V4 Pro now that its GA build leads again', () => {
+    // Pro carried a "Flash performs better" notice from 2026-07-31, when
+    // Flash-0731 beat the Pro PREVIEW. The 08/13 GA build reversed that on the
+    // agentic benchmarks, so the notice would now steer users off the stronger
+    // model — and the picker offers a one-click switch for whatever it names.
+    const all = ANVIL_MODELS.map((model) => model.id)
+    expect(
+      getAnvilModelSupersededBy(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID, all),
+    ).toBeUndefined()
+    // And on 2026-08-12 it became the recommended CLI/Desktop default too,
+    // matching the browser surfaces.
+    expect(DEFAULT_ANVIL_MODEL_ID).toBe(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID)
+  })
+
+  test('marks both new DeepSeek builds as NEW and dates their names', () => {
+    // The wire ids are undated and auto-update, so the display has to carry the
+    // signal that this is a different model than the one users already judged.
+    const dated = [
+      [ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID, '07/31'],
+      [ANVIL_DEEPSEEK_V4_PRO_MODEL_ID, '08/13'],
+    ] as const
+    // Widened to the interface: the const-asserted tuple's union type only
+    // exposes optional fields set on EVERY member, so `isNew` is unreachable
+    // through it unless the find() narrows to a single literal id.
+    const catalog: readonly AnvilModelOption[] = ANVIL_MODELS
+    for (const [id, date] of dated) {
+      const model = catalog.find((candidate) => candidate.id === id)!
+      expect(model.isNew).toBe(true)
+      expect(model.displayName).toContain(date)
+    }
+    // Nothing else claims to be new, or the badge stops meaning anything.
+    expect(catalog.filter((model) => model.isNew)).toHaveLength(dated.length)
+  })
+
+  test('steers saved picks off every superseded model', () => {
+    const all = ANVIL_MODELS.map((model) => model.id)
+    // Every model Flash overtook migrates to it...
+    for (const superseded of [MINIMAX_M3_MODEL_ID, ANVIL_MIMO_V25_MODEL_ID]) {
+      expect(migrateSupersededAnvilModelPreference(superseded, all)).toBe(
+        ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+      )
+    }
+    // ...and a current pick is left alone (null = keep it). V4 Pro is one again
+    // as of its 08/13 GA build: a user who saved it keeps it instead of being
+    // moved off it on every load.
+    for (const current of [
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+    ]) {
+      expect(migrateSupersededAnvilModelPreference(current, all)).toBeNull()
+    }
+    expect(migrateSupersededAnvilModelPreference(undefined, all)).toBeNull()
+    // Never migrates onto a model this surface cannot select.
+    expect(
+      migrateSupersededAnvilModelPreference(MINIMAX_M3_MODEL_ID, [
+        MINIMAX_M3_MODEL_ID,
+      ]),
+    ).toBeNull()
+  })
+
+  test('never de-emphasizes a model we still recommend', () => {
+    // Muting + sorting-last is how the Premium group steers to the
+    // replacement, so anything muted must be superseded. NOT the converse:
+    // MiMo 2.5 is superseded on quality but costs the same as Flash, and
+    // de-emphasis is defined as a cost signal — muting it would make the list
+    // say something untrue about its price.
+    const all = ANVIL_MODELS.map((model) => model.id)
+    for (const model of ANVIL_MODELS) {
+      if (isAnvilWebDeemphasizedModelId(model.id)) {
+        expect(getAnvilModelSupersededBy(model.id, all)).toBeDefined()
+      }
+    }
+    // The recommended default is never muted or superseded.
+    expect(isAnvilWebDeemphasizedModelId(DEFAULT_ANVIL_MODEL_ID)).toBe(
+      false,
+    )
+    expect(
+      getAnvilModelSupersededBy(DEFAULT_ANVIL_MODEL_ID, all),
+    ).toBeUndefined()
+  })
+
+  test('never offers a switch to a model the surface cannot select', () => {
+    // A picker that lacks the replacement must show no switch at all, rather
+    // than a button that resolves to nothing.
+    expect(
+      getAnvilModelSupersededBy(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID, [
+        ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+      ]),
+    ).toBeUndefined()
+    expect(getAnvilModelSupersededBy(undefined, [])).toBeUndefined()
+    expect(getAnvilModelSupersededBy('vendor/unknown', [])).toBeUndefined()
+  })
+
+  test('full-access anvil models can spawn the gemini-thinker subagent', () => {
+    // Full-access models (non-limited, non-fastest) get the thinker. Kimi is
+    // gone from Anvil entirely, so it no longer qualifies.
+    expect(canAnvilModelSpawnGeminiThinker(ANVIL_KIMI_MODEL_ID)).toBe(
+      false,
+    )
+    expect(
+      canAnvilModelSpawnGeminiThinker(ANVIL_DEEPSEEK_V4_PRO_MODEL_ID),
+    ).toBe(true)
+    // MiMo 2.5 Pro is gone from Anvil, so it no longer qualifies either.
+    expect(
+      canAnvilModelSpawnGeminiThinker(ANVIL_MIMO_V25_PRO_MODEL_ID),
+    ).toBe(false)
+    expect(canAnvilModelSpawnGeminiThinker(MINIMAX_M3_MODEL_ID)).toBe(true)
+    expect(
+      canAnvilModelSpawnGeminiThinker(ANVIL_GPT_5_6_LUNA_MODEL_ID),
+    ).toBe(true)
+
+    // Limited-tier models (DeepSeek V4 Flash, MiMo 2.5) skip it.
+    expect(
+      canAnvilModelSpawnGeminiThinker(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID),
+    ).toBe(false)
+    expect(canAnvilModelSpawnGeminiThinker(ANVIL_MIMO_V25_MODEL_ID)).toBe(
+      false,
+    )
+  })
+
+  test('does not support GLM 5.1 for anvil sessions', () => {
+    const glm = 'z-ai/glm-5.1'
+    expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(glm)
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      glm,
+    )
+    expect(isAnvilModelId(glm)).toBe(false)
+    expect(isSupportedAnvilModelId(glm)).toBe(false)
+  })
+
+  test('surfaces referral-gated GLM 5.2 only in the Web and Cloud picker', () => {
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).toContain(
+      ANVIL_GLM_V52_MODEL_ID,
+    )
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).toContain(
+      ANVIL_GLM_V52_MODEL_ID,
+    )
+    expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_GLM_V52_MODEL_ID,
+    )
+    expect(isAnvilWebPremiumModelId(ANVIL_GLM_V52_MODEL_ID)).toBe(false)
+  })
+
+  test('formats the close time in the user local timezone while deployment is open', () => {
+    expect(
+      getAnvilDeploymentAvailabilityLabel(new Date('2026-01-05T18:00:00Z'), {
+        locale: 'en-US',
+        timeZone: 'America/Los_Angeles',
+      }),
+    ).toBe('until 5:00 PM')
+  })
+
+  test('formats the next open time in the user local timezone while deployment is closed', () => {
+    expect(
+      getAnvilDeploymentAvailabilityLabel(new Date('2026-01-05T12:00:00Z'), {
+        locale: 'en-US',
+        timeZone: 'America/Los_Angeles',
+      }),
+    ).toBe('opens 6:00 AM')
+  })
+
+  test('includes the weekday when the next opening is on a later local day', () => {
+    expect(
+      getAnvilDeploymentAvailabilityLabel(new Date('2026-01-11T03:00:00Z'), {
+        locale: 'en-US',
+        timeZone: 'America/Los_Angeles',
+      }),
+    ).toBe('opens Sun 6:00 AM')
+  })
+
+  test('tracks deployment hours correctly across the open and close boundaries', () => {
+    expect(isAnvilDeploymentHours(new Date('2026-01-05T13:59:00Z'))).toBe(
+      false,
+    )
+    expect(isAnvilDeploymentHours(new Date('2026-01-05T14:00:00Z'))).toBe(
+      true,
+    )
+    expect(isAnvilDeploymentHours(new Date('2026-01-06T00:59:00Z'))).toBe(
+      true,
+    )
+    expect(isAnvilDeploymentHours(new Date('2026-01-06T01:00:00Z'))).toBe(
+      false,
+    )
+    expect(isAnvilDeploymentHours(new Date('2026-01-10T20:00:00Z'))).toBe(
+      true,
+    )
+  })
+})
+
+describe('limited-offer models (Claude Fable 5)', () => {
+  test('is deliberately absent from every client picker catalog', () => {
+    // The whole mechanism rests on this: no client may render Fable from its
+    // own catalog, because only the server knows whether the wave still has
+    // sessions. A client that has never been told about the offer must look
+    // exactly like it does today.
+    expect(ANVIL_MODELS.map((m) => m.id)).not.toContain(
+      ANVIL_FABLE_5_MODEL_ID,
+    )
+    expect(isAnvilModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(false)
+    expect(ANVIL_WEB_ALL_MODELS.map((m) => m.id)).not.toContain(
+      ANVIL_FABLE_5_MODEL_ID,
+    )
+    expect(
+      getAnvilModelsForAccessTier('full').map((m) => m.id),
+    ).not.toContain(ANVIL_FABLE_5_MODEL_ID)
+  })
+
+  test('is still a model the session and chat layers accept', () => {
+    // Same shape as referral GLM: out of the picker catalog, in the supported
+    // catalog, so admission, the chat gate and the display-name lookup all
+    // resolve it.
+    expect(isSupportedAnvilModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(true)
+    expect(
+      isAnvilSessionModelAllowedForAccessTier(
+        ANVIL_FABLE_5_MODEL_ID,
+        'full',
+      ),
+    ).toBe(true)
+    expect(getAnvilModel(ANVIL_FABLE_5_MODEL_ID).displayName).toBe(
+      'Claude Fable 5',
+    )
+  })
+
+  test('an explicit pick survives resolution instead of silently downgrading', () => {
+    // resolveAnvilModelForAccessTier runs on every explicit CLI pick. Before
+    // the offer models were passed through, pressing Enter on the Fable row
+    // would have started a DeepSeek session with no explanation.
+    expect(
+      resolveAnvilModelForAccessTier(ANVIL_FABLE_5_MODEL_ID, 'full'),
+    ).toBe(ANVIL_FABLE_5_MODEL_ID)
+  })
+
+  test('limited-region users cannot reach it', () => {
+    expect(
+      isAnvilSessionModelAllowedForAccessTier(
+        ANVIL_FABLE_5_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(false)
+    expect(
+      resolveAnvilSessionModelForAccessTier(
+        ANVIL_FABLE_5_MODEL_ID,
+        'limited',
+      ),
+    ).toBe(LIMITED_ANVIL_MODEL_ID)
+  })
+
+  test('traces are collected, which is the point of running the wave at all', () => {
+    expect(isAnvilTracedModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(true)
+    const fable = SUPPORTED_ANVIL_MODELS.find(
+      (m) => m.id === ANVIL_FABLE_5_MODEL_ID,
+    )
+    expect((fable as { warning?: string } | undefined)?.warning).toBe(
+      'May use data for AI training',
+    )
+  })
+
+  test('is metered by its own pool, never the shared daily premium one', () => {
+    // It is marked `premium: true` for styling and to keep it out of the free
+    // Standard pool, but joining ANVIL_PREMIUM_MODEL_IDS would put trial
+    // sessions on the quota M3 and DeepSeek Pro share.
+    expect(isAnvilPremiumModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(false)
+    expect(isAnvilWebPremiumModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(false)
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(
+      ANVIL_FABLE_5_MODEL_ID,
+    )
+    expect(isAnvilLimitedOfferModelId(ANVIL_FABLE_5_MODEL_ID)).toBe(true)
+  })
+
+  test('the offer predicate tolerates dated provider snapshots', () => {
+    expect(
+      isAnvilLimitedOfferModelId(`${ANVIL_FABLE_5_MODEL_ID}-20260815`),
+    ).toBe(true)
+    expect(
+      isAnvilLimitedOfferModelId(ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID),
+    ).toBe(false)
+    expect(isAnvilLimitedOfferModelId(null)).toBe(false)
+  })
+})
+
+describe('Meta Muse Spark 1.2 Contributor', () => {
+  test('is a Anvil Web model and reachable from no other surface', () => {
+    // Web-only is enforced by ABSENCE from the CLI/Desktop catalogs, which is
+    // also what makes the session layer refuse it there
+    // (isAnvilSessionModelId reads SUPPORTED_ANVIL_MODELS). The reason is
+    // the queue, not the price: the browser can render a rate-limit wait with
+    // an ETA and the CLI cannot, so on the CLI a 60-RPM team-wide ceiling would
+    // just be unexplained 429s.
+    expect(ANVIL_WEB_MODELS.map((model) => model.id)).toContain(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(SUPPORTED_ANVIL_MODELS.map((model) => model.id)).not.toContain(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    // Absence from SUPPORTED_ is the Desktop gate, not just tidiness:
+    // isModelForHarness('anvil', …) validates against exactly this set, so a
+    // Desktop client asking for Muse Spark is refused before session admission
+    // ever sees it.
+    expect(
+      isSupportedAnvilModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(false)
+    // Session admission DOES accept it — it must, or no Web session could run
+    // on it. The shared gate is the union of the CLI and Web catalogs, so
+    // "Web-only" is enforced by the catalogs above plus the free-mode agent
+    // allowlist (only base2-free-muse-spark may run this model, and only the
+    // Web bundle ships that root), never by this predicate.
+    expect(
+      isAnvilSessionModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(true)
+
+    // Visible to every full-access Web user, not god-gated and not retired.
+    expect(
+      isAnvilWebModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(true)
+    expect(
+      isAnvilWebGodOnlyModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(false)
+    expect(
+      isAnvilWebSelectableModelId(
+        ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+      ),
+    ).toBe(true)
+  })
+
+  test('is metered by the Web premium pool and no other', () => {
+    // Premium here bounds how many users are inside the 60 RPM ceiling at once
+    // — it is NOT a price signal, since Contributor is cheaper per token than
+    // the standard-pool models. Being in some pool is mandatory:
+    // ANVIL_WEB_STANDARD_MODEL_IDS is derived by filtering `!premium`, so a
+    // premium model missing from the premium list is metered by nothing.
+    expect(
+      isAnvilWebPremiumModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(true)
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(
+      isAnvilGlmV52ModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(false)
+    // The CLI's own premium pool must not learn about a model the CLI cannot
+    // select.
+    expect(
+      isAnvilPremiumModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(false)
+  })
+
+  test('carries a reasoning effort that the server can actually resolve', () => {
+    // Two halves, and the second is the one that used to silently fail.
+    // getAnvilModelReasoningEffort read SUPPORTED_ANVIL_MODELS alone —
+    // the CLI/Desktop catalog — which Muse Spark is deliberately absent from
+    // (that absence IS the Desktop gate). So the field could be set on the row
+    // and resolve to null anyway, with nothing to indicate why.
+    const model = getAnvilWebModel(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(model.reasoningEffort).toBe(ANVIL_MUSE_SPARK_REASONING_EFFORT)
+    expect(
+      getAnvilModelReasoningEffort(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(ANVIL_MUSE_SPARK_REASONING_EFFORT)
+
+    // Never 'none': Muse Spark answers that with a hard 400 (verified live),
+    // and a 400 is neither retried nor queued, so it kills the turn outright.
+    expect(ANVIL_MUSE_SPARK_REASONING_EFFORT).not.toBe('none')
+    // Meta's ladder, from its own 400 on an unknown value. `xhigh` and
+    // `minimal` exist here and nowhere else in this repo, which is why the
+    // shared agent-definition enum deliberately does not carry them.
+    expect(['minimal', 'low', 'medium', 'high', 'xhigh']).toContain(
+      ANVIL_MUSE_SPARK_REASONING_EFFORT,
+    )
+
+    // Suffix-tolerant like every other id helper, so a dated provider snapshot
+    // does not silently drop back to Meta's default effort.
+    expect(
+      getAnvilModelReasoningEffort(
+        `${ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID}-20260901`,
+      ),
+    ).toBe(ANVIL_MUSE_SPARK_REASONING_EFFORT)
+
+    // Widening the lookup to the Web catalog must not invent an effort for
+    // models that declare none.
+    expect(
+      getAnvilModelReasoningEffort(ANVIL_KIMI_K3_ECO_MODEL_ID),
+    ).toBeNull()
+  })
+
+  test('discloses the Contributor tier training terms', () => {
+    // The discount IS the training grant, so the warning is the disclosure that
+    // makes the row legitimate rather than decoration.
+    const model = getAnvilWebModel(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(model.displayName).toBe('Muse Spark 1.2')
+    expect(model.dataUse).toBe('training')
+    expect(model.warning).toBe('May use data for AI training')
+  })
+
+  test('has exactly one wire id, and the predicate tolerates dated snapshots', () => {
+    // The queue, the premium pool and the free-mode agent allowlist all key off
+    // this id. A second id reaching the same upstream is how `crof/glm-5.2`
+    // handed out a metered model for free; do not add one.
+    expect(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID).toBe(
+      'meta/muse-spark-1.2-contributor',
+    )
+    // Meta's own id is what the provider receives, never a wire id a caller
+    // may send. Widened to string[] on purpose: the union type already proves
+    // this at compile time, and the runtime check is what survives someone
+    // later adding the bare id to a catalog.
+    expect(
+      ANVIL_WEB_ALL_MODELS.map((model): string => model.id),
+    ).not.toContain(MUSE_SPARK_12_CONTRIBUTOR_UPSTREAM_MODEL_ID)
+
+    expect(
+      isMuseSparkModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(true)
+    // A dated provider snapshot must not slip past the rate-limit queue.
+    expect(
+      isMuseSparkModelId(
+        `${ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID}-20260901`,
+      ),
+    ).toBe(true)
+    expect(isMuseSparkModelId('meta/muse-spark-1.2')).toBe(false)
+    expect(isMuseSparkModelId(null)).toBe(false)
+  })
+})
+
+describe('Muse Spark rate-limit fallback', () => {
+  test('reroutes only to a model the caller is already entitled to', () => {
+    // THE invariant. A fallback outside the shared daily premium pool would
+    // turn "Muse Spark is busy" into a way to reach a model the user had not
+    // earned — the same shape as the retired crof/glm-5.2 route, which handed
+    // out a referral-earned model for nothing. The fallback sits in the same
+    // pool, so a rerouted request spends exactly the entitlement the original
+    // would.
+    expect(isAnvilWebPremiumModelId(MUSE_SPARK_FALLBACK_MODEL_ID)).toBe(true)
+    expect(
+      isAnvilWebPremiumModelId(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID),
+    ).toBe(true)
+    // Never the earned-GLM pool, and never the free standard pool.
+    expect(isAnvilGlmV52ModelId(MUSE_SPARK_FALLBACK_MODEL_ID)).toBe(false)
+    expect(ANVIL_WEB_STANDARD_MODEL_IDS).not.toContain(
+      MUSE_SPARK_FALLBACK_MODEL_ID,
+    )
+    // And it must be a real, selectable Web model rather than a dangling id.
+    expect(isAnvilWebModelId(MUSE_SPARK_FALLBACK_MODEL_ID)).toBe(true)
+    expect(MUSE_SPARK_FALLBACK_MODEL_ID).not.toBe(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+  })
+
+  test('the picker promises exactly what the server does', () => {
+    // The tooltip is a promise about behavior; drift between the two is how a
+    // UI starts lying. Both read the same constant, and the threshold the copy
+    // implies ("too long") is the one the server actually applies.
+    const model = getAnvilWebModel(
+      ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+    )
+    expect(model.tagline).toBe('Queue')
+    expect(model.taglineTooltip).toBe(MUSE_SPARK_FALLBACK_NOTICE)
+    // The copy must NAME the model the server actually reroutes to — pinning it
+    // to the catalog rather than to a literal is what catches a fallback that
+    // moves (as it did on 2026-08-12, Luna → V4 Pro) while its tooltip does not.
+    // Matched undated: this tooltip promises a behavior rather than pointing at
+    // a picker row, so it does not carry a build date the way the supersedes
+    // notices do.
+    expect(MUSE_SPARK_FALLBACK_NOTICE).toContain(
+      getAnvilWebModel(MUSE_SPARK_FALLBACK_MODEL_ID).displayName.replace(
+        /\s+\d{2}\/\d{2}$/,
+        '',
+      ),
+    )
+    // The row no longer advertises itself as new.
+    expect(model.isNew).toBeUndefined()
+    // A wait worth explaining, not one worth hiding — and the same number the
+    // provider uses for its silent window, so the two cannot disagree about
+    // what "too long" means.
+    expect(MUSE_SPARK_FALLBACK_AFTER_MS).toBe(10_000)
+  })
+})