@1aboveio/skills 1.0.8 → 1.0.10

package/skills/engineering/resolve-issues/scripts/size-check.test.mjs

@@ -1,458 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { sizeCheck, longestChain, SizeCheckError, ExplorationUnfinished, PACK_LINES } from './size-check.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'size-check.mjs')
-
-const unit = (id, dependsOn = []) => ({ id, dependsOn })
-// One behavior, nothing missing, cheap proof: a clean slice.
-const slice = (overrides = {}) => ({ behaviors: ['the cashier sees the total'], prerequisites: [], layers: ['android'], ...overrides })
-const proof = (overrides = {}) => ({ level: 'unit', physical: [], ...overrides })
-const SKILL = '/home/dev/.claude/skills/android-foundation/SKILL.md'
-const suite = (status, overrides = {}) => ({ what: 'emulator journey suite', status, evidence: status === 'present' ? 'scripts/journey.py; green in CI' : 'no suite in scripts/', ...(status === 'present' ? { check: 'python3 scripts/journey.py --check', local: 'python3 scripts/journey.py' } : {}), skill: SKILL, ...overrides })
-const emulator = (overrides = {}) => proof({ level: 'emulator', suite: suite('present'), ...overrides })
-const entry = (lines, sliceOverrides, proofValue = proof()) => ({ estimatedLines: lines, slice: slice(sliceOverrides), proof: proofValue })
-const estimates = (ids, lines) => ({ version: 2, units: Object.fromEntries(ids.map((id) => [id, entry(lines)])) })
-const withUnit = (findings, id, value) => ({ ...findings, units: { ...findings.units, [id]: value } })
-const FOUR = ['preview the total', 'charge once', 'recover the attempt', 'send a receipt']
-
-test('a small plan of clean slices is ok', () => {
-  const plan = { units: [unit('a'), unit('b', ['a']), unit('c')] }
-  const result = sizeCheck(plan, estimates(['a', 'b', 'c'], 800))
-  assert.equal(result.verdict, 'ok')
-  assert.deepEqual(result.units.map((u) => [u.id, u.lines, u.verdict]), [['a', 800, 'ok'], ['b', 800, 'ok'], ['c', 800, 'ok']])
-  assert.deepEqual(result.runnable, ['a', 'b', 'c'])
-  assert.deepEqual(result.held, [])
-  assert.deepEqual(result.longestChain, { length: 2, end: 'b' })
-})
-
-test('a one-unit run is checked like any other', () => {
-  assert.equal(sizeCheck({ units: [unit('a')] }, estimates(['a'], 100)).verdict, 'ok')
-  const big = sizeCheck({ units: [unit('a')] }, { version: 2, units: { a: entry(100, { behaviors: FOUR }) } })
-  assert.equal(big.verdict, 'stop', 'nothing is left to run, so the run stops')
-  assert.deepEqual(big.runnable, [])
-  assert.equal(big.held[0].id, 'a')
-})
-
-test('any number of runnable units is one run: no waves, no unit-count warning', () => {
-  // The dependency order decides what starts when; a count never splits the run.
-  const ids = Array.from({ length: 27 }, (_, i) => `u${i}`)
-  const units = ids.map((id, i) => unit(id, i > 0 && i % 5 === 0 ? [ids[i - 1]] : []))
-  const result = sizeCheck({ units }, estimates(ids, 100))
-  assert.equal(result.verdict, 'ok')
-  assert.deepEqual(result.runnable, ids)
-  assert.equal(result.waves, undefined)
-  assert.ok(!result.reasons.some((r) => /wave/.test(r.message)))
-})
-
-test('a chain of 6 or more warns but never stops the run', () => {
-  const chain = (n) => ({ units: Array.from({ length: n }, (_, i) => unit(`u${i}`, i ? [`u${i - 1}`] : [])) })
-  const ids = (n) => Array.from({ length: n }, (_, i) => `u${i}`)
-  assert.equal(sizeCheck(chain(5), estimates(ids(5), 100)).verdict, 'ok')
-  const six = sizeCheck(chain(6), estimates(ids(6), 100))
-  assert.equal(six.verdict, 'warn')
-  assert.equal(six.reasons[0].measure, 'chainUnits')
-  assert.equal(six.reasons[0].level, 'warn')
-  assert.deepEqual(six.longestChain, { length: 6, end: 'u5' })
-  assert.deepEqual(six.runnable, ids(6))
-  // A long chain with a held link: the links before it still run.
-  const held = sizeCheck(chain(8), { version: 2, units: Object.fromEntries(ids(8).map((id) => [id, id === 'u3' ? entry(100, { behaviors: FOUR }) : entry(100)])) })
-  assert.equal(held.verdict, 'hold')
-  assert.deepEqual(held.runnable, ['u0', 'u1', 'u2'])
-})
-
-test('estimated lines are scaled by 1.3 before the limits: ok to 2500, warn above, hold above 5000', () => {
-  const plan = { units: [unit('a'), unit('b')] }
-  assert.equal(sizeCheck(plan, estimates(['a', 'b'], 1923)).verdict, 'ok', '1923 x 1.3 = 2500')
-  assert.equal(sizeCheck(plan, estimates(['a', 'b'], 1925)).verdict, 'warn', '1925 x 1.3 = 2503')
-  const hold = sizeCheck(plan, withUnit(estimates(['a', 'b'], 10), 'a', entry(3847)))
-  assert.equal(hold.verdict, 'hold')
-  assert.match(hold.held[0].reasons[0], /unit a is sized at 5001 changed lines \(estimate 3847 x 1\.3\).*sub-issues/)
-  assert.equal(hold.held[0].proposedSplit, null, 'a line overrun alone has no behavior split to propose')
-  assert.deepEqual(hold.runnable, ['b'])
-})
-
-test('two or three behaviors warn; four or more hold and propose the fewest slices of at most three', () => {
-  const plan = { units: [unit('a'), unit('b')] }
-  const check = (behaviors) => sizeCheck(plan, withUnit(estimates(['a', 'b'], 100), 'a', entry(100, { behaviors })))
-  assert.equal(check(FOUR.slice(0, 1)).verdict, 'ok')
-  for (const n of [2, 3]) {
-    const result = check(FOUR.slice(0, n))
-    assert.equal(result.verdict, 'warn', `${n} behaviors`)
-    assert.deepEqual(result.runnable, ['a', 'b'])
-  }
-  const result = check(FOUR)
-  assert.equal(result.verdict, 'hold')
-  assert.equal(result.reasons[0].measure, 'behaviors')
-  assert.equal(result.reasons[0].unit, 'a')
-  assert.deepEqual(result.held[0].proposedSplit, [
-    { kind: 'behavior', title: 'preview the total; charge once', blockedBy: [] },
-    { kind: 'behavior', title: 'recover the attempt; send a receipt', blockedBy: [] },
-  ], 'two even slices, never one issue per behavior')
-  assert.deepEqual(result.runnable, ['b'])
-})
-
-test('proof: a missing suite warns and stays in the unit; it never holds the unit or becomes a prefactor', () => {
-  const missing = emulator({ suite: suite('missing', { what: 'emulator journey suite for Charge' }) })
-  const result = sizeCheck({ units: [unit('a')] }, { version: 2, units: { a: entry(100, {}, missing) } })
-  assert.equal(result.verdict, 'warn')
-  assert.deepEqual(result.runnable, ['a'])
-  assert.equal(result.reasons[0].measure, 'suite')
-  assert.equal(result.reasons[0].consideration, 'proof')
-  assert.match(result.reasons[0].message, /build the emulator journey it needs inside the unit, counted in its lines/)
-  assert.deepEqual(result.environmentChecks, [], 'a missing suite has nothing to check')
-  // Held for size, the unit's split still has no suite prefactor for every slice to wait on.
-  const big = sizeCheck({ units: [unit('a'), unit('b')] }, withUnit(estimates(['a', 'b'], 10), 'a', entry(6000, { behaviors: ['import', 'export'] }, missing)))
-  assert.deepEqual(big.held[0].proposedSplit.map((s) => [s.kind, s.blockedBy]), [['behavior', []], ['behavior', []]])
-})
-
-test('proof: one environment check per distinct suite, only for runnable units', () => {
-  const plan = { units: [unit('a'), unit('b'), unit('c'), unit('d')] }
-  const findings = {
-    version: 2,
-    units: {
-      a: entry(100, {}, emulator()),
-      b: entry(100, {}, emulator()),
-      c: entry(100, {}, proof({ level: 'browser', suite: suite('present', { what: 'Playwright', check: 'pnpm exec playwright --version' }) })),
-      d: entry(100, { behaviors: FOUR }, emulator()),
-    },
-  }
-  const result = sizeCheck(plan, findings)
-  assert.deepEqual(result.environmentChecks, [
-    { check: 'python3 scripts/journey.py --check', suite: 'emulator journey suite', units: ['a', 'b'] },
-    { check: 'pnpm exec playwright --version', suite: 'Playwright', units: ['c'] },
-  ])
-})
-
-test('proof: real-device evidence becomes one pending release-gate record and a handback, never a hold', () => {
-  const findings = { version: 2, units: { a: entry(100, {}, emulator({ physical: ['six outcomes on a real phone and tablet'] })) } }
-  const result = sizeCheck({ units: [unit('a')] }, findings)
-  assert.equal(result.verdict, 'warn')
-  assert.equal(result.reasons[0].measure, 'physical')
-  assert.deepEqual(result.verification, [{ title: 'Physical-device verification at the release gate', units: ['a'], evidence: ['#a: six outcomes on a real phone and tablet'] }])
-  assert.deepEqual(result.handback, [{ what: 'Physical-device verification at the release gate (pending): #a: six outcomes on a real phone and tablet', unit: null }])
-})
-
-test('a separate missing prerequisite only warns; in a size split the first slice builds it', () => {
-  const missing = { what: 'backend decides Money, Tax and Tip', status: 'missing', separate: true, evidence: 'no authority in backend/services' }
-  const present = { what: 'exact Sale correlation', status: 'present', evidence: 'backend/services/sale-attempt-correlation.js:40' }
-  const small = sizeCheck({ units: [unit('a')] }, { version: 2, units: { a: entry(100, { prerequisites: [present, missing] }) } })
-  assert.equal(small.verdict, 'warn')
-  assert.deepEqual(small.held, [])
-  assert.match(small.reasons[0].message, /backend decides Money, Tax and Tip \(no authority in backend\/services\); build it inside the unit/)
-  assert.deepEqual(small.units[0].missingPrerequisites, ['backend decides Money, Tax and Tip'])
-  const big = sizeCheck({ units: [unit('a'), unit('b')] }, withUnit(estimates(['a', 'b'], 10), 'a', entry(6000, { behaviors: ['preview', 'charge'], prerequisites: [missing] })))
-  assert.deepEqual(big.held[0].proposedSplit, [
-    { kind: 'behavior', title: 'preview', blockedBy: [], builds: ['backend decides Money, Tax and Tip'] },
-    { kind: 'behavior', title: 'charge', blockedBy: ['preview'] },
-  ], 'no prefactor of its own: the first slice starts at once')
-})
-
-test('a missing prerequisite that fits inside the issue only warns', () => {
-  const inside = { what: 'a format helper for the receipt total', status: 'missing', separate: false, evidence: 'no helper in android/src' }
-  const result = sizeCheck({ units: [unit('a')] }, { version: 2, units: { a: entry(100, { prerequisites: [inside] }) } })
-  assert.equal(result.verdict, 'warn')
-  assert.match(result.reasons[0].message, /must also build a format helper.*build it inside the unit/)
-  assert.deepEqual(result.held, [])
-})
-
-test('proof: emulator proof across three or more layers warns but does not hold', () => {
-  const plan = { units: [unit('a')] }
-  const two = sizeCheck(plan, { version: 2, units: { a: entry(100, { layers: ['backend', 'android'] }, emulator()) } })
-  assert.equal(two.verdict, 'ok')
-  const three = sizeCheck(plan, { version: 2, units: { a: entry(100, { layers: ['backend', 'android', 'shared'] }, emulator()) } })
-  assert.equal(three.verdict, 'warn')
-  assert.equal(three.reasons[0].measure, 'emulatorLayers')
-  const cheap = sizeCheck(plan, { version: 2, units: { a: entry(100, { layers: ['backend', 'android', 'shared'] }, proof({ level: 'database' })) } })
-  assert.equal(cheap.verdict, 'ok')
-})
-
-test('units that depend on a held unit wait with it; shared surfaces do not', () => {
-  const plan = { units: [unit('a'), unit('b', ['a']), unit('c', ['b']), unit('d'), unit('e')] }
-  plan.units[3].stacksOn = ['a']
-  const findings = withUnit(estimates(['a', 'b', 'c', 'd', 'e'], 100), 'a', entry(100, { behaviors: FOUR }))
-  const result = sizeCheck(plan, findings)
-  assert.equal(result.verdict, 'hold')
-  assert.deepEqual(result.held.map((h) => h.id), ['a'])
-  assert.deepEqual(result.units.map((u) => [u.id, u.heldBy]), [['a', []], ['b', ['a']], ['c', ['a']], ['d', []], ['e', []]])
-  assert.deepEqual(result.runnable, ['d', 'e'])
-})
-
-test('a three-behavior emulator unit runs on warnings; its separate prerequisites count in its lines', () => {
-  // Three behaviors, two separate prerequisites, emulator proof with no suite yet. It used to be
-  // held on four strong signals; now only its size can hold it, and the explorer counts the
-  // prerequisites it builds inside the unit.
-  const charge = (estimatedLines) => ({
-    estimatedLines,
-    slice: {
-      behaviors: ['preview the authoritative total', 'submit one exact Sale attempt and recover it', 'send an optional receipt'],
-      prerequisites: [
-        { what: 'exact Sale correlation (#1129)', status: 'present', evidence: 'backend/services/sale-attempt-correlation.js' },
-        { what: 'Money and Tax helpers shared with Android', status: 'missing', separate: true, evidence: 'only frontend/src/lib/money.ts' },
-        { what: 'backend Store sale authority for Money, Tax and Tip', status: 'missing', separate: true, evidence: 'no service owns it' },
-      ],
-      layers: ['backend', 'android', 'shared'],
-    },
-    proof: {
-      level: 'emulator',
-      suite: { what: 'emulator journey suite for native Charge', status: 'missing', evidence: 'no device script in scripts/', skill: SKILL },
-      physical: ['all six Charge outcomes on a real phone and tablet'],
-    },
-  })
-  const plan = { units: [unit('1131'), unit('1132')] }
-  const fits = sizeCheck(plan, withUnit(estimates(['1131', '1132'], 1550), '1131', charge(1900)))
-  assert.equal(fits.verdict, 'warn')
-  assert.deepEqual(fits.runnable, ['1131', '1132'])
-  assert.deepEqual(fits.reasons.filter((r) => r.unit === '1131').map((r) => `${r.consideration}:${r.level}:${r.measure}`), [
-    'scope:warn:behaviors', 'scope:warn:prerequisites', 'scope:warn:prerequisites',
-    'proof:warn:suite', 'proof:warn:emulatorLayers', 'proof:warn:physical',
-  ])
-  // Counting both prerequisites inside, the estimate passes the line limit: held, packed into the fewest
-  // slices that fit (two and one behaviors), the later one behind the first.
-  const counted = sizeCheck(plan, withUnit(estimates(['1131', '1132'], 1550), '1131', charge(4000)))
-  assert.equal(counted.verdict, 'hold')
-  assert.deepEqual(counted.held[0].proposedSplit.map((s) => [s.kind, s.blockedBy.length, (s.builds ?? []).length]), [['behavior', 0, 2], ['behavior', 1, 0]])
-  assert.deepEqual(counted.held[0].proposedSplit[1].blockedBy, ['preview the authoritative total; submit one exact Sale attempt and recover it'])
-  assert.deepEqual(counted.held[0].physical, ['all six Charge outcomes on a real phone and tablet'])
-})
-
-test('open product, scope or approval questions hold their unit, or stop the run when unassigned', () => {
-  const plan = { units: [unit('a'), unit('b')] }
-  const base = estimates(['a', 'b'], 10)
-  const check = (openQuestions) => sizeCheck(plan, { ...base, openQuestions })
-  assert.equal(check([{ kind: 'technical', unit: 'a', text: 'which cursor encoding?' }]).verdict, 'ok')
-  assert.equal(check([{ kind: 'approval', text: 'may we rotate the key?', resolved: true }]).verdict, 'ok')
-  for (const kind of ['product', 'scope', 'approval']) {
-    assert.equal(check([{ kind, text: 'q' }]).verdict, 'stop', kind)
-    const held = check([{ kind, unit: 'b', text: 'release go/no-go' }])
-    assert.equal(held.verdict, 'hold', kind)
-    assert.deepEqual(held.held.map((h) => h.id), ['b'])
-    assert.deepEqual(held.runnable, ['a'])
-  }
-  assert.equal(check([{ kind: 'technical', text: 'unassigned' }]).verdict, 'ok', 'technical questions are notes, never blockers')
-  assert.equal(check([{ kind: 'product', unit: 'zz', text: 'unknown unit' }]).verdict, 'stop')
-  assert.equal(check([{ text: 'no kind' }]).verdict, 'stop')
-})
-
-test('handback items are reported without affecting the verdict', () => {
-  const result = sizeCheck({ units: [unit('a')] }, { ...estimates(['a'], 10), handback: [{ what: 'run the migration on staging', unit: 'a' }] })
-  assert.equal(result.verdict, 'ok')
-  assert.deepEqual(result.handback, [{ what: 'run the migration on staging', unit: 'a' }])
-})
-
-test('unfinished exploration is its own error, not a verdict', () => {
-  const plan = { units: [unit('a'), unit('b')] }
-  const unfinished = (findings, message) => assert.throws(() => sizeCheck(plan, findings), (e) => e instanceof ExplorationUnfinished && message.test(e.message))
-  unfinished({ units: {} }, /version is undefined, expected 2/)
-  unfinished({ version: 1, units: { a: { entries: [] }, b: { entries: [] } } }, /version is 1/)
-  unfinished({ version: 2 }, /no units map/)
-  unfinished({ version: 2, units: [] }, /no units map/)
-  unfinished(estimates(['a'], 10), /no findings for unit b; continue the explorer/)
-  // The explorer's scaffold: an empty entry for every unit.
-  unfinished({ version: 2, units: { a: {}, b: {} } }, /unit a: no slice; no proof; unit b: no slice; no proof/)
-  // Findings from before the slice record existed.
-  unfinished({ version: 2, units: { a: { estimatedLines: 10 }, b: entry(10) } }, /unit a: no slice/)
-  unfinished(withUnit(estimates(['a', 'b'], 10), 'b', { estimatedLines: -1, slice: slice(), proof: proof() }), /no estimatedLines for unit b/)
-  unfinished(withUnit(estimates(['a', 'b'], 10), 'b', { slice: slice(), proof: proof() }), /no estimatedLines for unit b/)
-  unfinished({ ...estimates(['a', 'b'], 10), openQuestions: { kind: 'product' } }, /openQuestions must be a list/)
-})
-
-test('a malformed slice is unfinished exploration, named field by field', () => {
-  const plan = { units: [unit('a')] }
-  const bad = (sliceOverrides, message) => assert.throws(
-    () => sizeCheck(plan, { version: 2, units: { a: entry(10, sliceOverrides) } }),
-    (e) => e instanceof ExplorationUnfinished && message.test(e.message),
-  )
-  bad({ behaviors: [] }, /behaviors must list at least one/)
-  bad({ behaviors: ['ok', ' '] }, /behaviors must list at least one/)
-  bad({ prerequisites: undefined }, /prerequisites must be a list/)
-  bad({ prerequisites: [{ what: 'x', status: 'partial', evidence: 'y' }] }, /status \(present or missing\)/)
-  bad({ prerequisites: [{ what: 'x', status: 'present' }] }, /needs what, status.*and evidence/)
-  bad({ prerequisites: [{ what: 'x', status: 'missing', evidence: 'y' }] }, /missing prerequisite needs separate/)
-  bad({ layers: [] }, /layers must list at least one/)
-})
-
-test('a malformed proof record is unfinished exploration, named field by field', () => {
-  const plan = { units: [unit('a')] }
-  const bad = (proofValue, message) => assert.throws(
-    () => sizeCheck(plan, { version: 2, units: { a: { estimatedLines: 10, slice: slice(), proof: proofValue } } }),
-    (e) => e instanceof ExplorationUnfinished && message.test(e.message),
-  )
-  bad(undefined, /unit a: no proof/)
-  bad(proof({ level: 'device' }), /level must be one of unit, database, browser, emulator \(real devices go in proof.physical\)/)
-  bad(proof({ level: 'emulator' }), /emulator proof needs an end-to-end suite/)
-  bad(proof({ level: 'browser', suite: { what: 'x', status: 'present', evidence: 'y' } }), /present end-to-end suite needs a check command/)
-  bad(proof({ physical: 'a phone' }), /physical must be a list/)
-  bad(proof({ level: 'unit', suite: 42 }), /suite is only for browser and emulator proof/)
-  bad(emulator({ suite: suite('present', { local: undefined }) }), /needs a local command that runs one journey off CI/)
-  bad(emulator({ suite: suite('present', { local: 'gh workflow run android.yml --ref rush/1918 -f richer-smoke=true' }) }), /local must run off CI, not dispatch it/)
-  bad(emulator({ suite: suite('present', { local: 'gh run rerun 39273527350 --failed' }) }), /local must run off CI, not dispatch it/)
-  bad(emulator({ suite: suite('present', { local: 'gh api -X POST repos/o/r/actions/workflows/android.yml/dispatches -f ref=main' }) }), /local must run off CI, not dispatch it/)
-  bad(emulator({ suite: suite('missing', { skill: undefined }) }), /skill must be the absolute SKILL.md path/)
-  bad(emulator({ suite: suite('present', { skill: 'android-foundation' }) }), /skill must be the absolute SKILL.md path/)
-})
-
-test('proof: a present suite may check through CI when its local command runs off CI; skill may be null', () => {
-  const ci = suite('present', { check: 'gh workflow run android.yml --ref <unit-branch> -f richer-smoke=true', local: 'bash scripts/android-foundation-journeys.sh', skill: null })
-  const result = sizeCheck({ units: [unit('a')] }, { version: 2, units: { a: entry(100, {}, emulator({ suite: ci })) } })
-  assert.equal(result.verdict, 'ok')
-  // A dispatch checks nothing on this host: the first implementer runs the local journey instead.
-  assert.deepEqual(result.environmentChecks, [{ check: 'bash scripts/android-foundation-journeys.sh', suite: 'emulator journey suite', units: ['a'] }])
-})
-
-test('findings for units no longer in the plan are ignored', () => {
-  assert.equal(sizeCheck({ units: [unit('a')] }, estimates(['a', 'trimmed'], 10)).verdict, 'ok')
-})
-
-test('a broken plan is a plan error, not unfinished exploration', () => {
-  const planError = (e) => e instanceof SizeCheckError && !(e instanceof ExplorationUnfinished)
-  assert.throws(() => sizeCheck({ units: [] }, {}), planError)
-  assert.throws(() => sizeCheck({ units: [unit('a', ['b']), unit('b', ['a'])] }, estimates(['a', 'b'], 10)), planError)
-  assert.throws(() => sizeCheck({ units: [{ title: 'no id' }] }, {}), /needs an id/)
-  assert.throws(() => sizeCheck({ units: [{ id: 'a', dependsOn: 'b' }] }, {}), (e) => planError(e) && /dependsOn must be a list/.test(e.message))
-  assert.throws(() => longestChain([unit('a', ['b']), unit('b', ['a'])]), /cycle/)
-  assert.throws(() => longestChain([unit('a', ['zz'])]), /unknown dependency zz/)
-})
-
-test('CLI exits 0 with the verdict in the output for ok, hold, stop, and unfinished exploration; 2 on a bad plan', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'size-check-'))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, JSON.stringify(value)); return p }
-  const run = (plan, findings, ...extra) => spawnSync(process.execPath, [script, '--plan', plan, '--findings', findings, ...extra], { encoding: 'utf8' })
-  const okPlan = write('ok.json', { units: [unit('a')] })
-  const f = write('f.json', estimates(['a'], 10))
-  const ok = run(okPlan, f)
-  assert.equal(ok.status, 0, ok.stderr)
-  assert.equal(JSON.parse(ok.stdout).verdict, 'ok')
-  const twoPlan = write('two.json', { units: [unit('a'), unit('b')] })
-  const holdFindings = write('h.json', withUnit(estimates(['a', 'b'], 10), 'a', entry(10, { behaviors: FOUR })))
-  const hold = run(twoPlan, holdFindings)
-  assert.equal(hold.status, 0, hold.stderr)
-  assert.equal(JSON.parse(hold.stdout).verdict, 'hold')
-  assert.deepEqual(JSON.parse(hold.stdout).runnable, ['b'])
-  const stopFindings = write('q.json', { ...estimates(['a'], 10), openQuestions: [{ kind: 'scope', text: 'x' }] })
-  const stop = run(okPlan, stopFindings)
-  assert.equal(stop.status, 0, stop.stderr)
-  assert.equal(JSON.parse(stop.stdout).verdict, 'stop')
-  const unfinished = run(twoPlan, f)
-  assert.equal(unfinished.status, 0, unfinished.stderr)
-  assert.equal(unfinished.stderr, '')
-  const answer = JSON.parse(unfinished.stdout)
-  assert.equal(answer.verdict, 'exploration-unfinished')
-  assert.match(answer.reason, /no findings for unit b/)
-  assert.equal(JSON.parse(run(okPlan, join(dir, 'no-findings.json')).stdout).verdict, 'exploration-unfinished')
-  // bad plan or command: the script could not answer
-  assert.equal(run(join(dir, 'missing.json'), f).status, 2)
-  assert.equal(run(write('cycle.json', { units: [unit('a', ['b']), unit('b', ['a'])] }), f).status, 2)
-  assert.equal(spawnSync(process.execPath, [script, '--plan', okPlan], { encoding: 'utf8' }).status, 2)
-  // --exit-verdict restores the old codes (deprecated)
-  assert.equal(run(okPlan, f, '--exit-verdict').status, 0)
-  assert.equal(run(twoPlan, holdFindings, '--exit-verdict').status, 4)
-  assert.equal(run(okPlan, stopFindings, '--exit-verdict').status, 1)
-  const legacyUnfinished = run(twoPlan, f, '--exit-verdict')
-  assert.equal(legacyUnfinished.status, 3)
-  assert.equal(JSON.parse(legacyUnfinished.stdout).verdict, 'exploration-unfinished')
-  assert.equal(run(join(dir, 'missing.json'), f, '--exit-verdict').status, 2)
-})
-
-test('a prerequisite named twice in a held unit is built once, by the first slice', () => {
-  const name = 'emulator journey suite'
-  const findings = { version: 2, units: { a: entry(6000,
-    { behaviors: ['import', 'export'], prerequisites: [{ what: name, status: 'missing', separate: true, evidence: 'none' }, { what: 'Emulator journey suite ', status: 'missing', separate: true, evidence: 'none' }] }) } }
-  const split = sizeCheck({ units: [unit('a'), unit('b')] }, withUnit(findings, 'b', entry(10))).held[0].proposedSplit
-  assert.deepEqual(split[0].builds, [name])
-  assert.deepEqual(split.at(-1).blockedBy, ['import'])
-})
-
-test('older findings that call the suite `harness` still check', () => {
-  const legacy = { level: 'browser', harness: { what: 'Playwright', status: 'missing', evidence: 'none', skill: null }, physical: [] }
-  const result = sizeCheck({ units: [unit('a'), unit('b')] }, withUnit(estimates(['a', 'b'], 10), 'a', { estimatedLines: 10, slice: slice(), proof: legacy }))
-  assert.equal(result.reasons.find((r) => r.unit === 'a').measure, 'suite')
-  assert.equal(result.units[0].suite, 'missing')
-})
-
-test('a lines hold splits along behaviors when there are two or more; otherwise the human decides', () => {
-  const plan = { units: [unit('a'), unit('b')] }
-  const held = (behaviors) => sizeCheck(plan, withUnit(estimates(['a', 'b'], 10), 'a', entry(6000, { behaviors }))).held[0]
-  assert.deepEqual(held(['import', 'export']).proposedSplit.map((s) => s.title), ['import', 'export'])
-  assert.equal(held(['import']).proposedSplit, null)
-  const question = sizeCheck(plan, { ...estimates(['a', 'b'], 10), openQuestions: [{ kind: 'product', unit: 'a', text: 'q' }] })
-  assert.equal(question.held[0].proposedSplit, null)
-})
-
-test('the device record is one per run and lists only units that will run', () => {
-  const plan = { units: [unit('a'), unit('b', ['a']), unit('c')] }
-  const device = emulator({ physical: ['on a real tablet'] })
-  const findings = { version: 2, units: { a: entry(100, { behaviors: FOUR }, device), b: entry(100, {}, device), c: entry(100, {}, device) } }
-  const result = sizeCheck(plan, findings)
-  assert.equal(result.verification.length, 1)
-  assert.deepEqual(result.verification[0].units, ['c'])
-  assert.equal(result.handback.length, 1)
-})
-
-test('a plan treats parents merged by an earlier run as met, not unknown', () => {
-  const plan = { merged: ['p'], units: [unit('c', ['p']), unit('d', ['c'])] }
-  const result = sizeCheck(plan, estimates(['c', 'd'], 100))
-  assert.equal(result.verdict, 'ok')
-  assert.deepEqual(result.runnable, ['c', 'd'])
-  assert.throws(() => sizeCheck({ units: [unit('c', ['p'])] }, estimates(['c'], 100)), /unknown dependency p/, 'an unmerged missing parent is still an error')
-  assert.throws(() => sizeCheck({ merged: 'p', units: [unit('c')] }, estimates(['c'], 100)), SizeCheckError)
-})
-
-test("a missing prerequisite that repeats the unit's own behavior is unfinished exploration", () => {
-  const findings = { version: 2, units: { a: entry(100, { behaviors: ['Persist the Charge layout'], prerequisites: [{ what: 'persist the charge layout', status: 'missing', separate: false, evidence: 'not in app/' }] }) } }
-  assert.throws(() => sizeCheck({ units: [unit('a')] }, findings), (e) => e instanceof ExplorationUnfinished && /own behavior/.test(e.message))
-})
-
-// ---- Proof-only units: split along proof groups ----
-
-const campaign = (groups, setups = []) => entry(
-  groups.reduce((sum, g) => sum + g.estimatedLines, 0) + setups.reduce((sum, su) => sum + su.estimatedLines, 0),
-  { behaviors: ['staff use the merged Merchant interface on Android'], newProductBehaviorCount: 0 },
-  proof({ groups, setups }),
-)
-
-test('a held proof-only campaign splits into a setup prefactor and the fewest group slices under 3,800 lines', () => {
-  // fmm #1343: an acceptance-only campaign of 25 groups held at 5,940 x 1.3 had no split to propose.
-  const setups = [{ id: 'device', what: 'owned emulator, database, and fixture pool', estimatedLines: 900 }]
-  const groups = Array.from({ length: 25 }, (_, i) => ({ id: `g${i + 1}`, covers: `#${1300 + i}`, estimatedLines: 200, setup: i < 20 ? 'device' : null }))
-  const result = sizeCheck({ units: [unit('1343')] }, { version: 2, units: { 1343: campaign(groups, setups) } })
-  assert.equal(result.verdict, 'stop')
-  const split = result.held[0].proposedSplit
-  assert.deepEqual(split[0], { kind: 'prefactor', title: 'Shared setup: owned emulator, database, and fixture pool', estimatedLines: 900, blockedBy: [] })
-  const slices = split.slice(1)
-  assert.ok(slices.every((s) => s.kind === 'proof' && s.estimatedLines < PACK_LINES), 'every slice fits')
-  assert.deepEqual(slices.flatMap((s) => s.groups), groups.map((g) => g.id), 'every group lands in exactly one slice, in order')
-  assert.deepEqual(slices.map((s) => s.groups.length), [18, 2, 5], 'groups sharing a setup pack together; the rest pack apart')
-  assert.deepEqual(slices[0].blockedBy, ['Shared setup: owned emulator, database, and fixture pool'])
-  assert.deepEqual(slices[2].blockedBy, [], 'groups with no setup wait on nothing')
-  assert.match(slices[0].title, /^Proof: g1, g2, .* \(#1300, #1301, /)
-})
-
-test('a proof-only split keeps prerequisite prefactors ahead of the groups', () => {
-  const groups = [{ id: 'a', covers: '#1', estimatedLines: 1800 }, { id: 'b', covers: '#2', estimatedLines: 1800 }, { id: 'c', covers: '#3', estimatedLines: 1800 }]
-  const unitEntry = campaign(groups)
-  unitEntry.slice.prerequisites = [{ what: 'a seeded fixture pool', status: 'missing', separate: true, evidence: 'none in scripts/' }]
-  const split = sizeCheck({ units: [unit('x')] }, { version: 2, units: { x: unitEntry } }).held[0].proposedSplit
-  assert.deepEqual(split.map((s) => [s.kind, s.groups ?? s.title, s.blockedBy]), [
-    ['prefactor', 'a seeded fixture pool', []],
-    ['proof', ['a', 'b'], ['a seeded fixture pool']],
-    ['proof', ['c'], ['a seeded fixture pool']],
-  ])
-})
-
-test('proof groups are required, valid, and small for a proof-only unit, and only for one', () => {
-  const run = (value) => () => sizeCheck({ units: [unit('x')] }, { version: 2, units: { x: value } })
-  assert.throws(run(entry(500, { newProductBehaviorCount: 0 })), (e) => e instanceof ExplorationUnfinished && /needs proof.groups/.test(e.message))
-  assert.throws(run(campaign([{ id: 'a', covers: '#1', estimatedLines: 2000 }])), /group a is estimated at 2000 lines; split it below 1900/)
-  assert.throws(run(campaign([{ id: 'a', covers: '#1', estimatedLines: 100, setup: 'nope' }])), /names setup nope/)
-  assert.throws(run(campaign([{ id: 'a', covers: '#1', estimatedLines: 100 }, { id: 'a', covers: '#2', estimatedLines: 100 }])), /listed twice/)
-  assert.throws(run(entry(500, {}, proof({ groups: [{ id: 'a', covers: '#1', estimatedLines: 1 }] }))), /only for a unit with slice.newProductBehaviorCount 0/)
-  assert.throws(run(entry(500, { newProductBehaviorCount: -1 })), /whole number/)
-  assert.equal(sizeCheck({ units: [unit('x')] }, { version: 2, units: { x: campaign([{ id: 'a', covers: '#1', estimatedLines: 400 }]) } }).verdict, 'ok', 'a small proof-only unit runs as is')
-})

package/skills/engineering/resolve-release/scripts/apply.test.mjs

@@ -1,99 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { applyRelease, bumpPyproject, insertChangelog } from './apply.mjs'
-
-test('insertChangelog cuts Unreleased and keeps handwritten notes', () => {
-  const before = `# Changelog\n\n## [Unreleased]\n\n- operator note\n\n## [1.0.0] - 2026-01-01\n`
-  const after = insertChangelog(before, {
-    version: '1.1.0',
-    date: '2026-08-24',
-    section: '## [1.1.0] - 2026-08-24\n\n### Added\n- export csv\n',
-  })
-  assert.match(after, /## \[Unreleased\]\n\n## \[1\.1\.0\] - 2026-08-24/)
-  assert.match(after, /export csv/)
-  assert.match(after, /operator note/)
-  assert.match(after, /## \[1\.0\.0\]/)
-  assert.equal((after.match(/## \[1\.1\.0\]/g) || []).length, 1)
-})
-
-test('insertChangelog is idempotent only when the recorded section is present', () => {
-  const section = '## [1.1.0] - 2026-08-24\n\n### Added\n- export csv'
-  const md = `# Changelog\n\n${section}\n`
-  assert.equal(insertChangelog(md, { version: '1.1.0', date: '2026-08-24', section }), md)
-  assert.throws(
-    () => insertChangelog(md, {
-      version: '1.1.0',
-      date: '2026-08-24',
-      section: '## [1.1.0] - 2026-08-24\n\n### Added\n- missing entry',
-    }),
-    /does not match the recorded plan/,
-  )
-})
-
-test('bumpPyproject replaces [project] version only', () => {
-  const text = '[build-system]\nrequires = ["setuptools"]\n\n[project]\nname = "demo"\nversion = "0.1.0"\n'
-  assert.match(bumpPyproject(text, '0.2.0'), /\[project\]\nname = "demo"\nversion = "0\.2\.0"/)
-})
-
-test('applyRelease writes changelog and identity files', () => {
-  const cwd = mkdtempSync(join(tmpdir(), 'rush-release-apply-'))
-  writeFileSync(join(cwd, 'package.json'), `${JSON.stringify({ name: 'demo', version: '1.2.0' }, null, 2)}\n`)
-  writeFileSync(join(cwd, 'package-lock.json'), `${JSON.stringify({ name: 'demo', version: '1.2.0', packages: { '': { name: 'demo', version: '1.2.0' } } }, null, 2)}\n`)
-  writeFileSync(join(cwd, 'VERSION'), '1.2.0\n')
-  writeFileSync(join(cwd, 'CHANGELOG.md'), '# Changelog\n\n## [Unreleased]\n\n')
-  const result = applyRelease({
-    version: '1.3.0',
-    date: '2026-08-24',
-    cwd,
-    changelogSection: '## [1.3.0] - 2026-08-24\n\n### Added\n- export csv\n',
-  })
-  assert.deepEqual(result.changed.sort(), ['CHANGELOG.md', 'VERSION', 'package-lock.json', 'package.json'])
-  assert.equal(JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8')).version, '1.3.0')
-  assert.equal(JSON.parse(readFileSync(join(cwd, 'package-lock.json'), 'utf8')).packages[''].version, '1.3.0')
-  assert.equal(readFileSync(join(cwd, 'VERSION'), 'utf8'), '1.3.0\n')
-  assert.match(readFileSync(join(cwd, 'CHANGELOG.md'), 'utf8'), /export csv/)
-})
-
-test('applyRelease refuses to discard the recorded plan changelog', () => {
-  assert.throws(
-    () => applyRelease({ version: '1.3.0', date: '2026-08-24' }),
-    /requires the recorded plan changelog/,
-  )
-})
-
-test('applyRelease delegates a distribution release without adding a version to the private root package', () => {
-  const cwd = mkdtempSync(join(tmpdir(), 'rush-release-distribution-apply-'))
-  mkdirSync(join(cwd, 'skills/distribution'), { recursive: true })
-  writeFileSync(join(cwd, 'package.json'), `${JSON.stringify({ name: 'private-root', private: true }, null, 2)}\n`)
-  writeFileSync(join(cwd, 'skills/distribution/manifest.json'), `${JSON.stringify({
-    releaseVersion: '0.19.0',
-    sources: [{ renderTargets: [{ id: 'private-checkout', revision: 'main' }] }],
-  }, null, 2)}\n`)
-  writeFileSync(join(cwd, 'CHANGELOG.md'), '# Changelog\n\n')
-  const calls = []
-
-  const result = applyRelease({
-    version: '0.19.1',
-    date: '2026-08-30',
-    cwd,
-    changelogSection: '## [0.19.1] - 2026-08-30\n\n### Changed\n- manual trigger only\n',
-    cutDistribution: (options) => {
-      calls.push(options)
-      return ['skills/distribution/manifest.json', 'skills/engineering/engineering-runtime/coherence/workflow.json']
-    },
-  })
-
-  assert.deepEqual(calls, [{ version: '0.19.1', cwd }])
-  assert.deepEqual(result.changed, [
-    'CHANGELOG.md',
-    'skills/distribution/manifest.json',
-    'skills/engineering/engineering-runtime/coherence/workflow.json',
-  ])
-  assert.deepEqual(JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8')), {
-    name: 'private-root',
-    private: true,
-  })
-})