@1aboveio/skills 1.0.7 → 1.0.9

package/skills/engineering/resolve-issues/scripts/plan-sync.test.mjs

@@ -1,156 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { mkdirSync, mkdtempSync, readFileSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { SNAPSHOT, classify, findRun, parseCliArgs, PlanSyncError, planSync, syncRun } from './plan-sync.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'plan-sync.mjs')
-
-// A tree in issue-tree.mjs's shape from { "n": { state, children: [n], blockedBy: [n] } } in o/r.
-function tree(spec, issues, { complete = true } = {}) {
-  const nodes = {}
-  const key = (n) => (String(n).includes('#') ? String(n) : `o/r#${n}`)
-  for (const [n, i] of Object.entries(issues)) {
-    nodes[key(n)] = { key: key(n), repo: 'o/r', number: Number(n), title: `t${n}`, state: i.state ?? 'open', labels: [], blockedBy: (i.blockedBy ?? []).map((b) => ({ key: key(b), state: issues[b]?.state ?? i.blockerState ?? 'open' })), children: (i.children ?? []).map(key), parent: null }
-  }
-  for (const node of Object.values(nodes)) for (const c of node.children) if (nodes[c]) nodes[c].parent = node.key
-  return { root: key(spec), complete, errors: complete ? [] : [{ key: key(spec), error: 'HTTP 502' }], nodes }
-}
-const plan = (units, extra = {}) => ({ spec: 'o/r#1', units, ...extra })
-const actionsOf = (result) => result.actions.map((a) => `${a.action} ${a.unit}`)
-
-test('a held issue whose filed prerequisite closed stays a unit, and a new open issue is added', () => {
-  // fmm #1343: its prerequisite #1659 was filed under it and closed; the old check dropped #1343.
-  const t = tree(1, { 1: { children: [1343, 1142, 1700] }, 1343: { children: [1659] }, 1659: { state: 'closed' }, 1142: { blockedBy: [1343] }, 1700: {} })
-  assert.equal(classify(t)['o/r#1343'], 'unit')
-  const result = planSync(plan([{ id: '1343', status: 'blocked' }, { id: '1142', status: 'pending', dependsOn: ['1343'] }]), t)
-  assert.deepEqual(actionsOf(result), ['add-unit 1700'])
-})
-
-test('add-unit carries blockedBy, expanding a blocking container into its open leaves', () => {
-  const t = tree(1, { 1: { children: [2, 5] }, 2: { children: [3, 4] }, 3: {}, 4: { state: 'closed' }, 5: { blockedBy: [2] } })
-  const result = planSync(plan([{ id: '3', status: 'pending' }]), t)
-  assert.deepEqual(result.actions.map((a) => [a.action, a.unit, a.dependsOn]), [['add-unit', '5', ['3']]])
-})
-
-test('a container\'s link is never inherited: move-link asks for it on the sub-issues that wait', () => {
-  // A link on a split issue fanned out to all five of its slices, though two used the blocker.
-  const t = tree(1, { 1: { children: [2, 9] }, 2: { children: [3, 4], blockedBy: [9] }, 3: {}, 4: {}, 9: {} })
-  const result = planSync(plan([{ id: '3', status: 'pending', dependsOn: ['7'] }, { id: '4', status: 'pending' }, { id: '9', status: 'pending' }]), t)
-  assert.deepEqual(result.actions.map((a) => [a.action, a.unit]), [['move-link', '2']])
-  assert.match(result.actions[0].detail, /o\/r#2 has 2 open sub-issues \(3, 4\) and is blocked by o\/r#9/)
-  const moved = tree(1, { 1: { children: [2, 9] }, 2: { children: [3, 4] }, 3: { blockedBy: [9] }, 4: {}, 9: {} })
-  const after = planSync(plan([{ id: '3', status: 'pending', dependsOn: ['7'] }, { id: '4', status: 'pending' }, { id: '9', status: 'pending' }]), moved)
-  assert.deepEqual(after.actions.map((a) => [a.action, a.unit, a.dependsOn]), [['set-deps', '3', ['7', '9']]], 'only the linked sub-issue waits; set-deps keeps the explorer-recorded 7')
-  const done = tree(1, { 1: { children: [2, 9] }, 2: { children: [3], blockedBy: [9] }, 3: {}, 9: { state: 'closed' } })
-  assert.deepEqual(planSync(plan([{ id: '3', status: 'pending' }]), done).actions, [], 'a closed blocker needs no move')
-})
-
-test('closed, split, and moved-out issues drop their units; done units are left alone', () => {
-  const t = tree(1, { 1: { children: [2, 3, 5] }, 2: { state: 'closed' }, 3: { children: [4] }, 4: {}, 5: { state: 'closed' } })
-  const result = planSync(plan([
-    { id: '2', status: 'in-flight' }, { id: '3', status: 'pending' }, { id: '4', status: 'pending' },
-    { id: '5', status: 'succeeded' }, { id: '8', status: 'pending' },
-  ]), t)
-  assert.deepEqual(actionsOf(result), ['drop-unit 2', 'drop-unit 3', 'drop-unit 8'])
-})
-
-test('a partial tree never drops a unit or changes dependencies', () => {
-  const t = tree(1, { 1: { children: [3, 5] }, 3: { blockedBy: [5] }, 5: {} }, { complete: false })
-  const result = planSync(plan([{ id: '3', status: 'pending' }, { id: '8', status: 'pending' }]), t)
-  assert.equal(result.partial, true)
-  assert.deepEqual(actionsOf(result), ['add-unit 5'])
-})
-
-test('an open blocker outside the tree is reported; a closed one is satisfied', () => {
-  const t = tree(1, { 1: { children: [3, 4] }, 3: { blockedBy: ['x/y#9'] }, 4: { blockedBy: ['x/y#10'], blockerState: 'closed' } })
-  const result = planSync(plan([{ id: '3', status: 'pending' }, { id: '4', status: 'pending' }]), t)
-  assert.deepEqual(result.actions.map((a) => [a.action, a.unit, a.blocker]), [['blocked-outside', '3', 'x/y#9']])
-})
-
-test('excluded issues and earlier merges are known; every other open leaf joins the run; a local spec has nothing to sync', () => {
-  const t = tree(1, { 1: { children: [2, 3, 4, 5] }, 2: {}, 3: {}, 4: {}, 5: {} })
-  const result = planSync(plan([{ id: '2', status: 'pending' }], { excluded: [{ issue: 'o/r#3', reason: 'release gate' }], merged: ['4'] }), t)
-  assert.deepEqual(result.actions.map((a) => `${a.action} ${a.unit}`), ['add-unit 5'], 'no wave keeps an open issue out of the run')
-  assert.equal(planSync({ spec: 'docs/spec.md', units: [{ id: 'one' }] }, t).synced, false)
-})
-
-function runDir(planBody, snapshot) {
-  const dir = mkdtempSync(join(tmpdir(), 'plan-sync-'))
-  writeFileSync(join(dir, 'task-plan.json'), JSON.stringify(planBody))
-  if (snapshot) writeFileSync(join(dir, SNAPSHOT), JSON.stringify(snapshot))
-  return dir
-}
-
-test('a live sync saves a complete tree; a failed fetch falls back to the snapshot and saves nothing', () => {
-  const saved = tree(1, { 1: { children: [2] }, 2: {} })
-  const dir = runDir(plan([{ id: '2', status: 'pending' }]), saved)
-  const fresh = tree(1, { 1: { children: [2, 3] }, 2: {}, 3: {} })
-  const live = syncRun(dir, { live: true, fetch: () => fresh, now: () => new Date('2026-10-12T00:00:00Z') })
-  assert.equal(live.source, 'live')
-  assert.deepEqual(actionsOf(live), ['add-unit 3'])
-  assert.equal(JSON.parse(readFileSync(join(dir, SNAPSHOT), 'utf8')).fetchedAt, '2026-10-12T00:00:00.000Z')
-  const down = syncRun(dir, { live: true, fetch: () => ({ root: 'o/r#1', complete: false, errors: [{ key: 'o/r#1', error: 'HTTP 502' }], nodes: {} }) })
-  assert.equal(down.source, 'snapshot')
-  assert.match(down.fetchError[0].error, /502/)
-  assert.deepEqual(actionsOf(down), ['add-unit 3'])
-  const offline = syncRun(dir, { fetch: () => { throw new Error('no call without --live') } })
-  assert.equal(offline.source, 'snapshot')
-})
-
-test('find-run picks the newest run whose spec or saved tree holds the issue', () => {
-  const runs = mkdtempSync(join(tmpdir(), 'plan-sync-runs-'))
-  const make = (name, body, snap, mtime) => {
-    mkdirSync(join(runs, name))
-    writeFileSync(join(runs, name, 'task-plan.json'), JSON.stringify(body))
-    if (snap) writeFileSync(join(runs, name, SNAPSHOT), JSON.stringify(snap))
-    utimesSync(join(runs, name, 'task-plan.json'), mtime, mtime)
-  }
-  make('old', plan([]), null, 1000)
-  make('followup', { spec: 'o/r#1512', units: [] }, tree(1512, { 1512: { children: [1343] }, 1343: {} }), 2000)
-  make('other', { spec: 'o/r#9', units: [] }, null, 3000)
-  assert.equal(findRun(runs, { repo: 'o/r', number: 1 }), join(runs, 'old'))
-  assert.equal(findRun(runs, { repo: 'o/r', number: 1343 }), join(runs, 'followup'))
-  assert.equal(findRun(runs, { repo: 'o/r', number: 77 }), null)
-})
-
-test('CLI exits 0 with or without actions and without a tree, 2 on bad input; --exit-actions restores the old codes', () => {
-  const dir = runDir(plan([{ id: '2', status: 'pending' }]), tree(1, { 1: { children: [2, 3] }, 2: {}, 3: {} }))
-  const due = spawnSync(process.execPath, [script, '--run', dir], { encoding: 'utf8' })
-  assert.equal(due.status, 0, due.stderr)
-  assert.match(due.stdout, /^add-unit +add unit 3/m)
-  assert.equal(JSON.parse(spawnSync(process.execPath, [script, '--run', dir, '--json'], { encoding: 'utf8' }).stdout).actions[0].action, 'add-unit')
-  assert.equal(spawnSync(process.execPath, [script, '--run', dir, '--exit-actions'], { encoding: 'utf8' }).status, 1)
-  const inSync = runDir(plan([{ id: '2', status: 'pending' }]), tree(1, { 1: { children: [2] }, 2: {} }))
-  assert.equal(spawnSync(process.execPath, [script, '--run', inSync], { encoding: 'utf8' }).status, 0)
-  assert.equal(spawnSync(process.execPath, [script, '--run', inSync, '--exit-actions'], { encoding: 'utf8' }).status, 0)
-  const noTree = runDir(plan([]))
-  const missing = spawnSync(process.execPath, [script, '--run', noTree], { encoding: 'utf8' })
-  assert.equal(missing.status, 0, missing.stderr)
-  assert.match(missing.stdout, /no issue tree available/)
-  assert.equal(JSON.parse(spawnSync(process.execPath, [script, '--run', noTree, '--json'], { encoding: 'utf8' }).stdout).missingTree, true)
-  assert.equal(spawnSync(process.execPath, [script, '--run', noTree, '--exit-actions'], { encoding: 'utf8' }).status, 2)
-  assert.equal(spawnSync(process.execPath, [script, '--run', join(noTree, 'nope')], { encoding: 'utf8' }).status, 2)
-  assert.equal(spawnSync(process.execPath, [script], { encoding: 'utf8' }).status, 2)
-  assert.throws(() => parseCliArgs(['--find-run', '--runs', 'x']), PlanSyncError)
-})
-
-test('--find-run exits 0 whether or not a run is found; --json and --exit-actions say which', () => {
-  const runs = mkdtempSync(join(tmpdir(), 'plan-sync-find-'))
-  const empty = (...extra) => spawnSync(process.execPath, [script, '--find-run', '--runs', runs, '--issue', 'o/r#77', ...extra], { encoding: 'utf8' })
-  const none = empty()
-  assert.equal(none.status, 0, none.stderr)
-  assert.equal(none.stdout, '', 'nothing on stdout when no run is found')
-  assert.deepEqual(JSON.parse(empty('--json').stdout), { found: false, dir: null })
-  assert.equal(empty('--exit-actions').status, 1)
-  mkdirSync(join(runs, 'one'))
-  writeFileSync(join(runs, 'one', 'task-plan.json'), JSON.stringify(plan([], { spec: 'o/r#77' })))
-  const found = empty('--json')
-  assert.equal(found.status, 0, found.stderr)
-  assert.deepEqual(JSON.parse(found.stdout), { found: true, dir: join(runs, 'one') })
-  assert.equal(empty('--exit-actions').status, 0)
-})

package/skills/engineering/resolve-issues/scripts/preflight-models.test.mjs

@@ -1,448 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-import {
-  recommendImplementer,
-  rankReviewers,
-  fillExplorer,
-  fillDiagnoser,
-  slotPoints,
-  buildAsk,
-  buildPreflightModels,
-  TEAM_REVIEWER_POLICY,
-} from './preflight-models.mjs'
-
-const points = [
-  { id: 'openai/gpt-6-astra', effort: 'high', tier: 'frontier', family: 'openai', key: 'openai/gpt-6-astra@high' },
-  { id: 'openai/gpt-5.6-sol', effort: 'high', tier: 'frontier', family: 'openai', key: 'openai/gpt-5.6-sol@high' },
-  { id: 'openai/gpt-6.1-sol', effort: 'high', tier: 'frontier', family: 'openai', key: 'openai/gpt-6.1-sol@high' },
-  { id: 'openai/gpt-5.5', effort: 'high', tier: 'deep-reasoner', family: 'openai', key: 'openai/gpt-5.5@high' },
-  { id: 'openai/gpt-5.6-terra', effort: 'high', tier: 'balanced-coder', family: 'openai', key: 'openai/gpt-5.6-terra@high' },
-  { id: 'openai/gpt-6-luna', effort: 'high', tier: 'balanced-coder', family: 'openai', key: 'openai/gpt-6-luna@high' },
-  { id: 'xiaomi/mimo-v2.6-pro', effort: 'high', tier: 'frontier', family: 'xiaomi', key: 'xiaomi/mimo-v2.6-pro@high' },
-  { id: 'xai/grok-4.7', effort: 'high', tier: 'frontier', family: 'xai', key: 'xai/grok-4.7@high' },
-  { id: 'xai/grok-4.6', effort: 'high', tier: 'deep-reasoner', family: 'xai', key: 'xai/grok-4.6@high' },
-  { id: 'xai/grok-4.5', effort: 'high', tier: 'balanced-coder', family: 'xai', key: 'xai/grok-4.5@high' },
-  { id: 'anthropic/claude-opus', effort: 'high', tier: 'frontier', family: 'anthropic', key: 'anthropic/claude-opus@high' },
-]
-
-test('routine risk recommends a balanced-coder, not frontier', () => {
-  const pick = recommendImplementer(points, 'routine')
-  assert.equal(pick.tier, 'balanced-coder')
-  assert.ok(['xai/grok-4.5', 'openai/gpt-5.6-terra'].includes(pick.id))
-})
-
-test('routine risk walks the team ladder: gpt-6.1-sol@high, gpt-6-luna@high, grok-4.6@high, then mimo-v2.6-pro@high', () => {
-  const pick = recommendImplementer(points, 'routine', 'pi')
-  assert.equal(pick.key, 'openai/gpt-6.1-sol@high')
-  assert.equal(pick.tier, 'frontier')
-  assert.equal(rankReviewers(points, pick, 'pi').fill.key, 'openai/gpt-6-astra@medium')
-  const withoutSol = points.filter((p) => p.id !== 'openai/gpt-6.1-sol')
-  const second = recommendImplementer(withoutSol, 'routine', 'pi')
-  assert.equal(second.key, 'openai/gpt-6-luna@high')
-  assert.equal(second.tier, 'balanced-coder')
-  assert.equal(rankReviewers(points, second, 'pi').fill.key, 'openai/gpt-6-astra@medium')
-  const withoutLuna = withoutSol.filter((p) => p.id !== 'openai/gpt-6-luna')
-  const third = recommendImplementer(withoutLuna, 'routine', 'pi')
-  assert.equal(third.key, 'xai/grok-4.6@high')
-  // a cross-family implementation is still reviewed by the team primary, a distinct id and family
-  const grokReview = rankReviewers(points, third, 'pi')
-  assert.equal(grokReview.fill.key, 'openai/gpt-6-astra@medium')
-  assert.equal(grokReview.reducedDiversity, false)
-  const withoutGrok46 = withoutLuna.filter((p) => p.id !== 'xai/grok-4.6')
-  const fourth = recommendImplementer(withoutGrok46, 'routine', 'pi')
-  assert.equal(fourth.key, 'xiaomi/mimo-v2.6-pro@high')
-  assert.equal(rankReviewers(points, fourth, 'pi').fill.key, 'openai/gpt-6-astra@medium')
-  // past the ladder, the tier order picks a balanced-coder
-  const withoutMimo = withoutGrok46.filter((p) => p.id !== 'xiaomi/mimo-v2.6-pro')
-  assert.equal(recommendImplementer(withoutMimo, 'routine', 'pi').tier, 'balanced-coder')
-})
-
-test('codex routine ladder is gpt-6.1-sol@high, then gpt-6-luna@high', () => {
-  const codex = [
-    { id: 'gpt-6.1-sol', effort: 'high', tier: 'frontier', family: 'openai', key: 'gpt-6.1-sol@high' },
-    { id: 'gpt-6-luna', effort: 'high', tier: 'balanced-coder', family: 'openai', key: 'gpt-6-luna@high' },
-  ]
-  assert.equal(recommendImplementer(codex, 'routine', 'codex').key, 'gpt-6.1-sol@high')
-  assert.equal(recommendImplementer(codex.slice(1), 'routine', 'codex').key, 'gpt-6-luna@high')
-})
-
-test('escalation fix workers walk the high-risk ladder', () => {
-  assert.equal(fillDiagnoser(points, 'pi').fill.key, 'openai/gpt-6.1-sol@high')
-  const withoutSol61 = points.filter((p) => p.id !== 'openai/gpt-6.1-sol')
-  assert.equal(fillDiagnoser(withoutSol61, 'pi').fill.key, 'openai/gpt-6-astra@high')
-  const withoutAstra = withoutSol61.filter((p) => p.id !== 'openai/gpt-6-astra')
-  assert.equal(fillDiagnoser(withoutAstra, 'pi').fill.key, 'openai/gpt-5.6-sol@high')
-  const withoutSol56 = withoutAstra.filter((p) => p.id !== 'openai/gpt-5.6-sol')
-  assert.equal(fillDiagnoser(withoutSol56, 'pi').fill.key, 'xai/grok-4.7@high')
-})
-
-test('explorer takes gpt-6.1-sol@medium first, then gpt-6-luna, grok-4.6, mimo-v2.6-pro (all @high), then the balanced-coder tier', () => {
-  const explorer = fillExplorer(points, 'pi')
-  assert.equal(explorer.reason, 'team-default')
-  assert.equal(explorer.fill.key, 'openai/gpt-6.1-sol@medium')
-  assert.equal(explorer.fill.effort, 'medium')
-  assert.equal(explorer.fill.source, 'team-explorer-policy')
-  const withoutSol = points.filter((p) => p.id !== 'openai/gpt-6.1-sol')
-  const second = fillExplorer(withoutSol, 'pi')
-  assert.equal(second.reason, 'team-default')
-  assert.equal(second.fill.key, 'openai/gpt-6-luna@high')
-  const withoutLuna = withoutSol.filter((p) => p.id !== 'openai/gpt-6-luna')
-  assert.equal(fillExplorer(withoutLuna, 'pi').fill.key, 'xai/grok-4.6@high')
-  const withoutGrok46 = withoutLuna.filter((p) => p.id !== 'xai/grok-4.6')
-  assert.equal(fillExplorer(withoutGrok46, 'pi').fill.key, 'xiaomi/mimo-v2.6-pro@high')
-  const noLadder = withoutGrok46.filter((p) => p.id !== 'xiaomi/mimo-v2.6-pro')
-  const tierFill = fillExplorer(noLadder, 'pi')
-  assert.equal(tierFill.reason, 'balanced-coder')
-  assert.equal(tierFill.fill.tier, 'balanced-coder')
-})
-
-test('a discovered gpt-6.1-sol fills the explorer at medium, not at its @high implementer rung', () => {
-  const onlySolHigh = [points.find((p) => p.id === 'openai/gpt-6.1-sol'), points.find((p) => p.id === 'openai/gpt-5.6-terra')]
-  assert.equal(fillExplorer(onlySolHigh, 'pi').fill.key, 'openai/gpt-6.1-sol@medium')
-})
-
-test('the explorer takes gpt-6.1-sol@medium while the routine implementer takes gpt-6.1-sol@high', () => {
-  assert.equal(fillExplorer(points, 'pi').fill.key, 'openai/gpt-6.1-sol@medium')
-  assert.equal(recommendImplementer(points, 'routine', 'pi').key, 'openai/gpt-6.1-sol@high')
-})
-
-test('an undiscovered explorer rung falls through to the next discovered point', () => {
-  // Discovery yields neither gpt-6.1-sol nor gpt-6-luna, so the explorer lands on the balanced-coder tier.
-  const tiered = [
-    { id: 'gpt-6-astra', tiers: { high: 'frontier' }, source: 'team-seed' },
-    { id: 'gpt-5.6-sol', tiers: { high: 'frontier' }, source: 'team-seed' },
-    { id: 'gpt-5.6-terra', tiers: { high: 'balanced-coder' }, source: 'team-seed' },
-  ]
-  const result = buildPreflightModels({
-    harness: 'codex',
-    risk: 'routine',
-    discoverFn: () => ({
-      harness: 'codex',
-      completeness: 'full',
-      discovered: tiered.map(({ id }) => ({ id, source: 'current-turn' })),
-      notes: [],
-    }),
-    tierFn: () => ({ models: tiered, seedDisagreements: [], staleClassifications: [] }),
-  })
-  assert.equal(result.explorer.fill.key, 'gpt-5.6-terra@high')
-  assert.equal(result.explorer.reason, 'balanced-coder')
-  assert.equal(result.ask.explorerFill.id, 'gpt-5.6-terra@high')
-  // the same harness with gpt-6.1-sol discovered takes the medium rung
-  const withSol = [...tiered, { id: 'gpt-6.1-sol', tiers: { high: 'frontier' }, source: 'team-seed' }]
-  const sol = buildPreflightModels({
-    harness: 'codex',
-    risk: 'routine',
-    discoverFn: () => ({
-      harness: 'codex',
-      completeness: 'full',
-      discovered: withSol.map(({ id }) => ({ id, source: 'current-turn' })),
-      notes: [],
-    }),
-    tierFn: () => ({ models: withSol, seedDisagreements: [], staleClassifications: [] }),
-  })
-  assert.equal(sol.explorer.fill.key, 'gpt-6.1-sol@medium')
-  assert.equal(sol.implementer.key, 'gpt-6.1-sol@high', 'the routine implementer takes the @high rung')
-})
-
-test('high risk walks the team ladder: gpt-6.1-sol, gpt-6-astra, gpt-5.6-sol, grok-4.7 (all @high), then the deep-reasoner tier', () => {
-  const pick = recommendImplementer(points, 'high', 'pi')
-  assert.equal(pick.id, 'openai/gpt-6.1-sol')
-  assert.equal(pick.tier, 'frontier')
-  assert.equal(pick.effort, 'high')
-  // the gpt-6.1-sol implementation is reviewed by Astra (distinct id, same family)
-  const firstReview = rankReviewers(points, pick, 'pi')
-  assert.equal(firstReview.fill.key, 'openai/gpt-6-astra@medium')
-  assert.equal(firstReview.reason, 'team-default')
-  // without gpt-6.1-sol, Astra implements and is reviewed by the implementer-aware fallback
-  const withoutSol61 = points.filter((p) => p.id !== 'openai/gpt-6.1-sol')
-  const second = recommendImplementer(withoutSol61, 'high', 'pi')
-  assert.equal(second.key, 'openai/gpt-6-astra@high')
-  const secondReview = rankReviewers(points, second, 'pi')
-  assert.equal(secondReview.fill.key, 'openai/gpt-5.6-sol@medium')
-  assert.equal(secondReview.reason, 'implementer-aware-default')
-  // then gpt-5.6-sol and grok-4.7, each reviewed by gpt-6-astra@medium
-  const withoutAstra = withoutSol61.filter((p) => p.id !== 'openai/gpt-6-astra')
-  const third = recommendImplementer(withoutAstra, 'high', 'pi')
-  assert.equal(third.key, 'openai/gpt-5.6-sol@high')
-  assert.equal(rankReviewers(points, third, 'pi').fill.key, 'openai/gpt-6-astra@medium')
-  const withoutSol56 = withoutAstra.filter((p) => p.id !== 'openai/gpt-5.6-sol')
-  const fourth = recommendImplementer(withoutSol56, 'high', 'pi')
-  assert.equal(fourth.key, 'xai/grok-4.7@high')
-  assert.equal(rankReviewers(points, fourth, 'pi').fill.key, 'openai/gpt-6-astra@medium')
-  // without the harness (no team ladder) the tier order picks a deep-reasoner, never frontier
-  assert.equal(recommendImplementer(points, 'high').tier, 'deep-reasoner')
-  // without any ladder rung discovered, the tier order falls back to the other deep-reasoner
-  const withoutLadder = withoutSol56.filter((p) => !['xai/grok-4.7', 'xai/grok-4.6'].includes(p.id))
-  assert.equal(recommendImplementer(withoutLadder, 'high', 'pi').id, 'openai/gpt-5.5')
-})
-
-test('the recommended frontier implementer is labelled as the team preference, not an alternate', () => {
-  const implementer = recommendImplementer(points, 'high', 'pi')
-  const reviewer = rankReviewers(points, implementer, 'pi')
-  const ask = buildAsk(implementer, points, reviewer, { risk: 'high' })
-  assert.equal(ask.options[0].modelId, 'openai/gpt-6.1-sol')
-  assert.match(ask.options[0].description, /recommended · frontier — team implementer ladder preference/)
-  // without a harness there is no ladder to consult, so the other frontier point is a plain alternate
-  const otherFrontier = [...ask.options, ...ask.alternates].find((o) => o.modelId === 'openai/gpt-5.6-sol')
-  assert.match(otherFrontier.description, /alternate only/)
-})
-
-test('the ask lists the discovered ladder rungs first, in ladder order, before other points', () => {
-  // Real Pi discovery shape: deep-reasoners whose ids sort before the ladder rungs, plus a
-  // balanced-coder with a cheap id. Before the fix these pushed the rungs into `alternates`.
-  const many = [
-    ...points,
-    { id: 'deepseek/deepseek-v4-pro', effort: 'max', tier: 'deep-reasoner', family: 'deepseek', key: 'deepseek/deepseek-v4-pro@max' },
-    { id: 'kimi-coding/k3', effort: 'high', tier: 'deep-reasoner', family: 'kimi', key: 'kimi-coding/k3@high' },
-    { id: 'deepseek/deepseek-flash', effort: 'max', tier: 'balanced-coder', family: 'deepseek', key: 'deepseek/deepseek-flash@max' },
-  ]
-  const high = recommendImplementer(many, 'high', 'pi')
-  const highAsk = buildAsk(many.find((p) => p.key === high.key), many, rankReviewers(many, high, 'pi'), { risk: 'high', harness: 'pi' })
-  assert.deepEqual(
-    highAsk.options.map((o) => o.id),
-    ['openai/gpt-6.1-sol@high', 'openai/gpt-6-astra@high', 'openai/gpt-5.6-sol@high', 'xai/grok-4.7@high'],
-    'high-risk options are the ladder',
-  )
-  assert.match(highAsk.options[1].description, /team ladder rung 2/)
-  assert.ok(highAsk.alternates.some((o) => o.modelId === 'deepseek/deepseek-v4-pro'), 'non-ladder deep-reasoners become alternates')
-
-  const routine = recommendImplementer(many, 'routine', 'pi')
-  const routineAsk = buildAsk(routine, many, rankReviewers(many, routine, 'pi'), { risk: 'routine', harness: 'pi' })
-  assert.deepEqual(
-    routineAsk.options.map((o) => o.id),
-    ['openai/gpt-6.1-sol@high', 'openai/gpt-6-luna@high', 'xai/grok-4.6@high', 'xiaomi/mimo-v2.6-pro@high'],
-    'routine options are the ladder',
-  )
-  // an undiscovered rung is skipped, not left as a hole: the next point fills the fourth slot
-  const withoutMimo = many.filter((p) => p.id !== 'xiaomi/mimo-v2.6-pro')
-  const routine2 = recommendImplementer(withoutMimo, 'routine', 'pi')
-  const ask2 = buildAsk(routine2, withoutMimo, rankReviewers(withoutMimo, routine2, 'pi'), { risk: 'routine', harness: 'pi' })
-  assert.deepEqual(ask2.options.slice(0, 3).map((o) => o.id), ['openai/gpt-6.1-sol@high', 'openai/gpt-6-luna@high', 'xai/grok-4.6@high'])
-  assert.equal(ask2.options.length, 4)
-})
-
-test('non-Astra implementation prefers the gpt-6-astra@medium policy review when discovered', () => {
-  const implementer = recommendImplementer(points, 'routine', 'pi')
-  const review = rankReviewers(points, implementer, 'pi')
-  assert.equal(review.reason, 'team-default')
-  assert.equal(review.fill.id, TEAM_REVIEWER_POLICY.pi.primary.id)
-  assert.equal(review.fill.effort, 'medium')
-  assert.equal(review.fill.tier, 'frontier')
-  assert.equal(review.fill.source, 'team-review-policy')
-  assert.equal(review.fill.citation, 'docs/research/2026-09-23-reviewer-benchmark-astra-vs-sol.md')
-  assert.notEqual(review.fill.id, implementer.id)
-  assert.equal(review.ranking[0].key, 'openai/gpt-6-astra@medium')
-  assert.equal(review.ranking[1].key, 'openai/gpt-5.6-sol@medium')
-  assert.ok(!review.ranking.some((candidate) => candidate.effort === 'high' && candidate.id === 'openai/gpt-6-astra'), 'the policy point replaces the catalog high point in the ranking')
-})
-
-test('Astra implementation uses the gpt-5.6-sol@medium implementer-aware default', () => {
-  const implementer = points.find((p) => p.id === 'openai/gpt-6-astra')
-  const review = rankReviewers(points, implementer, 'pi')
-  assert.equal(review.reason, 'implementer-aware-default')
-  assert.notEqual(review.fill.id, implementer.id)
-  assert.equal(review.fill.id, TEAM_REVIEWER_POLICY.pi.fallback.id)
-  assert.equal(review.fill.effort, 'medium')
-  assert.equal(review.fill.key, 'openai/gpt-5.6-sol@medium')
-})
-
-test('another Astra effort is still the same implementer model id', () => {
-  const implementer = {
-    ...points.find((p) => p.id === 'openai/gpt-6-astra'),
-    effort: 'xhigh',
-    key: 'openai/gpt-6-astra@xhigh',
-  }
-  const review = rankReviewers(points, implementer, 'pi')
-  assert.equal(review.fill.id, 'openai/gpt-5.6-sol')
-  assert.notEqual(review.fill.id, implementer.id)
-})
-
-test('a gpt-6.1-sol implementation still gets the Astra reviewer (distinct id, same family)', () => {
-  const implementer = points.find((p) => p.id === 'openai/gpt-6.1-sol')
-  const review = rankReviewers(points, implementer, 'pi')
-  assert.equal(review.reason, 'team-default')
-  assert.equal(review.fill.id, 'openai/gpt-6-astra')
-  assert.equal(review.reducedDiversity, true, 'same family is flagged, not forbidden')
-})
-
-test('missing implementer-aware fallback uses the distinct-model ladder', () => {
-  const withoutSol56 = points.filter((p) => p.id !== 'openai/gpt-5.6-sol')
-  const implementer = withoutSol56.find((p) => p.id === 'openai/gpt-6-astra')
-  const review = rankReviewers(withoutSol56, implementer, 'pi')
-  assert.equal(review.reason, 'ladder')
-  // diversity-first: a cross-family deep-reasoner (grok-4.6) outranks cross-family frontier points
-  assert.equal(review.fill.id, 'xai/grok-4.6')
-  const withoutGrok = withoutSol56.filter((p) => p.family !== 'xai' && p.family !== 'xiaomi')
-  assert.equal(rankReviewers(withoutGrok, implementer, 'pi').fill.id, 'anthropic/claude-opus')
-})
-
-test('missing Astra primary uses the distinct-model ladder even when gpt-5.6-sol is available', () => {
-  const withoutAstra = points.filter((p) => p.id !== 'openai/gpt-6-astra')
-  const implementer = withoutAstra.find((p) => p.id === 'xai/grok-4.5')
-  const review = rankReviewers(withoutAstra, implementer, 'pi')
-  assert.equal(review.reason, 'ladder')
-  assert.equal(review.fill.id, 'openai/gpt-5.5', 'a cross-family deep-reasoner leads the ladder')
-  assert.equal(review.ranking[0].id, 'openai/gpt-5.6-sol', 'the fallback frontier point stays first in the ranking for a later Astra override')
-})
-
-test('scoped-coder points never enter slotPoints', () => {
-  const tiered = [
-    { id: 'scoped/x', tiers: { high: 'scoped-coder' }, source: 'banked' },
-    { id: 'ok/y', tiers: { high: 'balanced-coder' }, source: 'banked' },
-  ]
-  const out = slotPoints(tiered, { harness: 'pi' })
-  assert.deepEqual(out.map((p) => p.id), ['ok/y'])
-})
-
-test('ask lists recommended implementer first, caps at 4, keeps frontier visible', () => {
-  const many = [
-    ...points,
-    { id: 'a/balanced', effort: 'high', tier: 'balanced-coder', family: 'a', key: 'a/balanced@high' },
-    { id: 'b/balanced', effort: 'high', tier: 'balanced-coder', family: 'b', key: 'b/balanced@high' },
-    { id: 'c/deep', effort: 'high', tier: 'deep-reasoner', family: 'c', key: 'c/deep@high' },
-  ]
-  const implementer = recommendImplementer(many, 'routine')
-  const explorer = fillExplorer(many, 'pi')
-  const reviewer = rankReviewers(many, implementer, 'pi')
-  const ask = buildAsk(implementer, many, reviewer, { risk: 'routine', explorer })
-  assert.equal(ask.options[0].modelId, implementer.id)
-  assert.equal(ask.recommended, implementer.key)
-  assert.ok(ask.options.length <= 4)
-  assert.equal(ask.reviewerFill.modelId, reviewer.fill.id)
-  assert.equal(ask.explorerFill.modelId, explorer.fill.id)
-  assert.ok(
-    ask.options.some((o) => o.tier === 'frontier') || ask.alternates.some((o) => o.tier === 'frontier'),
-    'frontier stays visible',
-  )
-})
-
-test('buildPreflightModels is injectable and defers sync/bank', () => {
-  const result = buildPreflightModels({
-    harness: 'pi',
-    risk: 'routine',
-    available: ['openai/gpt-5.5', 'xai/grok-4.5', 'openai/gpt-5.6-sol', 'openai/gpt-5.6-terra', 'openai/gpt-6-astra'],
-    discoverFn: () => ({
-      harness: 'pi',
-      completeness: 'full',
-      discovered: [
-        { id: 'openai/gpt-6-astra', source: 'current-turn' },
-        { id: 'openai/gpt-5.5', source: 'current-turn' },
-        { id: 'xai/grok-4.5', source: 'current-turn' },
-        { id: 'openai/gpt-5.6-sol', source: 'current-turn' },
-        { id: 'openai/gpt-5.6-terra', source: 'current-turn' },
-      ],
-      notes: [],
-    }),
-    tierFn: () => ({
-      models: [
-        { id: 'openai/gpt-6-astra', tiers: { high: 'frontier' }, source: 'team-seed', citation: null },
-        { id: 'openai/gpt-5.5', tiers: { high: 'deep-reasoner' }, source: 'team-seed', citation: null },
-        { id: 'xai/grok-4.5', tiers: { high: 'balanced-coder' }, source: 'team-seed', citation: null },
-        { id: 'openai/gpt-5.6-sol', tiers: { high: 'frontier' }, source: 'team-seed', citation: null },
-        { id: 'openai/gpt-5.6-terra', tiers: { high: 'balanced-coder' }, source: 'team-seed', citation: null },
-      ],
-      seedDisagreements: [],
-      staleClassifications: [],
-    }),
-  })
-  assert.equal(result.ok, true)
-  assert.equal(result.implementer.tier, 'balanced-coder')
-  assert.equal(result.explorer.reason, 'balanced-coder')
-  assert.equal(result.explorer.fill.id, 'openai/gpt-5.6-terra')
-  assert.equal(result.reviewer.reason, 'team-default')
-  assert.equal(result.reviewer.fill.id, TEAM_REVIEWER_POLICY.pi.primary.id)
-  assert.equal(result.reviewer.fill.effort, 'medium')
-  assert.ok(result.deferred.afterConfirm.some((s) => s.includes('sync')))
-  assert.ok(result.deferred.doNotReadBeforeAsk.length >= 1)
-  assert.equal(result.ask.options[0].modelId, result.implementer.id)
-  assert.equal(result.ask.explorerFill.modelId, 'openai/gpt-5.6-terra')
-  assert.equal(result.diagnoser.fill.key, 'openai/gpt-6-astra@high')
-  assert.equal(result.ask.diagnoserFill.id, 'openai/gpt-6-astra@high')
-})
-
-test('CLI --ask-only prints only the ask block', () => {
-  const script = fileURLToPath(new URL('./preflight-models.mjs', import.meta.url))
-  const run = spawnSync(process.execPath, [
-    script,
-    '--harness', 'pi',
-    '--risk', 'routine',
-    '--available', 'openai/gpt-5.5,xai/grok-4.5,openai/gpt-5.6-sol,openai/gpt-5.6-terra,openai/gpt-6-astra',
-    '--ask-only',
-  ], { encoding: 'utf8' })
-  assert.equal(run.status, 0, run.stderr)
-  const ask = JSON.parse(run.stdout)
-  assert.ok(ask.question)
-  assert.ok(Array.isArray(ask.options))
-  assert.ok(ask.reviewerFill)
-  assert.ok(ask.explorerFill)
-  assert.equal(ask.options[0].description.includes('recommended'), true)
-})
-
-const pinTiered = [
-  { id: 'gpt-6-astra', tiers: { high: 'frontier' }, source: 'team-seed' },
-  { id: 'gpt-6.1-sol', tiers: { high: 'frontier' }, source: 'team-seed' },
-  { id: 'gpt-5.6-terra', tiers: { high: 'balanced-coder' }, source: 'team-seed' },
-]
-const pinRun = (implementer, tiered = pinTiered) => buildPreflightModels({
-  harness: 'codex',
-  risk: 'routine',
-  implementer,
-  discoverFn: () => ({
-    harness: 'codex',
-    completeness: 'full',
-    discovered: tiered.map(({ id }) => ({ id, source: 'current-turn' })),
-    notes: [],
-  }),
-  tierFn: () => ({ models: tiered, seedDisagreements: [], staleClassifications: [] }),
-})
-
-test('a pinned implementer is kept over the recommendation and is the only option', () => {
-  const result = pinRun('gpt-5.6-terra')
-  assert.equal(result.ok, true)
-  assert.equal(result.pinned, 'gpt-5.6-terra')
-  assert.equal(result.implementer.key, 'gpt-5.6-terra@high', 'the ladder would have picked gpt-6.1-sol@high')
-  assert.deepEqual(result.ask.options.map((o) => o.id), ['gpt-5.6-terra@high'])
-  assert.deepEqual(result.ask.alternates, [])
-  assert.equal(result.ask.pinned, true)
-  assert.notEqual(result.reviewer.fill.id, 'gpt-5.6-terra', 'the reviewer still differs from the pinned implementer')
-})
-
-test('a pin with an effort matches that operating point only', () => {
-  assert.equal(pinRun('gpt-6-astra@high').implementer.key, 'gpt-6-astra@high')
-  const wrongEffort = pinRun('gpt-6-astra@max')
-  assert.equal(wrongEffort.ok, false)
-  assert.equal(wrongEffort.code, 'pinned-implementer-unavailable')
-})
-
-test('an unavailable pinned implementer blocks instead of falling back', () => {
-  const result = pinRun('cory-model')
-  assert.equal(result.ok, false)
-  assert.equal(result.code, 'pinned-implementer-unavailable')
-  assert.equal(result.implementer, null)
-  assert.equal(result.ask, null)
-  assert.match(result.reason, /never substitute/)
-})
-
-test('no pin keeps the recommendation and the full option list', () => {
-  const result = pinRun(null)
-  assert.equal(result.pinned, undefined)
-  assert.equal(result.implementer.key, 'gpt-6.1-sol@high')
-  assert.ok(result.ask.options.length > 1)
-  assert.equal(result.ask.pinned, undefined)
-})
-
-test('CLI exits 0 with the unavailable pin in the output and rejects an empty one with 2', () => {
-  const script = fileURLToPath(new URL('./preflight-models.mjs', import.meta.url))
-  const run = (extra) => spawnSync(process.execPath, [
-    script, '--harness', 'pi', '--available', 'openai/gpt-5.6-terra', ...extra,
-  ], { encoding: 'utf8' })
-  const missing = run(['--implementer', 'openai/not-a-model'])
-  assert.equal(missing.status, 0, missing.stderr)
-  assert.equal(JSON.parse(missing.stdout).ok, false)
-  assert.equal(JSON.parse(missing.stdout).code, 'pinned-implementer-unavailable')
-  assert.equal(run(['--implementer=']).status, 2)
-  assert.equal(run(['--implementer']).status, 2, 'a flag with no value never falls back to the recommendation')
-})