@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/harness-runtime/model-catalog-seed.test.mjs

@@ -1,829 +0,0 @@
-// Tests for the team seed (model-catalog.md rule 7): seed read path, alias
-// resolution, precedence, the read-only guarantee, and the rule-3
-// never-proposes-an-undiscovered-model property. Separate file from
-// model-catalog.test.mjs (which covers the per-user banked catalog) because
-// the seed is a distinct, read-only artifact with its own invariants.
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { spawnSync } from 'node:child_process'
-
-import {
-  readSeed, findSeedEntry, seedTiersFor, seedTierAt, seedProposals,
-  resolveModelTiers, tierProposals, entryFromSeedConfirmation, defaultSeedPath,
-  readCatalog, writeCatalog, EFFORTS, TIERS, SLOT_ELIGIBLE_TIERS,
-  crossHarnessProposals, plainlyMatches, operatingPoints, CLASSIFY_STALE_AFTER_DAYS,
-} from './model-catalog.mjs'
-
-const SCRIPT = fileURLToPath(new URL('./bin/model-catalog.mjs', import.meta.url))
-const tmpFile = (name = 'seed.json') => path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'model-catalog-seed-test-')), name)
-
-function run(args, input) {
-  return spawnSync('node', [SCRIPT, ...args], { encoding: 'utf8', input })
-}
-
-// A small fixture mirroring the shipped seed's shape: two models that AGREE
-// across harnesses, and one seeded from a single harness only.
-const FIXTURE_SEED = {
-  seededAt: '2026-07-20',
-  models: [
-    {
-      canonical: 'gpt-5.6-sol',
-      family: 'openai',
-      ids: { 'claude-code': 'gpt-5.6-sol', pi: 'openai/gpt-5.6-sol' },
-      tiers: { 'claude-code': { high: 'frontier' }, pi: { high: 'frontier' } },
-      note: 'agrees everywhere',
-    },
-    {
-      canonical: 'kimi-k2.7-code',
-      family: 'moonshot',
-      ids: { 'claude-code': 'kimi-k2.7-code', pi: 'kimi-coding/kimi-for-coding' },
-      tiers: { 'claude-code': { high: 'scoped-coder' }, pi: { high: 'scoped-coder' } },
-      note: 'agrees everywhere',
-    },
-    {
-      canonical: 'opus',
-      family: 'anthropic',
-      ids: { 'claude-code': 'opus' },
-      tiers: { 'claude-code': { high: 'deep-reasoner' } },
-      note: 'claude-code only',
-    },
-  ],
-}
-
-// ---- seed read path ----
-
-test('readSeed returns null for an absent file (absent is normal, same contract as readCatalog)', () => {
-  assert.equal(readSeed(tmpFile()), null)
-})
-
-test('readSeed parses the seed JSON', () => {
-  const file = tmpFile()
-  fs.writeFileSync(file, JSON.stringify(FIXTURE_SEED))
-  assert.deepEqual(readSeed(file), FIXTURE_SEED)
-})
-
-// @covers package:harness-runtime
-// @level integration
-test('defaultSeedPath resolves to the shipped references/model-catalog-seed.json, and it parses', () => {
-  const p = defaultSeedPath()
-  assert.ok(p.endsWith(path.join('references', 'model-catalog-seed.json')))
-  const seed = readSeed(p)
-  assert.ok(seed, 'the shipped seed must exist and parse')
-  assert.ok(seed.seededAt)
-  assert.ok(Array.isArray(seed.models) && seed.models.length > 0)
-})
-
-test('the shipped seed keeps gpt-5.6-sol frontier at its measured high point only', () => {
-  const seed = readSeed(defaultSeedPath())
-  const sol = seed.models.find((m) => m.canonical === 'gpt-5.6-sol')
-  assert.ok(sol, 'seed must carry gpt-5.6-sol')
-
-  for (const [harness, id] of Object.entries({
-    'claude-code': 'gpt-5.6-sol',
-    codex: 'gpt-5.6-sol',
-    pi: 'openai/gpt-5.6-sol',
-  })) {
-    assert.deepEqual(sol.tiers[harness], { high: 'frontier' }, `gpt-5.6-sol@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals.map((p) => p.id), [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'frontier', slotEligible: true }])
-  }
-})
-
-test('the shipped seed banks gpt-6-astra at its measured high point only', () => {
-  const seed = readSeed(defaultSeedPath())
-  const astra = seed.models.find((m) => m.canonical === 'gpt-6-astra')
-  assert.ok(astra, 'seed must carry the canonical gpt-6-astra id')
-  assert.ok(!seed.models.some((m) => m.canonical === 'gpt-6-astro'), 'the astro typo must not become an alias')
-
-  for (const [harness, id] of Object.entries({
-    'claude-code': 'gpt-6-astra',
-    codex: 'gpt-6-astra',
-    pi: 'openai/gpt-6-astra',
-  })) {
-    assert.equal(astra.ids[harness], id, `gpt-6-astra@${harness} id`)
-    assert.deepEqual(astra.tiers[harness], { high: 'frontier' }, `gpt-6-astra@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'frontier', slotEligible: true }])
-  }
-})
-
-test('the shipped seed banks gpt-6-sol as deep-reasoner at its vendor-measured high point only', () => {
-  const seed = readSeed(defaultSeedPath())
-  const sol6 = seed.models.find((m) => m.canonical === 'gpt-6-sol')
-  assert.ok(sol6, 'seed must carry gpt-6-sol')
-  // 65.3 @high from OpenAI's 2026-09-22 launch chart lands in the deep-reasoner band with
-  // gpt-5.5 (64.4±3.1) and grok-4.6 (65.2±1.5); its xhigh/max points are not banked, and it
-  // does not inherit gpt-5.6-sol's frontier seat (68.8 vs 72.7 at max).
-  for (const [harness, id] of Object.entries({ 'claude-code': 'gpt-6-sol', codex: 'gpt-6-sol', pi: 'openai/gpt-6-sol' })) {
-    assert.equal(sol6.ids[harness], id, `gpt-6-sol@${harness} id`)
-    assert.deepEqual(sol6.tiers[harness], { high: 'deep-reasoner' }, `gpt-6-sol@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'deep-reasoner', slotEligible: true }])
-  }
-  const sol56 = seed.models.find((m) => m.canonical === 'gpt-5.6-sol')
-  assert.deepEqual(sol56.tiers.pi, { high: 'frontier' }, 'gpt-5.6-sol keeps its frontier seat')
-})
-
-test('the shipped seed banks gpt-6.1-sol as frontier at its vendor-measured high point only', () => {
-  const seed = readSeed(defaultSeedPath())
-  const sol61 = seed.models.find((m) => m.canonical === 'gpt-6.1-sol')
-  assert.ok(sol61, 'seed must carry gpt-6.1-sol')
-  // 75.2 @high from OpenAI's 2026-09-29 launch lands in the frontier band with gpt-6-astra
-  // (73.2±3.4) and gpt-5.6-sol (69.4±1.4); its medium point (73) is the explorer's policy
-  // point, not banked.
-  for (const [harness, id] of Object.entries({ 'claude-code': 'gpt-6.1-sol', codex: 'gpt-6.1-sol', pi: 'openai/gpt-6.1-sol' })) {
-    assert.equal(sol61.ids[harness], id, `gpt-6.1-sol@${harness} id`)
-    assert.deepEqual(sol61.tiers[harness], { high: 'frontier' }, `gpt-6.1-sol@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'frontier', slotEligible: true }])
-  }
-})
-
-test('the shipped seed banks gpt-6-luna at max (measured) and at high (human classification)', () => {
-  const seed = readSeed(defaultSeedPath())
-  const luna6 = seed.models.find((m) => m.canonical === 'gpt-6-luna')
-  assert.ok(luna6, 'seed must carry gpt-6-luna')
-  // OpenAI published low/medium/max only (66.6 @max); rule 6 forbids reading max down to high, so the
-  // high point is a 2026-09-23 human classification (the rush routine ladder runs Luna at high because
-  // max is too slow). Both points are balanced-coder; the note says which one is measured.
-  for (const [harness, id] of Object.entries({ 'claude-code': 'gpt-6-luna', codex: 'gpt-6-luna', pi: 'openai/gpt-6-luna' })) {
-    assert.equal(luna6.ids[harness], id, `gpt-6-luna@${harness} id`)
-    assert.deepEqual(luna6.tiers[harness], { high: 'balanced-coder', max: 'balanced-coder' }, `gpt-6-luna@${harness}`)
-  }
-  assert.match(luna6.note, /HUMAN CLASSIFICATION/, 'the note must say the high point is not benchmark-backed')
-})
-
-// ---- alias resolution (both directions: id -> entry, entry -> per-harness tier) ----
-
-test('findSeedEntry resolves a harness-specific alias id to the shared canonical entry', () => {
-  // The confirmed alias (issue #370): kimi-k2.7-code (claude-code) = kimi-coding/kimi-for-coding (pi).
-  const viaClaudeCode = findSeedEntry(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code')
-  const viaPi = findSeedEntry(FIXTURE_SEED, 'pi', 'kimi-coding/kimi-for-coding')
-  assert.equal(viaClaudeCode.canonical, 'kimi-k2.7-code')
-  assert.equal(viaPi.canonical, 'kimi-k2.7-code')
-  assert.equal(viaClaudeCode, viaPi) // same entry object, reached from either harness's id
-})
-
-test('findSeedEntry returns null for an id the seed does not know, or a harness the entry does not cover', () => {
-  assert.equal(findSeedEntry(FIXTURE_SEED, 'claude-code', 'no-such-model'), null)
-  assert.equal(findSeedEntry(FIXTURE_SEED, 'codex', 'kimi-k2.7-code'), null) // no codex id on this entry
-})
-
-test('a plainly-normalizable id that was NOT given a confirmed alias does not resolve — no guessing', () => {
-  // kimi-k3 (claude-code) vs kimi-coding/k3 (pi) do not plainly normalize (stripping
-  // "kimi-coding/" gives "k3", not "kimi-k3") and were never confirmed as a pair
-  // (issue #370) — the seed keeps them as two separate entries, so a lookup for
-  // one harness's id must never resolve to the other harness's entry.
-  const seed = {
-    seededAt: '2026-07-20',
-    models: [
-      { canonical: 'kimi-k3', family: 'moonshot', ids: { 'claude-code': 'kimi-k3' }, tiers: { 'claude-code': { max: 'frontier' } } },
-      { canonical: 'kimi-coding/k3', family: 'moonshot', ids: { pi: 'kimi-coding/k3' }, tiers: { pi: { high: 'deep-reasoner' } } },
-    ],
-  }
-  assert.equal(findSeedEntry(seed, 'pi', 'kimi-k3'), null)
-  assert.equal(findSeedEntry(seed, 'claude-code', 'kimi-coding/k3'), null)
-})
-
-// ---- per-harness tiers stay PER-HARNESS, never collapsed ----
-
-test('seedTiersFor/seedTierAt resolve the tier for the RIGHT harness', () => {
-  assert.deepEqual(seedTiersFor(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code'), { high: 'scoped-coder' })
-  assert.deepEqual(seedTiersFor(FIXTURE_SEED, 'pi', 'kimi-coding/kimi-for-coding'), { high: 'scoped-coder' })
-  assert.equal(seedTierAt(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code', 'high'), 'scoped-coder')
-  assert.equal(seedTierAt(FIXTURE_SEED, 'pi', 'kimi-coding/kimi-for-coding', 'high'), 'scoped-coder')
-})
-
-test('seedTierAt returns null for an effort the entry does not cover, or a harness it was not seeded from', () => {
-  assert.equal(seedTierAt(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code', 'max'), null)
-  assert.equal(seedTierAt(FIXTURE_SEED, 'codex', 'opus', 'high'), null) // opus is claude-code only
-})
-
-test('the shipped seed keeps its remaining per-harness disagreements (not collapsed)', () => {
-  const seed = readSeed(defaultSeedPath())
-  // Zero shared models now disagree per harness. deepseek-v4-pro was the last
-  // (claude-code high:scoped-coder vs pi high:balanced-coder) and left on
-  // 2026-08-13 when 0813 GA collapsed it to an agreeing max:deep-reasoner point.
-  // Pinned so a silent drift back into disagreement has to be deliberate.
-  const shared = seed.models.filter((m) => Object.keys(m.tiers || {}).length > 1)
-  for (const entry of shared) {
-    const maps = Object.values(entry.tiers)
-    assert.ok(maps.every((t) => JSON.stringify(t) === JSON.stringify(maps[0])), `${entry.canonical} must agree across harnesses`)
-  }
-  const pro = seed.models.find((m) => m.canonical === 'deepseek-v4-pro')
-  assert.ok(pro, 'seed must carry deepseek-v4-pro')
-  for (const harness of ['claude-code', 'pi']) {
-    assert.deepEqual(pro.tiers[harness], { max: 'deep-reasoner' }, `deepseek-v4-pro@${harness}`)
-  }
-  // grok-4.5 left this set on 2026-07-22 (pi demoted deep-reasoner -> balanced-coder);
-  // pinned so a re-promotion has to be a deliberate edit, not a silent drift back.
-  const grok = seed.models.find((m) => m.canonical === 'grok-4.5')
-  assert.equal(grok.tiers['claude-code'].high, 'balanced-coder')
-  assert.equal(grok.tiers.pi.high, 'balanced-coder')
-
-  // grok-4.6 added 2026-08-13 from vendor DeepSWE v1.1 @high 65.9. Separate entry,
-  // not a reband of 4.5. Pinned so a silent collapse into 4.5 or a drop to
-  // balanced-coder has to be deliberate.
-  const grok46 = seed.models.find((m) => m.canonical === 'grok-4.6')
-  assert.ok(grok46, 'seed must carry grok-4.6')
-  for (const harness of ['claude-code', 'pi']) {
-    assert.deepEqual(grok46.tiers[harness], { high: 'deep-reasoner' }, `grok-4.6@${harness}`)
-  }
-
-  // grok-4.7 added 2026-09-23 from SpaceXAI's launch chart: vendor DeepSWE v1.1 71.0 @high
-  // (asterisked "high effort"), not yet on the official board. Above gpt-5.6-sol's official
-  // 69.4±1.4 high point and inside gpt-6-astra's 73.2±3.4, so frontier at high; a separate
-  // entry that does not re-tier grok-4.6. Pinned so a silent drop to deep-reasoner or a
-  // score-chasing xhigh point has to be a deliberate edit when Datacurve publishes the run.
-  const grok47 = seed.models.find((m) => m.canonical === 'grok-4.7')
-  assert.ok(grok47, 'seed must carry grok-4.7')
-  assert.equal(grok47.family, 'xai')
-  for (const [harness, id] of Object.entries({ 'claude-code': 'grok-4.7', pi: 'xai/grok-4.7' })) {
-    assert.equal(grok47.ids[harness], id, `grok-4.7@${harness} id`)
-    assert.deepEqual(grok47.tiers[harness], { high: 'frontier' }, `grok-4.7@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'frontier', slotEligible: true }])
-  }
-  assert.ok(!grok47.ids.codex, 'codex holds no grok entry')
-  assert.deepEqual(grok46.tiers.pi, { high: 'deep-reasoner' }, 'grok-4.7 does not re-tier grok-4.6')
-
-  // deepseek-flash moved 2026-08-13 from high:balanced-coder to max:balanced-coder.
-  // The 55.4 figure previously cited as @high is the vendor max point (official board:
-  // [max] 53%±4). Pinned so a silent restore of the high point has to be deliberate.
-  const flash = seed.models.find((m) => m.canonical === 'deepseek-flash')
-  assert.ok(flash, 'seed must carry deepseek-flash')
-  for (const harness of ['claude-code', 'codex', 'pi']) {
-    assert.deepEqual(flash.tiers[harness], { max: 'balanced-coder' }, `deepseek-flash@${harness}`)
-  }
-
-  // DeepSWE measured luna at high (44.2%±2.9), so its higher-effort results are not
-  // banked. Pinned so a score-chasing xhigh/max point cannot quietly return.
-  // mimo-v2.5-pro left this set on 2026-08-02: pi downgraded balanced-coder -> scoped-coder,
-  // so both its harnesses now agree. Pinned like grok-4.5 and luna, because it was this file's
-  // worked example of a harness disagreement and a silent drift back would be easy to miss.
-  const mimo = seed.models.find((m) => m.canonical === 'mimo-v2.5-pro')
-  for (const harness of ['claude-code', 'pi']) {
-    assert.deepEqual(mimo.tiers[harness], { high: 'scoped-coder' }, `mimo-v2.5-pro@${harness}`)
-  }
-
-  // mimo-v2.6-pro added 2026-09-23 from Xiaomi's release table: vendor DeepSWE v1.1 71.9
-  // (own run of the public harness), not on the official board. Above gpt-5.6-sol's official
-  // 69.4±1.4 high point and inside gpt-6-astra's 73.2±3.4, so frontier at high — `high` being
-  // the label for the model's single thinking-on point (the API has no graded efforts). A
-  // separate entry that does not re-tier mimo-v2.5-pro. Pinned so a silent drop to
-  // deep-reasoner, or a collapse into 2.5-pro, has to be a deliberate edit.
-  const mimo26 = seed.models.find((m) => m.canonical === 'mimo-v2.6-pro')
-  assert.ok(mimo26, 'seed must carry mimo-v2.6-pro')
-  assert.equal(mimo26.family, 'xiaomi')
-  for (const [harness, id] of Object.entries({ 'claude-code': 'mimo-v2.6-pro', pi: 'xiaomi/mimo-v2.6-pro' })) {
-    assert.equal(mimo26.ids[harness], id, `mimo-v2.6-pro@${harness} id`)
-    assert.deepEqual(mimo26.tiers[harness], { high: 'frontier' }, `mimo-v2.6-pro@${harness}`)
-    const { proposals } = seedProposals(seed, harness, [id])
-    assert.deepEqual(proposals[0].points, [{ effort: 'high', tier: 'frontier', slotEligible: true }])
-  }
-  assert.ok(!mimo26.ids.codex, 'codex holds no MiMo entry')
-  assert.deepEqual(mimo.tiers.pi, { high: 'scoped-coder' }, 'mimo-v2.6-pro does not re-tier mimo-v2.5-pro')
-
-  const luna = seed.models.find((m) => m.canonical === 'gpt-5.6-luna')
-  for (const harness of ['claude-code', 'codex', 'pi']) {
-    assert.deepEqual(
-      luna.tiers[harness],
-      { high: 'scoped-coder' },
-      `gpt-5.6-luna@${harness}`,
-    )
-  }
-
-  // Opus 4.8's 51.8%±4.6 high point overlaps the balanced-coder reference band;
-  // its separate max result must not promote the default operating point.
-  const opus = seed.models.find((m) => m.canonical === 'opus')
-  assert.deepEqual(opus.tiers['claude-code'], { high: 'balanced-coder' })
-})
-
-// ---- rule 3, mechanized: never proposes a model this run's discovery didn't yield ----
-
-test('seedProposals only proposes ids present in discoveredIds — the seed carrying an id is not enough', () => {
-  const { proposals } = seedProposals(FIXTURE_SEED, 'claude-code', ['gpt-5.6-sol']) // opus, kimi-k2.7-code NOT discovered
-  assert.deepEqual(proposals.map((p) => p.id), ['gpt-5.6-sol'])
-})
-
-test('seedProposals with an EMPTY discovery set proposes nothing, however much the seed covers', () => {
-  assert.deepEqual(seedProposals(FIXTURE_SEED, 'claude-code', []).proposals, [])
-})
-
-test('seedProposals never proposes an id under the WRONG harness even if discovered there', () => {
-  // pi's discovery of "kimi-coding/kimi-for-coding" must not surface the claude-code
-  // id "kimi-k2.7-code", and vice versa — availability is per-harness (rule 3).
-  const { proposals } = seedProposals(FIXTURE_SEED, 'claude-code', ['kimi-coding/kimi-for-coding'])
-  assert.deepEqual(proposals, [])
-})
-
-test('seedProposals skips an entry that has no tiers for the queried harness even if the id somehow matched', () => {
-  const seed = { seededAt: '2026-07-20', models: [{ canonical: 'x', family: 'f', ids: { 'claude-code': 'x' }, tiers: {} }] }
-  assert.deepEqual(seedProposals(seed, 'claude-code', ['x']).proposals, [])
-})
-
-test('CLI seed-proposals: an undiscovered id never appears in the output', () => {
-  const seedFile = tmpFile()
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const res = run(['seed-proposals', '--seed-file', seedFile, '--harness', 'claude-code', '--seen', 'opus,definitely-not-real', '--file', tmpFile('catalog.json')])
-  assert.equal(res.status, 0)
-  const { proposals } = JSON.parse(res.stdout)
-  assert.deepEqual(proposals.map((p) => p.id), ['opus'])
-  assert.equal(proposals[0].citation, 'tier from team seed: opus')
-})
-
-// ---- rule 7 precedence, mechanized: a banked entry suppresses the seed PER MODEL ----
-
-test('seedProposals: a model already banked in this harness gets NO seed proposal — the catalog outranks the seed', () => {
-  const catalog = { harness: 'claude-code', models: [{ id: 'opus', family: 'anthropic', tiers: { high: 'frontier' } }] }
-  const { proposals, suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus', 'gpt-5.6-sol'], catalog)
-  assert.deepEqual(proposals.map((p) => p.id), ['gpt-5.6-sol'])
-  assert.deepEqual(suppressed.map((s) => s.id), ['opus'])
-})
-
-test('seedProposals: a DELETED operating point is not restored from the seed — suppression is per model, never per effort', () => {
-  // The terra regression: the human banked {high} after deciding the max point
-  // wasn't real. A per-effort merge would see no banked tier at `max`, read the
-  // deletion as silence, and hand `max: deep-reasoner` back every run.
-  const seed = {
-    seededAt: '2026-07-20',
-    models: [{
-      canonical: 'terra',
-      family: 'openai',
-      ids: { pi: 'openai/terra' },
-      tiers: { pi: { high: 'balanced-coder', max: 'deep-reasoner' } },
-    }],
-  }
-  const catalog = { harness: 'pi', models: [{ id: 'openai/terra', family: 'openai', tiers: { high: 'balanced-coder' } }] }
-  const { proposals, suppressed } = seedProposals(seed, 'pi', ['openai/terra'], catalog)
-
-  assert.deepEqual(proposals, [], 'no proposal at all for a banked model')
-  assert.equal(suppressed[0].disagrees, true, 'the seed claiming a point the human dropped is a disagreement')
-  assert.deepEqual(suppressed[0].banked, { high: 'balanced-coder' })
-  assert.deepEqual(suppressed[0].seed, { high: 'balanced-coder', max: 'deep-reasoner' })
-})
-
-test('seedProposals: suppression where seed and catalog AGREE is not flagged as a disagreement', () => {
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', tiers: { high: 'deep-reasoner' } }] }
-  const { suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.equal(suppressed[0].disagrees, false)
-})
-
-test('seedProposals: an entry banked with NO operating points does not suppress the seed pre-fill', () => {
-  // tiers:{} passes a truthiness guard but classifies nothing — check the points.
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', tiers: {} }] }
-  const { proposals } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.deepEqual(proposals.map((p) => p.id), ['opus'])
-})
-
-test('seedProposals: a legacy single-point {tier} entry still suppresses (banked is read through toTiers)', () => {
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', tier: 'prior-frontier' }] }
-  const { proposals, suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.deepEqual(proposals, [])
-  assert.deepEqual(suppressed[0].banked, { high: 'deep-reasoner' }) // legacy name normalized
-})
-
-test('seedProposals with NO catalog argument still proposes — an absent catalog suppresses nothing', () => {
-  const { proposals, suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'])
-  assert.deepEqual(proposals.map((p) => p.id), ['opus'])
-  assert.deepEqual(suppressed, [])
-})
-
-// ---- build 1: date-aware disagreement (seedNewer) — the grok-4.5 class ----
-// FIXTURE_SEED.seededAt is 2026-07-20; seed says opus=deep-reasoner.
-test('seedProposals: a disagreement where the seed is NEWER than the banked confirmation sets seedNewer', () => {
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', confirmedAt: '2026-07-19', tiers: { high: 'balanced-coder' } }] }
-  const { suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.equal(suppressed[0].disagrees, true)
-  assert.equal(suppressed[0].seedNewer, true, 'seed seededAt 07-20 is newer than banked confirmedAt 07-19')
-  assert.equal(suppressed[0].seededAt, '2026-07-20')
-  assert.equal(suppressed[0].bankedConfirmedAt, '2026-07-19')
-})
-
-test('seedProposals: seedNewer is false when the banked confirmation is at or after the seed date', () => {
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', confirmedAt: '2026-07-25', tiers: { high: 'balanced-coder' } }] }
-  const { suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.equal(suppressed[0].disagrees, true)
-  assert.equal(suppressed[0].seedNewer, false, 'a banked confirmation after the seed date is not overruled')
-})
-
-test('seedProposals: seedNewer is false when seed and banked AGREE, however old the banked entry', () => {
-  const catalog = { models: [{ id: 'opus', family: 'anthropic', confirmedAt: '2020-01-01', tiers: { high: 'deep-reasoner' } }] }
-  const { suppressed } = seedProposals(FIXTURE_SEED, 'claude-code', ['opus'], catalog)
-  assert.equal(suppressed[0].disagrees, false)
-  assert.equal(suppressed[0].seedNewer, false)
-})
-
-test('CLI seed-proposals escalates the citation to RE-CONFIRM when the seed is newer than the banked entry', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED)) // seededAt 2026-07-20, opus=deep-reasoner
-  const catalogFile = tmpFile('catalog.json')
-  writeCatalog(catalogFile, { harness: 'claude-code', models: [{ id: 'opus', family: 'anthropic', confirmedAt: '2026-07-19', tiers: { high: 'balanced-coder' } }] })
-  const res = run(['seed-proposals', '--seed-file', seedFile, '--file', catalogFile, '--harness', 'claude-code', '--seen', 'opus'])
-  assert.equal(res.status, 0)
-  const { suppressed } = JSON.parse(res.stdout)
-  assert.match(suppressed[0].citation, /NEWER than your banked opus/)
-  assert.match(suppressed[0].citation, /RE-CONFIRM/)
-  assert.doesNotMatch(suppressed[0].citation, /Refresh the seed if yours is the better answer/, 'the stale-banked case must not print the default catalog-wins nudge')
-})
-
-test('CLI seed-proposals reads the harness catalog itself and reports the disagreement in the citation', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const catalogFile = tmpFile('catalog.json')
-  writeCatalog(catalogFile, { harness: 'claude-code', models: [{ id: 'opus', family: 'anthropic', tiers: { high: 'balanced-coder' } }] })
-
-  const res = run(['seed-proposals', '--seed-file', seedFile, '--file', catalogFile, '--harness', 'claude-code', '--seen', 'opus'])
-  assert.equal(res.status, 0)
-  const { proposals, suppressed } = JSON.parse(res.stdout)
-  assert.deepEqual(proposals, [])
-  assert.match(suppressed[0].citation, /team seed disagrees with your banked opus/)
-  assert.match(suppressed[0].citation, /your catalog wins/)
-})
-
-// ---- the shipped seed's own invariants ----
-
-test('the shipped seed is internally well-formed: known efforts and tiers, ids covering every tiered harness', () => {
-  const seed = readSeed(defaultSeedPath())
-  for (const entry of seed.models) {
-    assert.ok(entry.canonical, 'every entry needs a canonical name')
-    assert.ok(entry.family, `${entry.canonical}: family is required`)
-    assert.ok(entry.ids && Object.keys(entry.ids).length, `${entry.canonical}: ids map is required`)
-    for (const [harness, tiers] of Object.entries(entry.tiers || {})) {
-      assert.ok(entry.ids[harness], `${entry.canonical}: tiers for "${harness}" with no id under that harness`)
-      assert.ok(Object.keys(tiers).length, `${entry.canonical}: empty tiers for "${harness}" says nothing`)
-      for (const [effort, tier] of Object.entries(tiers)) {
-        assert.ok(EFFORTS.includes(effort), `${entry.canonical}@${harness}: effort "${effort}" not in ${EFFORTS.join('|')}`)
-        assert.ok(TIERS.includes(tier), `${entry.canonical}@${harness}: tier "${tier}" not in ${TIERS.join('|')}`)
-      }
-    }
-  }
-})
-
-test('the shipped seed never maps one harness id to two entries — an ambiguous alias would make lookup order-dependent', () => {
-  const seed = readSeed(defaultSeedPath())
-  const seen = new Map()
-  for (const entry of seed.models) {
-    for (const [harness, id] of Object.entries(entry.ids || {})) {
-      const key = `${harness}\u0000${id}`
-      assert.equal(seen.get(key), undefined, `${harness}:${id} is claimed by both "${seen.get(key)}" and "${entry.canonical}"`)
-      seen.set(key, entry.canonical)
-    }
-  }
-})
-
-test('CLI seed: exits 3 with a clear message when the seed file is absent', () => {
-  const res = run(['seed', '--seed-file', tmpFile()])
-  assert.equal(res.status, 3)
-  assert.match(res.stderr, /no seed at/)
-})
-
-test('CLI seed: prints the shipped seed by default (no --seed-file needed)', () => {
-  const res = run(['seed'])
-  assert.equal(res.status, 0)
-  const seed = JSON.parse(res.stdout)
-  assert.ok(seed.seededAt)
-  assert.ok(seed.models.length >= 16) // issue #370 shipped 15; grok-4.6 added 2026-08-13
-})
-
-// ---- precedence: own banked entry -> cross-harness -> team seed -> discovery -> unconfirmed ----
-//
-// resolveTierPrecedence (scalar tier per source, resolved per model+effort) was
-// replaced by resolveModelTiers (whole tiers maps, resolved per MODEL) on
-// 2026-07-20. Its five tests went with it: they proved the old shape computed
-// correctly, which was never in doubt — nothing called it, and its signature
-// invited exactly the per-effort merge its own comment forbade.
-
-test('resolveModelTiers: a banked entry wins over everything, including the seed', () => {
-  const r = resolveModelTiers({
-    banked: { high: 'frontier' },
-    crossHarness: { tiers: { high: 'balanced-coder' }, citation: 'x' },
-    seed: { tiers: { high: 'scoped-coder' }, citation: 'y' },
-    discoveryTiers: { high: 'deep-reasoner' },
-  })
-  assert.deepEqual(r.tiers, { high: 'frontier' })
-  assert.equal(r.source, 'banked')
-})
-
-test('resolveModelTiers: cross-harness (rule 5) beats the team seed, and carries its citation', () => {
-  const r = resolveModelTiers({
-    crossHarness: { tiers: { high: 'balanced-coder' }, citation: 'tier from codex catalog: x' },
-    seed: { tiers: { high: 'scoped-coder' }, citation: 'tier from team seed: x' },
-  })
-  assert.equal(r.source, 'cross-harness')
-  assert.equal(r.citation, 'tier from codex catalog: x')
-})
-
-test('resolveModelTiers: the seed pre-fills only when nothing stronger exists', () => {
-  const r = resolveModelTiers({ seed: { tiers: { high: 'scoped-coder' }, citation: 'c' }, discoveryTiers: { high: 'deep-reasoner' } })
-  assert.equal(r.source, 'team-seed')
-})
-
-test('resolveModelTiers: discovery evidence is the fallback below the seed; nothing at all is unconfirmed', () => {
-  assert.equal(resolveModelTiers({ discoveryTiers: { high: 'balanced-coder' } }).source, 'discovery')
-  assert.equal(resolveModelTiers({}).source, 'unconfirmed')
-  assert.equal(resolveModelTiers().source, 'unconfirmed')
-  assert.deepEqual(resolveModelTiers().tiers, {})
-})
-
-test('resolveModelTiers: an EMPTY tiers map does not win — it classifies nothing', () => {
-  // The trap `bank` already guards: `tiers: {}` passes a truthiness check while
-  // saying nothing, so a banked-but-empty entry must fall through, not shadow
-  // the seed with a blank answer.
-  const r = resolveModelTiers({ banked: {}, seed: { tiers: { high: 'frontier' }, citation: 'c' } })
-  assert.equal(r.source, 'team-seed')
-})
-
-test('resolveModelTiers cannot express a per-effort merge — the shape is the safeguard', () => {
-  // The regression that motivated the replacement: a human banked {high} after
-  // dropping a max point. Whatever the seed claims at max, the banked map wins
-  // WHOLE, so the deleted point cannot come back.
-  const r = resolveModelTiers({
-    banked: { high: 'balanced-coder' },
-    seed: { tiers: { high: 'balanced-coder', max: 'deep-reasoner' }, citation: 'c' },
-  })
-  assert.deepEqual(r.tiers, { high: 'balanced-coder' })
-  assert.equal(r.tiers.max, undefined, 'a dropped operating point must not reappear from a weaker source')
-})
-
-// ---- a seed entry is never confirmedAt; confirming banks a NORMAL entry into the user's own file ----
-
-test('entryFromSeedConfirmation produces a normal bankable entry, stamped fresh, never carrying seed provenance as confirmedAt', () => {
-  const out = entryFromSeedConfirmation(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code', '2026-07-20')
-  assert.deepEqual(out, { id: 'kimi-k2.7-code', family: 'moonshot', tiers: { high: 'scoped-coder' }, confirmedAt: '2026-07-20', lastSeenAt: '2026-07-20' })
-})
-
-test('entryFromSeedConfirmation resolves the PI-side alias id to the same canonical entry, banking the PI tier', () => {
-  const out = entryFromSeedConfirmation(FIXTURE_SEED, 'pi', 'kimi-coding/kimi-for-coding', '2026-07-20')
-  assert.deepEqual(out.tiers, { high: 'scoped-coder' }) // pi's tier, not claude-code's
-})
-
-test('entryFromSeedConfirmation throws for an id the seed does not cover under that harness', () => {
-  assert.throws(() => entryFromSeedConfirmation(FIXTURE_SEED, 'codex', 'kimi-k2.7-code', '2026-07-20'), /no seed entry/)
-  assert.throws(() => entryFromSeedConfirmation(FIXTURE_SEED, 'codex', 'opus', '2026-07-20'), /no seed entry/) // opus has no codex id at all
-})
-
-// ---- read-only: bank/sync never write to the seed, sync --seen never prunes it ----
-
-test('CLI bank refuses to write to the seed file by path (the default seed location)', () => {
-  const before = fs.readFileSync(defaultSeedPath(), 'utf8')
-  const res = run(['bank', JSON.stringify({ id: 'new-model', family: 'x', tier: 'frontier' }), '--file', defaultSeedPath()])
-  assert.equal(res.status, 2)
-  assert.match(res.stderr, /read-only/)
-  assert.equal(fs.readFileSync(defaultSeedPath(), 'utf8'), before, 'the shipped seed must be byte-identical after a refused write')
-})
-
-test('CLI sync refuses to write to the seed file by path', () => {
-  const before = fs.readFileSync(defaultSeedPath(), 'utf8')
-  const res = run(['sync', '--file', defaultSeedPath(), '--seen', 'gpt-5.6-sol'])
-  assert.equal(res.status, 2)
-  assert.match(res.stderr, /read-only/)
-  assert.equal(fs.readFileSync(defaultSeedPath(), 'utf8'), before)
-})
-
-test('CLI bank/sync refuse ANY file shaped like a seed (carrying seededAt), not just the default path', () => {
-  // A copy of the seed at a scratch path must still be caught — the guard checks
-  // shape, not only the well-known location.
-  const copy = tmpFile('seed-copy.json')
-  fs.writeFileSync(copy, JSON.stringify(FIXTURE_SEED))
-  const before = fs.readFileSync(copy, 'utf8')
-
-  const bankRes = run(['bank', JSON.stringify({ id: 'x', family: 'f', tier: 'frontier' }), '--file', copy])
-  assert.equal(bankRes.status, 2)
-  assert.match(bankRes.stderr, /read-only/)
-
-  const syncRes = run(['sync', '--file', copy, '--seen', 'gpt-5.6-sol'])
-  assert.equal(syncRes.status, 2)
-  assert.match(syncRes.stderr, /read-only/)
-
-  assert.equal(fs.readFileSync(copy, 'utf8'), before, 'a seed-shaped file must be untouched by a refused bank/sync')
-})
-
-test('sync --seen pruning logic never applies to seed entries — the seed has no lastSeenAt/confirmedAt to prune by', () => {
-  // Structural proof, not just the write-refusal above: seed entries carry no
-  // lastSeenAt/confirmedAt fields at all (that is a per-user-catalog concept),
-  // so even if syncCatalog's pure prune predicate were run over seed-shaped
-  // data it could not classify a seed entry as stale — there is nothing to
-  // stamp `pruned` against. seedProposals (the actual seed read path) has no
-  // pruning step whatsoever.
-  for (const entry of FIXTURE_SEED.models) {
-    assert.equal(entry.lastSeenAt, undefined)
-    assert.equal(entry.confirmedAt, undefined)
-  }
-})
-
-test('confirming a seed-backed proposal banks into the USER catalog file, leaving the seed itself untouched', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const userCatalogFile = tmpFile('catalog.json')
-  const seedBefore = fs.readFileSync(seedFile, 'utf8')
-
-  // Simulate pre-flight step 4: the human confirmed the seed-backed proposal for
-  // kimi-k2.7-code, so it's banked into the user's OWN per-harness catalog.
-  const entry = entryFromSeedConfirmation(FIXTURE_SEED, 'claude-code', 'kimi-k2.7-code', '2026-07-20')
-  const res = run(['bank', JSON.stringify(entry), '--file', userCatalogFile, '--today', '2026-07-20'])
-  assert.equal(res.status, 0)
-
-  assert.deepEqual(readCatalog(userCatalogFile).models[0].tiers, { high: 'scoped-coder' })
-  assert.ok(readCatalog(userCatalogFile).models[0].confirmedAt, 'a banked entry carries a real confirmedAt — never seed provenance')
-  assert.equal(fs.readFileSync(seedFile, 'utf8'), seedBefore, 'the seed file itself is never written by a confirmation')
-})
-
-// ---- rule 5 (cross-harness), which had no implementation at all until 2026-07-20 ----
-
-const XH_CATS = {
-  'claude-code': { harness: 'claude-code', models: [{ id: 'gpt-5.6-terra', family: 'openai', tiers: { high: 'balanced-coder' } }, { id: 'kimi-k3', family: 'moonshot', tiers: { max: 'frontier' } }] },
-  codex: { harness: 'codex', models: [{ id: 'gpt-5.6-sol', family: 'openai', tiers: { high: 'frontier' } }] },
-  pi: { harness: 'pi', models: [{ id: 'kimi-coding/k3', family: 'moonshot', tiers: { high: 'deep-reasoner' } }] },
-}
-const XH_PATHS = { 'claude-code': 1, codex: 1, pi: 1 }
-const xhRead = (p) => XH_CATS[Object.keys(XH_PATHS).find((h) => p.includes(h === 'claude-code' ? '.claude' : `.${h}`))] || null
-const xh = (harness, seen) => crossHarnessProposals(harness, seen, { readAt: xhRead, paths: XH_PATHS })
-
-test('plainlyMatches accepts a provider/ prefix difference in either direction, and exact equality', () => {
-  assert.equal(plainlyMatches('openai/gpt-5.6-sol', 'gpt-5.6-sol'), true)
-  assert.equal(plainlyMatches('gpt-5.6-sol', 'openai/gpt-5.6-sol'), true)
-  assert.equal(plainlyMatches('gpt-5.5', 'gpt-5.5'), true)
-})
-
-test('plainlyMatches REFUSES the near-misses — this is the half of rule 5 that matters', () => {
-  // A harness-local alias normalizes to nothing.
-  assert.equal(plainlyMatches('sonnet', 'anthropic/claude-sonnet-5'), false)
-  // The trap the shipped seed documents: stripping `kimi-coding/` gives `k3`, not
-  // `kimi-k3`. The seed's authors declined this merge pending human confirmation;
-  // an agent hand-applying rule 5 makes it anyway. The refusal must be mechanical.
-  assert.equal(plainlyMatches('kimi-coding/k3', 'kimi-k3'), false)
-  assert.equal(plainlyMatches('openai/gpt-5.6-sol', 'openai/gpt-5.6-luna'), false)
-})
-
-test('crossHarnessProposals pre-fills from another harness with the citation rule 5 specifies', () => {
-  const out = xh('pi', ['openai/gpt-5.6-terra'])
-  assert.equal(out.length, 1)
-  assert.deepEqual(out[0].tiers, { high: 'balanced-coder' })
-  assert.equal(out[0].fromHarness, 'claude-code')
-  assert.equal(out[0].citation, 'tier from claude-code catalog: gpt-5.6-terra')
-})
-
-test('crossHarnessProposals never transfers a tier across an unconfirmed alias', () => {
-  // pi's `kimi-coding/k3` and claude-code's `kimi-k3` are plausibly one model.
-  // Rule 5 must not merge them, so a claude-code run discovering kimi-k3 gets nothing.
-  assert.deepEqual(xh('claude-code', ['kimi-k3']), [])
-})
-
-test('crossHarnessProposals skips a model THIS harness already banked — rule 1 outranks rule 5', () => {
-  assert.deepEqual(xh('claude-code', ['gpt-5.6-terra']), [])
-})
-
-test('crossHarnessProposals never leaks availability — only discovered ids appear (rule 3)', () => {
-  // codex has gpt-5.6-sol banked; a pi run that did not discover it gets nothing.
-  assert.deepEqual(xh('pi', []), [])
-  assert.deepEqual(xh('pi', ['something-else']), [])
-})
-
-// ---- SLOT_ELIGIBLE_TIERS, wired at last ----
-
-test('operatingPoints marks scoped-coder ineligible rather than hiding it', () => {
-  const catalog = { models: [{ id: 'x', family: 'f', tiers: { high: 'scoped-coder' } }] }
-  const [pt] = operatingPoints(catalog, 'x')
-  assert.equal(pt.tier, 'scoped-coder')
-  assert.equal(pt.slotEligible, false, 'marked, so pre-flight can show it without offering it')
-  assert.equal(operatingPoints(catalog, 'x').length, 1, 'still listed — banking it is what stops pre-flight re-asking')
-})
-
-test('every SLOT_ELIGIBLE_TIERS band is marked eligible and every other band is not', () => {
-  for (const tier of TIERS) {
-    const catalog = { models: [{ id: 'x', family: 'f', tiers: { high: tier } }] }
-    assert.equal(operatingPoints(catalog, 'x')[0].slotEligible, SLOT_ELIGIBLE_TIERS.includes(tier), tier)
-  }
-})
-
-test('the shipped seed cannot hand a fresh install a slot-eligible scoped-coder', () => {
-  const seed = readSeed(defaultSeedPath())
-  const ids = seed.models.filter((m) => m.ids['claude-code']).map((m) => m.ids['claude-code'])
-  const { proposals } = seedProposals(seed, 'claude-code', ids, null) // null catalog = fresh install
-  const scoped = proposals.flatMap((p) => p.points).filter((pt) => pt.tier === 'scoped-coder')
-  assert.ok(scoped.length > 0, 'the seed does ship scoped-coder entries — that is the case under test')
-  assert.ok(scoped.every((pt) => pt.slotEligible === false), 'a scoped-coder point must never be marked slot-eligible')
-})
-
-// ---- bank-from-seed: the confirmation path, previously hand-written ----
-
-test('CLI bank-from-seed banks THIS harness tiers with a fresh confirmedAt, never the seed provenance', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const catalogFile = tmpFile('catalog.json')
-  const res = run(['bank-from-seed', 'kimi-coding/kimi-for-coding', '--seed-file', seedFile, '--file', catalogFile, '--harness', 'pi', '--today', '2026-07-20'])
-  assert.equal(res.status, 0)
-  const [entry] = readCatalog(catalogFile).models
-  assert.deepEqual(entry.tiers, { high: 'scoped-coder' }, "pi's tier, not claude-code's")
-  assert.equal(entry.confirmedAt, '2026-07-20')
-  assert.equal(entry.seededAt, undefined, 'no seed provenance may ride along as a confirmation')
-})
-
-test('CLI bank-from-seed refuses an id the seed does not cover under that harness', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const res = run(['bank-from-seed', 'kimi-k2.7-code', '--seed-file', seedFile, '--file', tmpFile('c.json'), '--harness', 'codex'])
-  assert.equal(res.status, 2)
-  assert.match(res.stderr, /no seed entry/)
-})
-
-// ---- tierProposals: the composed answer pre-flight step 2 actually consumes ----
-
-test('tierProposals decides each discovered model and names the winning source', () => {
-  const cats = {
-    'claude-code': { harness: 'claude-code', models: [{ id: 'opus', family: 'anthropic', tiers: { high: 'deep-reasoner' } }] },
-    codex: { harness: 'codex', models: [{ id: 'gpt-5.6-sol', family: 'openai', tiers: { high: 'frontier' } }] },
-    pi: { harness: 'pi', models: [] },
-  }
-  const readAt = (p) => cats[Object.keys(cats).find((h) => p.includes(h === 'claude-code' ? '.claude' : `.${h}`))] || null
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-
-  const { models } = tierProposals('claude-code', ['opus', 'gpt-5.6-sol', 'kimi-k2.7-code', 'never-heard-of-it'], { seedFile, readAt })
-  const by = Object.fromEntries(models.map((m) => [m.id, m]))
-
-  assert.equal(by.opus.source, 'banked', 'own catalog wins')
-  assert.equal(by['gpt-5.6-sol'].source, 'cross-harness', "codex's entry, plainly matching")
-  assert.equal(by['kimi-k2.7-code'].source, 'team-seed', 'nothing banked or cross-harness')
-  assert.equal(by['never-heard-of-it'].source, 'unconfirmed')
-  assert.deepEqual(by['never-heard-of-it'].tiers, {})
-})
-
-test('tierProposals marks slot eligibility on the resolved answer, so a scoped-coder cannot reach a slot list', () => {
-  const readAt = () => null // fresh install: nothing banked anywhere
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const { models } = tierProposals('claude-code', ['kimi-k2.7-code'], { seedFile, readAt })
-  assert.equal(models[0].tiers.high, 'scoped-coder')
-  assert.deepEqual(models[0].points, [{ effort: 'high', tier: 'scoped-coder', slotEligible: false }])
-})
-
-test('tierProposals surfaces a stale-seed disagreement instead of swallowing it', () => {
-  const cats = { 'claude-code': { harness: 'claude-code', models: [{ id: 'kimi-k2.7-code', family: 'moonshot', tiers: { high: 'balanced-coder' } }] } }
-  const readAt = (p) => (p.includes('.claude') ? cats['claude-code'] : null)
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED)) // seed says scoped-coder
-  const { models, seedDisagreements } = tierProposals('claude-code', ['kimi-k2.7-code'], { seedFile, readAt })
-  assert.equal(models[0].source, 'banked')
-  assert.equal(seedDisagreements.length, 1)
-  assert.deepEqual(seedDisagreements[0].banked, { high: 'balanced-coder' })
-  assert.deepEqual(seedDisagreements[0].seed, { high: 'scoped-coder' })
-})
-
-// ---- build 2: classification-staleness (confirmedAt age), distinct from prune (lastSeenAt) ----
-test('tierProposals flags a banked classification older than CLASSIFY_STALE_AFTER_DAYS, and only when past it', () => {
-  assert.equal(CLASSIFY_STALE_AFTER_DAYS, 30)
-  const cats = { 'claude-code': { harness: 'claude-code', models: [{ id: 'grok-4.5', family: 'xai', confirmedAt: '2026-07-19', lastSeenAt: '2026-08-30', tiers: { high: 'deep-reasoner' } }] } }
-  const readAt = (p) => (p.includes('.claude') ? cats['claude-code'] : null)
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-
-  // 42 days after confirmedAt — recently SEEN (never pruned) yet the classification is stale.
-  const stale = tierProposals('claude-code', ['grok-4.5'], { seedFile, readAt, today: '2026-08-30' })
-  assert.deepEqual(stale.staleClassifications, [{ id: 'grok-4.5', confirmedAt: '2026-07-19', ageDays: 42 }])
-
-  // 6 days after — not stale.
-  const fresh = tierProposals('claude-code', ['grok-4.5'], { seedFile, readAt, today: '2026-07-25' })
-  assert.deepEqual(fresh.staleClassifications, [])
-})
-
-test('tierProposals only flags stale classifications for DISCOVERED ids (rule 3)', () => {
-  const cats = { 'claude-code': { harness: 'claude-code', models: [{ id: 'old-model', family: 'x', confirmedAt: '2020-01-01', tiers: { high: 'frontier' } }] } }
-  const readAt = (p) => (p.includes('.claude') ? cats['claude-code'] : null)
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const out = tierProposals('claude-code', ['definitely-not-discovered'], { seedFile, readAt, today: '2026-08-30' })
-  assert.deepEqual(out.staleClassifications, [], 'an undiscovered banked model is not surfaced')
-})
-
-test('CLI tiers composes the three arms in one call', () => {
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const res = run(['tiers', '--harness', 'claude-code', '--seed-file', seedFile, '--seen', 'definitely-not-real'])
-  assert.equal(res.status, 0)
-  const { models } = JSON.parse(res.stdout)
-  assert.equal(models[0].source, 'unconfirmed')
-})
-
-test('CLI tiers reads the catalog from --file — the pure-path fix exercised through the CLI, not injected readAt', () => {
-  // The staleClassifications/seedDisagreements surfaces are only truthful if the CLI reads the
-  // catalog it was pointed at. Before the fix `tiers --file` read the default per-harness path,
-  // so a stale banked model on an explicit path came back `unconfirmed` with no staleClassifications.
-  const seedFile = tmpFile('seed.json')
-  fs.writeFileSync(seedFile, JSON.stringify(FIXTURE_SEED))
-  const catalogFile = tmpFile('catalog.json')
-  writeCatalog(catalogFile, { harness: 'claude-code', models: [{ id: 'old-model', family: 'x', confirmedAt: '2026-07-19', lastSeenAt: '2026-08-30', tiers: { high: 'deep-reasoner' } }] })
-
-  const res = run(['tiers', '--file', catalogFile, '--harness', 'claude-code', '--seed-file', seedFile, '--seen', 'old-model', '--today', '2026-08-30'])
-  assert.equal(res.status, 0)
-  const out = JSON.parse(res.stdout)
-  assert.equal(out.models[0].source, 'banked', 'the --file catalog is read, so the model is banked, not unconfirmed')
-  assert.equal(out.models[0].tiers.high, 'deep-reasoner')
-  assert.deepEqual(out.staleClassifications, [{ id: 'old-model', confirmedAt: '2026-07-19', ageDays: 42 }])
-})