@1aboveio/skills 1.0.8 → 1.0.10

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

@@ -1,366 +0,0 @@
-// Tests for model-catalog — pure core + CLI round-trip (exit codes), no network.
-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 {
-  PRUNE_AFTER_DAYS, syncCatalog, bankEntry, readCatalog, writeCatalog, pathForHarness,
-  EFFORTS, DEFAULT_EFFORT, TIERS, SLOT_ELIGIBLE_TIERS, normalizeTier, operatingPoints, tierAt, toTiers,
-} from './model-catalog.mjs'
-
-const SCRIPT = fileURLToPath(new URL('./bin/model-catalog.mjs', import.meta.url))
-const tmpFile = () => path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'model-catalog-test-')), 'catalog.json')
-
-const entry = (id, lastSeenAt, confirmedAt = '2026-01-01') => ({ id, family: 'x', tier: 'frontier', confirmedAt, ...(lastSeenAt ? { lastSeenAt } : {}) })
-
-// ---- syncCatalog: the rule-4 predicate in one place ----
-
-// @covers package:harness-runtime
-// @level unit
-test('sync bumps lastSeenAt for seen ids and keeps fresh unseen entries', () => {
-  const { catalog, bumped, pruned } = syncCatalog(
-    { models: [entry('a', '2026-05-01'), entry('b', '2026-06-01')] },
-    ['a'],
-    '2026-07-13',
-  )
-  assert.deepEqual(bumped, ['a'])
-  assert.deepEqual(pruned, [])
-  assert.equal(catalog.models.find((m) => m.id === 'a').lastSeenAt, '2026-07-13')
-  assert.equal(catalog.models.find((m) => m.id === 'b').lastSeenAt, '2026-06-01') // unseen: untouched
-})
-
-test('sync prunes strictly after PRUNE_AFTER_DAYS — day 60 kept, day 61 pruned', () => {
-  // 2026-05-14 is exactly 60 days before 2026-07-13; 2026-05-13 is 61.
-  const { catalog, pruned } = syncCatalog(
-    { models: [entry('kept', '2026-05-14'), entry('gone', '2026-05-13')] },
-    [],
-    '2026-07-13',
-  )
-  assert.equal(PRUNE_AFTER_DAYS, 60)
-  assert.deepEqual(pruned, ['gone'])
-  assert.deepEqual(catalog.models.map((m) => m.id), ['kept'])
-})
-
-test('sync falls back to confirmedAt when lastSeenAt is absent (pre-field entries)', () => {
-  const { pruned } = syncCatalog(
-    { models: [entry('old', null, '2026-01-01'), entry('new', null, '2026-07-01')] },
-    [],
-    '2026-07-13',
-  )
-  assert.deepEqual(pruned, ['old'])
-})
-
-test('sync bumps before pruning — a stale entry rediscovered this run survives', () => {
-  const { catalog, pruned } = syncCatalog(
-    { models: [entry('back', '2026-01-01')] },
-    ['back'],
-    '2026-07-13',
-  )
-  assert.deepEqual(pruned, [])
-  assert.equal(catalog.models[0].lastSeenAt, '2026-07-13')
-})
-
-// ---- bankEntry: rule-2 classification writes ----
-
-test('bank appends a new entry stamped with confirmedAt + lastSeenAt', () => {
-  const c = bankEntry({ models: [] }, { id: 'm', family: 'openai', tier: 'balanced-coder' }, '2026-07-13')
-  assert.deepEqual(c.models, [{ id: 'm', family: 'openai', tiers: { high: 'balanced-coder' }, confirmedAt: '2026-07-13', lastSeenAt: '2026-07-13' }])
-})
-
-test('bank overwrites an existing id (human correction) and refreshes confirmedAt', () => {
-  const c = bankEntry(
-    { models: [entry('m', '2026-06-01')] },
-    { id: 'm', family: 'openai', tier: 'balanced-coder' },
-    '2026-07-13',
-  )
-  assert.equal(c.models.length, 1)
-  assert.deepEqual(c.models[0].tiers, { high: 'balanced-coder' })
-  assert.equal(c.models[0].confirmedAt, '2026-07-13')
-})
-
-test('bank rejects entries missing id/family/tier or with an unknown tier', () => {
-  assert.throws(() => bankEntry({ models: [] }, { family: 'x', tier: 'frontier' }, '2026-07-13'))
-  assert.throws(() => bankEntry({ models: [] }, { id: 'm', tier: 'frontier' }, '2026-07-13'))
-  assert.throws(() => bankEntry({ models: [] }, { id: 'm', family: 'x' }, '2026-07-13')) // neither tier nor tiers
-  assert.throws(() => bankEntry({ models: [] }, { id: 'm', family: 'x', tier: 'huge' }, '2026-07-13'))
-})
-
-// ---- operating points: tier = f(model, effort), banked once (2026-07-19) ----
-
-test('bank accepts a tiers map — one model, two operating points', () => {
-  const c = bankEntry(
-    { models: [] },
-    { id: 'gpt-5.6-terra', family: 'openai', tiers: { high: 'balanced-coder', max: 'deep-reasoner' } },
-    '2026-07-19',
-  )
-  assert.deepEqual(c.models[0].tiers, { high: 'balanced-coder', max: 'deep-reasoner' })
-  assert.equal(c.models[0].tier, undefined) // the legacy single-point field never persists
-})
-
-test('a single tier UPSERTS one point; a full tiers map REPLACES all of them', () => {
-  let c = bankEntry({ models: [] }, { id: 'terra', family: 'openai', tier: 'balanced-coder' }, '2026-07-19')
-  assert.deepEqual(c.models[0].tiers, { high: 'balanced-coder' }) // no effort -> the high point
-
-  // measured later, confirmed on its own: the existing point survives
-  c = bankEntry(c, { id: 'terra', family: 'openai', tier: 'deep-reasoner', effort: 'max' }, '2026-07-19')
-  assert.deepEqual(c.models[0].tiers, { high: 'balanced-coder', max: 'deep-reasoner' })
-
-  // a full map is the human restating the whole picture — it wins outright
-  c = bankEntry(c, { id: 'terra', family: 'openai', tiers: { max: 'deep-reasoner' } }, '2026-07-19')
-  assert.deepEqual(c.models[0].tiers, { max: 'deep-reasoner' })
-})
-
-test('an upsert onto a LEGACY-shape entry leaves no stale tier/effort behind', () => {
-  // Regression: the strip ran on the incoming entry only, so `existing.tier` was
-  // spread back in with nothing to shadow it — the stored entry then claimed a tier
-  // that could flatly contradict its own map. Reads went through toTiers and looked
-  // fine; the FILE was wrong, and the file is what a human and a cross-harness
-  // lookup (catalog rule 5) actually read.
-  const legacy = { models: [{ id: 'm', family: 'f', tier: 'mid-tier', effort: 'high', confirmedAt: '2026-06-01' }] }
-
-  const upserted = bankEntry(legacy, { id: 'm', family: 'f', tier: 'deep-reasoner', effort: 'max' }, '2026-07-19')
-  assert.equal(upserted.models[0].tier, undefined)
-  assert.equal(upserted.models[0].effort, undefined)
-  assert.deepEqual(upserted.models[0].tiers, { high: 'balanced-coder', max: 'deep-reasoner' }) // legacy point preserved
-
-  const replaced = bankEntry({ models: [{ id: 'm', family: 'f', tier: 'frontier' }] }, { id: 'm', family: 'f', tiers: { high: 'balanced-coder' } }, '2026-07-19')
-  assert.equal(replaced.models[0].tier, undefined) // never "frontier" beside a balanced-coder map
-  assert.deepEqual(replaced.models[0].tiers, { high: 'balanced-coder' })
-})
-
-test('bank refuses an entry carrying no operating points', () => {
-  // `tiers: {}` passes a truthiness guard but classifies nothing: tierAt returns
-  // null at every effort and no later sync ever flags it. Check the POINTS.
-  for (const bad of [{}, [], null]) {
-    assert.throws(
-      () => bankEntry({ models: [] }, { id: 'a', family: 'f', tiers: bad }, '2026-07-19'),
-      /tiers|operating points/,
-      `tiers: ${JSON.stringify(bad)} must be rejected`,
-    )
-  }
-  assert.throws(() => bankEntry({ models: [] }, { id: 'a', family: 'f', tiers: 'frontier' }, '2026-07-19'), /tiers/)
-})
-
-test('sync does not emit an undefined tier for an entry with no classification at all', () => {
-  const { migrated } = syncCatalog({ models: [{ id: 'nocap', family: 'f', lastSeenAt: '2026-07-18' }] }, [], '2026-07-19')
-  assert.ok(!migrated.some((m) => m.includes('undefined')), `migration line leaked undefined: ${migrated}`)
-})
-
-test('bank rejects a point below high — cheaper means a cheaper model, not a throttled one', () => {
-  for (const bad of ['low', 'medium', 'none']) {
-    assert.throws(
-      () => bankEntry({ models: [] }, { id: 'm', family: 'x', tiers: { [bad]: 'balanced-coder' } }, '2026-07-19'),
-      /effort/,
-      `effort "${bad}" must be rejected`,
-    )
-  }
-  assert.throws(() => bankEntry({ models: [] }, { id: 'm', family: 'x', tiers: { high: 'huge' } }, '2026-07-19'), /tier/)
-  assert.deepEqual(EFFORTS, ['high', 'xhigh', 'max'])
-  assert.equal(DEFAULT_EFFORT, 'high')
-})
-
-test('operatingPoints lists every banked point, strongest tier first', () => {
-  const catalog = {
-    models: [
-      { id: 'terra', family: 'openai', tiers: { high: 'balanced-coder', max: 'deep-reasoner' } },
-      { id: 'sonnet', family: 'anthropic', tiers: { high: 'balanced-coder' } },
-    ],
-  }
-  // slotEligible rides along on every point (wired to SLOT_ELIGIBLE_TIERS in 2026-07-20's
-  // audit fix); both bands here are eligible, the scoped-coder case lives in the seed tests.
-  assert.deepEqual(operatingPoints(catalog, 'terra'), [
-    { effort: 'max', tier: 'deep-reasoner', slotEligible: true },
-    { effort: 'high', tier: 'balanced-coder', slotEligible: true },
-  ])
-  assert.deepEqual(operatingPoints(catalog, 'sonnet'), [{ effort: 'high', tier: 'balanced-coder', slotEligible: true }])
-  assert.deepEqual(operatingPoints(catalog, 'unknown'), [])
-  assert.deepEqual(operatingPoints(null, 'terra'), []) // absent catalog is normal
-})
-
-test('tierAt answers what a model reaches at a given effort, null where nothing is banked', () => {
-  const catalog = { models: [{ id: 'terra', family: 'openai', tiers: { high: 'balanced-coder', max: 'deep-reasoner' } }] }
-  assert.equal(tierAt(catalog, 'terra', 'max'), 'deep-reasoner')
-  assert.equal(tierAt(catalog, 'terra', 'high'), 'balanced-coder')
-  assert.equal(tierAt(catalog, 'terra', 'xhigh'), null) // not measured -> not claimed
-  assert.equal(tierAt(catalog, 'nope', 'high'), null)
-})
-
-test('bank accepts deep-reasoner (the band below the current top end)', () => {
-  const c = bankEntry({ models: [] }, { id: 'gpt-5.5', family: 'openai', tier: 'deep-reasoner' }, '2026-07-13')
-  assert.deepEqual(c.models[0].tiers, { high: 'deep-reasoner' })
-})
-
-// ---- tier renames (2026-07-19): prior-frontier -> deep-reasoner, mid-tier -> balanced-coder ----
-
-test('bank accepts either legacy tier name and stores the current one', () => {
-  const a = bankEntry({ models: [] }, { id: 'opus', family: 'anthropic', tier: 'prior-frontier' }, '2026-07-19')
-  assert.deepEqual(a.models[0].tiers, { high: 'deep-reasoner' })
-  const b = bankEntry({ models: [] }, { id: 'sonnet', family: 'anthropic', tier: 'mid-tier', effort: 'max' }, '2026-07-19')
-  assert.deepEqual(b.models[0].tiers, { max: 'balanced-coder' })
-  assert.deepEqual(toTiers({ tiers: { high: 'prior-frontier' } }), { high: 'deep-reasoner' }) // legacy names inside a map too
-  assert.deepEqual(TIERS, ['frontier', 'deep-reasoner', 'balanced-coder', 'scoped-coder'])
-  for (const t of TIERS) assert.equal(normalizeTier(t), t) // current names pass through
-})
-
-test('sync migrates legacy tier names AND the single-point shape, reporting both', () => {
-  const { catalog, migrated } = syncCatalog(
-    {
-      models: [
-        { id: 'opus', family: 'anthropic', tier: 'prior-frontier', lastSeenAt: '2026-07-18' },
-        { id: 'terra', family: 'openai', tier: 'mid-tier', effort: 'max', lastSeenAt: '2026-07-18' },
-        { id: 'fable', family: 'anthropic', tiers: { high: 'frontier' }, lastSeenAt: '2026-07-18' },
-      ],
-    },
-    ['opus'],
-    '2026-07-19',
-  )
-  // opus: renamed value + reshaped; terra: renamed value at its banked effort;
-  // fable: already current -> absent from the report entirely.
-  assert.deepEqual(migrated, [
-    'opus: {high:prior-frontier} -> {high:deep-reasoner}',
-    'terra: {max:mid-tier} -> {max:balanced-coder}',
-  ])
-  assert.deepEqual(catalog.models.find((m) => m.id === 'opus').tiers, { high: 'deep-reasoner' })
-  assert.deepEqual(catalog.models.find((m) => m.id === 'terra').tiers, { max: 'balanced-coder' })
-  assert.deepEqual(catalog.models.find((m) => m.id === 'fable').tiers, { high: 'frontier' })
-  for (const m of catalog.models) {
-    assert.equal(m.tier, undefined) // the legacy fields are gone, not merely shadowed
-    assert.equal(m.effort, undefined)
-  }
-})
-
-test('sync reshapes a current-name single-point entry without claiming a rename', () => {
-  const { migrated } = syncCatalog(
-    { models: [{ id: 'sonnet', family: 'anthropic', tier: 'balanced-coder', lastSeenAt: '2026-07-18' }] },
-    [],
-    '2026-07-19',
-  )
-  assert.deepEqual(migrated, ['sonnet: tier/effort -> tiers map {high:balanced-coder}'])
-})
-
-test('sync migrates a legacy entry even when it never saw it', () => {
-  const { migrated } = syncCatalog(
-    { models: [{ id: 'unseen', family: 'x', tier: 'prior-frontier', lastSeenAt: '2026-07-01' }] },
-    [], // migration is not gated on discovery — it is a rename, not an observation
-    '2026-07-19',
-  )
-  assert.deepEqual(migrated, ['unseen: {high:prior-frontier} -> {high:deep-reasoner}'])
-})
-
-// ---- CLI round-trip ----
-
-function run(args, input) {
-  return spawnSync('node', [SCRIPT, ...args], { encoding: 'utf8', input })
-}
-
-test('CLI: read/sync exit 3 on an absent catalog (absent is normal)', () => {
-  const file = tmpFile()
-  assert.equal(run(['read', '--file', file]).status, 3)
-  assert.equal(run(['sync', '--file', file, '--seen', 'a']).status, 3)
-})
-
-// @covers package:harness-runtime
-// @level integration
-test('CLI: bank creates the file; sync bumps + prunes and reports both', () => {
-  const file = tmpFile()
-  assert.equal(run(['bank', JSON.stringify({ id: 'a', family: 'x', tier: 'frontier' }), '--file', file, '--today', '2026-01-01']).status, 0)
-  assert.equal(run(['bank', JSON.stringify({ id: 'b', family: 'y', tier: 'balanced-coder' }), '--file', file, '--today', '2026-07-01']).status, 0)
-
-  const sync = run(['sync', '--file', file, '--seen', 'b', '--today', '2026-07-13'])
-  assert.equal(sync.status, 0)
-  assert.deepEqual(JSON.parse(sync.stdout), { bumped: ['b'], pruned: ['a'], migrated: [] }) // a: unseen since Jan — pruned
-
-  const kept = readCatalog(file)
-  assert.deepEqual(kept.models.map((m) => m.id), ['b'])
-  assert.equal(kept.models[0].lastSeenAt, '2026-07-13')
-})
-
-test('CLI: list aliases read, help exits 0', () => {
-  const file = tmpFile()
-  assert.equal(run(['bank', JSON.stringify({ id: 'a', family: 'x', tier: 'frontier' }), '--file', file, '--today', '2026-07-13']).status, 0)
-  const list = run(['list', '--file', file])
-  assert.equal(list.status, 0)
-  assert.equal(JSON.parse(list.stdout).models[0].id, 'a')
-  assert.equal(run(['help']).status, 0)
-  assert.equal(run(['bogus']).status, 2)
-})
-
-test('CLI: bank via --stdin round-trips through read', () => {
-  const file = tmpFile()
-  assert.equal(run(['bank', '--stdin', '--file', file, '--today', '2026-07-13'], JSON.stringify({ id: 's', family: 'x', tier: 'frontier' })).status, 0)
-  const read = run(['read', '--file', file])
-  assert.equal(read.status, 0)
-  assert.equal(JSON.parse(read.stdout).models[0].id, 's')
-})
-
-// ---- per-harness catalogs (one file per harness, never shared) ----
-
-// @covers package:harness-runtime
-// @level unit
-test('pathForHarness maps the known harnesses and returns null for unknown ones', () => {
-  assert.equal(pathForHarness('claude-code', { HOME: '/h' }), '/h/.claude/model-catalog.json')
-  assert.equal(pathForHarness('codex', { HOME: '/h' }), '/h/.codex/model-catalog.json')
-  assert.equal(pathForHarness('pi', { HOME: '/h' }), '/h/.pi/agent/model-catalog.json')
-  assert.equal(pathForHarness('bogus', { HOME: '/h' }), null)
-})
-
-test('CLI: bank --harness stamps the file; a write from another harness is refused', () => {
-  const file = tmpFile()
-  assert.equal(run(['bank', JSON.stringify({ id: 'a', family: 'x', tier: 'frontier' }), '--file', file, '--harness', 'codex', '--today', '2026-07-13']).status, 0)
-  assert.equal(readCatalog(file).harness, 'codex')
-
-  // same file, different harness → refused (exit 2), catalog untouched
-  assert.equal(run(['sync', '--file', file, '--harness', 'pi', '--seen', 'a', '--today', '2026-07-13']).status, 2)
-  assert.equal(run(['bank', JSON.stringify({ id: 'b', family: 'y', tier: 'balanced-coder' }), '--file', file, '--harness', 'pi', '--today', '2026-07-13']).status, 2)
-  assert.deepEqual(readCatalog(file).models.map((m) => m.id), ['a'])
-
-  // matching harness → fine
-  assert.equal(run(['sync', '--file', file, '--harness', 'codex', '--seen', 'a', '--today', '2026-07-13']).status, 0)
-})
-
-test('CLI: bank --harness stamps a legacy (pre-field) file at its next confirmed write', () => {
-  const file = tmpFile()
-  writeCatalog(file, { models: [entry('a', '2026-07-01')] }) // no harness stamp
-  assert.equal(run(['bank', JSON.stringify({ id: 'b', family: 'y', tier: 'balanced-coder' }), '--file', file, '--harness', 'pi', '--today', '2026-07-13']).status, 0)
-  assert.equal(readCatalog(file).harness, 'pi')
-})
-
-test('CLI: --harness with no location mapping errors, path --harness resolves', () => {
-  assert.equal(run(['read', '--harness', 'bogus']).status, 2)
-  const p = run(['path', '--harness', 'pi'])
-  assert.equal(p.status, 0)
-  assert.ok(p.stdout.trim().endsWith(path.join('.pi', 'agent', 'model-catalog.json')))
-})
-
-test('writeCatalog is atomic-ish: file parses after write, tmp file removed', () => {
-  const file = tmpFile()
-  writeCatalog(file, { models: [] })
-  assert.deepEqual(JSON.parse(fs.readFileSync(file, 'utf8')), { models: [] })
-  assert.ok(!fs.existsSync(`${file}.tmp`))
-})
-
-test('scoped-coder is a bankable classification but never a slot candidate', () => {
-  // The band exists so a model that keeps turning up in discovery, but sits below the
-  // implementer floor, can be answered ONCE instead of being tagged
-  // "unconfirmed — please classify" every run. It must bank like any other tier...
-  const c = bankEntry({ models: [] }, { id: 'gemini-3.5-flash', family: 'google', tier: 'scoped-coder' }, '2026-07-20')
-  assert.deepEqual(c.models[0].tiers, { high: 'scoped-coder' })
-
-  // ...and must never reach a slot.
-  assert.ok(TIERS.includes('scoped-coder'), 'bankable')
-  assert.ok(!SLOT_ELIGIBLE_TIERS.includes('scoped-coder'), 'not proposable for implementer/reviewer')
-  assert.deepEqual(SLOT_ELIGIBLE_TIERS, ['frontier', 'deep-reasoner', 'balanced-coder'])
-})
-
-test('scoped-coder sorts below every slot-eligible band', () => {
-  // operatingPoints sorts by TIERS.indexOf, so a mis-ordered enum would float a
-  // scoped-coder above a balanced-coder in the proposal block and invite a bad pick.
-  assert.equal(TIERS.indexOf('scoped-coder'), TIERS.length - 1)
-  for (const t of SLOT_ELIGIBLE_TIERS) {
-    assert.ok(TIERS.indexOf(t) < TIERS.indexOf('scoped-coder'), `${t} must outrank scoped-coder`)
-  }
-})

package/skills/engineering/resolve-issues/scripts/cleanup-runs.test.mjs

@@ -1,280 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { execFileSync, spawnSync } from 'node:child_process'
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, readdirSync, utimesSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { EVIDENCE_MAX_BYTES, planSweep } from './cleanup-runs.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'cleanup-runs.mjs')
-const DAY_MS = 24 * 60 * 60 * 1000
-
-const git = (dir, ...args) => execFileSync('git', ['-C', dir, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
-
-function write(path, content = 'x') {
-  mkdirSync(dirname(path), { recursive: true })
-  writeFileSync(path, content)
-}
-
-// A clone of the remote at `dir`, with ignored installs, caches, and a test log.
-function clone(remote, dir) {
-  git(dirname(dir), 'clone', '--quiet', remote, dir)
-  git(dir, 'config', 'user.email', 't@example.com')
-  git(dir, 'config', 'user.name', 'T')
-  write(join(dir, 'node_modules', 'pkg', 'package.json'), '{}')
-  write(join(dir, '.cache', 'sdk', 'system.img'), 'big')
-  write(join(dir, 'test-results', 'journey.log'), 'emulator boot failed')
-  write(join(dir, 'test-results', 'avd', 'Charge.avd', 'userdata.img'), 'big')
-  return dir
-}
-
-function fixture() {
-  const base = mkdtempSync(join(tmpdir(), 'cleanup-runs-'))
-  const remote = join(base, 'remote.git')
-  const seed = join(base, 'seed')
-  execFileSync('git', ['init', '--quiet', '--bare', remote])
-  execFileSync('git', ['init', '--quiet', seed])
-  git(seed, 'config', 'user.email', 't@example.com')
-  git(seed, 'config', 'user.name', 'T')
-  write(join(seed, '.gitignore'), 'node_modules/\n.cache/\ntest-results/\n')
-  write(join(seed, 'app.js'), 'v1')
-  write(join(seed, 'docs', 'README.md'), '# tracked doc')
-  git(seed, 'add', '.')
-  git(seed, 'commit', '--quiet', '-m', 'seed')
-  git(seed, 'push', '--quiet', remote, 'HEAD:main')
-  git(remote, 'symbolic-ref', 'HEAD', 'refs/heads/main')
-  const repo = join(base, 'repo')
-  mkdirSync(repo)
-  return { base, remote, repo, rush: join(repo, '.resolve-issues', 'rush') }
-}
-
-function makeRun(rush, name, idleDays) {
-  const dir = join(rush, name)
-  write(join(dir, 'task-plan.json'), '{}')
-  const when = new Date(Date.now() - idleDays * DAY_MS)
-  utimesSync(join(dir, 'task-plan.json'), when, when)
-  return dir
-}
-
-const cli = (...args) => spawnSync(process.execPath, [script, ...args], { encoding: 'utf8' })
-const has = (dir, rel) => existsSync(join(dir, rel))
-
-test('an idle run keeps records and logs, and loses downloads, caches, and clean source', () => {
-  const { remote, repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  write(join(run, 'exploration', 'findings.json'), '{}')
-  write(join(run, 'reviews', '1131-r1', 'review.md'), 'ok')
-  write(join(run, 'reviews', '1131-r1', 'sandbox', 'sdk', 'system.img'), 'big')
-  write(join(run, 'reviews', '1131-r1', 'sandbox', 'worker.log'), 'review log')
-  write(join(run, 'diagnoses', '1136', 'deep', 'nested', 'adb.txt'), 'adb not ready')
-  write(join(run, '.tmp', 'resume-result.json'), '{}')
-  write(join(run, 'jdk17.tar.gz'), 'big')
-  mkdirSync(join(run, 'units'), { recursive: true })
-  const ws = clone(remote, join(run, 'units', '1132'))
-
-  const result = cli('--repo', repo, '--apply')
-  assert.equal(result.status, 0, result.stderr)
-
-  for (const kept of ['task-plan.json', 'exploration/findings.json', 'reviews/1131-r1/review.md', 'reviews/1131-r1/sandbox/worker.log', 'diagnoses/1136/deep/nested/adb.txt', '.tmp/resume-result.json']) {
-    assert.ok(has(run, kept), `${kept} should be kept`)
-  }
-  for (const gone of ['reviews/1131-r1/sandbox/sdk', 'jdk17.tar.gz']) assert.ok(!has(run, gone), `${gone} should be removed`)
-
-  // The clean clone keeps only its logs: no source, .git, installs, caches, or emulator disks.
-  assert.ok(has(ws, 'test-results/journey.log'))
-  for (const gone of ['app.js', 'docs', '.git', '.gitignore', 'node_modules', '.cache', 'test-results/avd']) assert.ok(!has(ws, gone), `clone ${gone} should be removed`)
-  assert.deepEqual(readdirSync(ws), ['test-results'])
-  assert.match(result.stdout, /sweep\s+units\/1132 \(clean and pushed; keeps 1 log file\(s\)/)
-  assert.match(result.stdout.trim().split('\n').at(-1), /^cleanup-runs: 1 idle run\(s\), 0 active; .*1 clean clone\(s\) emptied.*log file\(s\) kept; freed/)
-})
-
-test('a clone with unpushed commits, edits, or a stash keeps its work and logs, and loses ignored downloads', () => {
-  const { remote, repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  mkdirSync(join(run, 'units'), { recursive: true })
-
-  const committed = clone(remote, join(run, 'units', 'committed'))
-  write(join(committed, 'app.js'), 'v2')
-  git(committed, 'commit', '--quiet', '-am', 'local only')
-
-  const edited = clone(remote, join(run, 'units', 'edited'))
-  write(join(edited, 'new.js'), 'untracked work')
-
-  const stashed = clone(remote, join(run, 'units', 'stashed'))
-  write(join(stashed, 'app.js'), 'stashed work')
-  git(stashed, 'stash', '--quiet')
-
-  const result = cli('--repo', repo, '--apply')
-  assert.equal(result.status, 0, result.stderr)
-
-  assert.equal(git(committed, 'rev-list', '--count', 'HEAD', '--not', '--remotes').trim(), '1')
-  assert.ok(has(edited, 'new.js'))
-  assert.equal(git(stashed, 'stash', 'list').split('\n').filter(Boolean).length, 1)
-  for (const dir of [committed, edited, stashed]) {
-    assert.ok(has(dir, 'app.js') && has(dir, 'docs/README.md'), `${dir} keeps tracked files`)
-    assert.ok(has(dir, 'test-results/journey.log'), `${dir} keeps its log`)
-    for (const gone of ['node_modules', '.cache', 'test-results/avd']) assert.ok(!has(dir, gone), `${dir} ${gone} should be stripped`)
-  }
-  assert.match(result.stdout, /strip\s+units\/committed \(keeps 1 unpushed commit\(s\) and 1 log file\(s\)/)
-})
-
-test('past the log window only records remain; clones with work still keep their work', () => {
-  const { remote, repo, rush } = fixture()
-  const run = makeRun(rush, 'ancient', 40)
-  write(join(run, 'reviews', '1131-r1.json'), '{}')
-  write(join(run, 'reviews', '1131-r1', 'sandbox', 'worker.log'), 'old log')
-  mkdirSync(join(run, 'units'), { recursive: true })
-  const clean = clone(remote, join(run, 'units', 'clean'))
-  const busy = clone(remote, join(run, 'units', 'busy'))
-  write(join(busy, 'app.js'), 'v2')
-  git(busy, 'commit', '--quiet', '-am', 'local only')
-
-  const result = cli('--repo', repo, '--log-days', '30', '--apply')
-  assert.equal(result.status, 0, result.stderr)
-  assert.match(result.stdout, /records only, past 30 days/)
-  assert.ok(has(run, 'reviews/1131-r1.json'))
-  assert.ok(!has(run, 'reviews/1131-r1'), 'the old log and its folder go')
-  assert.ok(!existsSync(clean), 'a clean clone with no logs left is deleted')
-  assert.ok(has(busy, 'app.js'))
-  assert.ok(!has(busy, 'test-results'), 'its ignored log goes too')
-})
-
-test('text inside a tool cache is not evidence, and an oversized log is dropped', () => {
-  const { repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  write(join(run, 'home', '.npm', '_cacache', 'index.json'), '{}')
-  write(join(run, 'xdg-cache', 'pnpm', 'metadata.jsonl'), '{}')
-  write(join(run, 'builds', 'Pixel.avd', 'config.txt'), 'x')
-  write(join(run, 'logs', 'huge.log'), Buffer.alloc(EVIDENCE_MAX_BYTES + 1))
-  write(join(run, 'logs', 'small.log'), 'ok')
-
-  assert.equal(cli('--repo', repo, '--apply').status, 0)
-  for (const gone of ['home', 'xdg-cache', 'builds', 'logs/huge.log']) assert.ok(!has(run, gone), `${gone} should be removed`)
-  assert.ok(has(run, 'logs/small.log'))
-})
-
-test('a clone hidden inside a dot directory is still protected', () => {
-  const { remote, repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  mkdirSync(join(run, '.tmp'), { recursive: true })
-  const hidden = clone(remote, join(run, '.tmp', 'wip'))
-  write(join(hidden, 'app.js'), 'v2')
-  git(hidden, 'commit', '--quiet', '-am', 'local only')
-
-  assert.equal(cli('--repo', repo, '--apply').status, 0)
-  assert.ok(has(hidden, 'app.js'))
-  assert.ok(!has(hidden, 'node_modules'))
-})
-
-test('a run used recently is left alone, and a dry run removes nothing', () => {
-  const { remote, repo, rush } = fixture()
-  const active = makeRun(rush, 'active', 1)
-  write(join(active, 'units', 'scratch', 'big.img'), 'big')
-  const idle = makeRun(rush, 'idle', 10)
-  mkdirSync(join(idle, 'units'), { recursive: true })
-  clone(remote, join(idle, 'units', 'a'))
-
-  const dry = cli('--repo', repo)
-  assert.equal(dry.status, 0, dry.stderr)
-  assert.ok(has(idle, 'units/a/node_modules'))
-  assert.match(dry.stdout.trim().split('\n').at(-1), /dry run, nothing removed.*Rerun with --apply/)
-
-  assert.equal(cli('--repo', repo, '--older-than-days', '3', '--apply').status, 0)
-  assert.ok(has(active, 'units/scratch/big.img'))
-  assert.ok(!has(idle, 'units/a/node_modules'))
-})
-
-test('runs are staged by task-plan.json age', () => {
-  const { repo, rush } = fixture()
-  makeRun(rush, 'a-two', 2)
-  makeRun(rush, 'b-ten', 10)
-  makeRun(rush, 'c-forty', 40)
-  const stages = planSweep({ repo, olderThanDays: 3, logDays: 30 }).runs.map((r) => [r.run, r.stage])
-  assert.deepEqual(stages, [['a-two', 'active'], ['b-ten', 'keep-logs'], ['c-forty', 'records-only']])
-  assert.deepEqual(planSweep({ repo: join(repo, 'missing') }).runs, [])
-})
-
-test('--merged empties a merged clean workspace to its logs, even with commits that look unpushed', () => {
-  const { remote, rush } = fixture()
-  const run = makeRun(rush, 'now', 0)
-  mkdirSync(join(run, 'units'), { recursive: true })
-  const ws = clone(remote, join(run, 'units', 'merged'))
-  write(join(ws, 'app.js'), 'v2')
-  git(ws, 'commit', '--quiet', '-am', 'squash-merged upstream')
-
-  const result = cli('--merged', ws, '--apply')
-  assert.equal(result.status, 0, result.stderr)
-  assert.deepEqual(readdirSync(ws), ['test-results'])
-  assert.ok(has(ws, 'test-results/journey.log'))
-})
-
-test('--merged keeps uncommitted edits and refuses paths outside .resolve-issues', () => {
-  const { base, remote, rush } = fixture()
-  const run = makeRun(rush, 'now', 0)
-  mkdirSync(join(run, 'units'), { recursive: true })
-  const ws = clone(remote, join(run, 'units', 'dirty'))
-  write(join(ws, 'app.js'), 'uncommitted')
-
-  assert.equal(cli('--merged', ws, '--apply').status, 0)
-  assert.ok(has(ws, 'app.js') && has(ws, 'test-results/journey.log'))
-  assert.ok(!has(ws, 'node_modules'))
-
-  const outside = clone(remote, join(base, 'elsewhere'))
-  const refused = cli('--merged', outside, '--apply')
-  assert.equal(refused.status, 2)
-  assert.match(refused.stderr, /only removes workspaces under a \.resolve-issues directory/)
-  assert.ok(existsSync(outside))
-})
-
-test('a bad command exits 2 with usage', () => {
-  for (const args of [['--older-than-days', 'soon'], ['--bogus'], ['--repo'], ['--log-days', '-1']]) {
-    const result = cli(...args)
-    assert.equal(result.status, 2)
-    assert.match(result.stderr, /^usage: cleanup-runs\.mjs/)
-  }
-  const inverted = cli('--older-than-days', '10', '--log-days', '5')
-  assert.equal(inverted.status, 2)
-  assert.match(inverted.stderr, /--log-days must be at least --older-than-days/)
-})
-
-test('in a non-Git copy of a repository, only logs and text under evidence folders are kept', () => {
-  const { repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  const copy = join(run, 'units', '1132', 'test-results', 'packet', 'build-x', 'workspace')
-  write(join(copy, 'pnpm-lock.yaml'), 'lock')
-  write(join(copy, 'package.json'), '{}')
-  write(join(copy, 'docs', 'design.md'), '# copied source doc')
-  write(join(copy, 'build.log'), 'gradle failed')
-  write(join(copy, 'test-results', 'summary.json'), '{}')
-  write(join(run, 'units', '1132', 'test-results', 'packet', 'gradle', 'caches', 'meta.json'), '{}')
-  write(join(run, 'units', '1132', 'test-results', 'packet', 'result.json'), '{}')
-
-  assert.equal(cli('--repo', repo, '--apply').status, 0)
-  for (const kept of ['build.log', 'test-results/summary.json']) assert.ok(has(copy, kept), `${kept} should be kept`)
-  for (const gone of ['package.json', 'pnpm-lock.yaml', 'docs']) assert.ok(!has(copy, gone), `${gone} should be removed`)
-  assert.ok(!has(run, 'units/1132/test-results/packet/gradle'))
-  assert.ok(has(run, 'units/1132/test-results/packet/result.json'))
-})
-
-test('read-only package stores are removed, not left to abort the run', () => {
-  const { repo, rush } = fixture()
-  const run = makeRun(rush, 'old', 10)
-  const store = join(run, 'artifacts', 'pnpm-v11', 'v11')
-  write(join(store, 'files', '61', 'abc'), 'blob')
-  write(join(store, 'index.db'), 'db')
-  for (const p of [join(store, 'files', '61', 'abc'), join(store, 'index.db')]) chmodSync(p, 0o444)
-  write(join(run, 'artifacts', 'pnpm-tuple', 'store', 'blob'), 'x')
-  write(join(run, 'artifacts', 'pnpm-tuple', 'install.log'), 'kept log')
-  for (const d of [join(store, 'files', '61'), join(store, 'files'), store, join(run, 'artifacts', 'pnpm-tuple', 'store'), join(run, 'artifacts', 'pnpm-tuple')]) chmodSync(d, 0o555)
-  write(join(run, 'zz', 'worker.log'), 'kept')
-
-  const result = cli('--repo', repo, '--apply')
-  assert.equal(result.status, 0, result.stderr)
-  assert.ok(!has(run, 'artifacts/pnpm-v11'), 'the read-only store is gone')
-  assert.ok(!has(run, 'artifacts/pnpm-tuple/store'), 'a store inside a read-only folder is gone')
-  assert.ok(has(run, 'artifacts/pnpm-tuple/install.log'), 'its sibling log stays')
-  assert.ok(has(run, 'zz/worker.log'), 'later paths are still processed')
-  assert.doesNotMatch(result.stdout, /could not be removed/)
-})