@1aboveio/skills 1.0.7 → 1.0.9

package/skills/engineering/resolve-issues/scripts/next-actions.test.mjs

@@ -1,915 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { nextActions as scheduleActions, readReviews, readActivity, readQuestions, parseCliArgs, NextActionsError, RULES, SKILL_PATH } from './next-actions.mjs'
-
-// Existing workflow cases use an explicit fixture budget; live-capacity cases are separate.
-const nextActions = (plan, reviews = {}, capacity = 4, options = {}) => scheduleActions(plan, reviews, capacity, options)
-const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'next-actions.mjs')
-const plan = (units, extra = {}) => ({ skill: 'resolve-issues', deliveryMode: 'stack', mergeMode: 'autonomous', units, ...extra })
-const kinds = (r) => r.due.map((a) => `${a.action}:${a.unit ?? ''}`)
-
-test('a free slot and a pending unit with met dependencies: fill the slot', () => {
-  const r = nextActions(plan([{ id: 'a', status: 'pending', stage: 'pending' }, { id: 'b', status: 'pending', dependsOn: ['a'] }]))
-  assert.deepEqual(kinds(r), ['fill-slot:a'])
-})
-
-test('a unit waiting on an excluded issue stays not started, and the run can finish around it', () => {
-  // A unit waits on environment work the run recorded as excluded: starting it
-  // would retry work only a human can unblock. It is not started, never blocked.
-  const excluded = [{ issue: 'o/r#1800', reason: 'environment the run cannot build' }]
-  const units = [{ id: '1801', status: 'pending', dependsOn: ['1800'] }, { id: '1802', status: 'pending' }]
-  assert.deepEqual(kinds(nextActions(plan(units, { spec: 'o/r#1', excluded }))), ['fill-slot:1802'])
-  const rest = [{ id: '1801', status: 'pending', dependsOn: ['1800'] }, { id: '1802', status: 'succeeded' }]
-  const r = nextActions(plan(rest, { spec: 'o/r#1', excluded }))
-  assert.deepEqual(kinds(r), ['finish:'])
-  assert.match(r.due[0].detail, /not started: 1801 \(waits on 1800\)/)
-  const legacy = [{ id: '1801', status: 'blocked', dependsOn: ['1800'] }, { id: '1802', status: 'succeeded' }]
-  assert.deepEqual(kinds(nextActions(plan(legacy, { spec: 'o/r#1', excluded }), {}, 4, { resume: true })), ['finish:'])
-  assert.deepEqual(kinds(nextActions(plan(units, { spec: 'o/r#1' }))), ['fill-slot:1801', 'fill-slot:1802'])
-})
-
-test('a unit behind a blocked unit is not started: it gets no action and does not hold finish', () => {
-  const units = [
-    { id: 'a', status: 'blocked', stage: 'implement', blockedReason: 'retry-implement', autoRetries: 3 },
-    { id: 'b', status: 'pending', dependsOn: ['a'] },
-    { id: 'c', status: 'pending', dependsOn: ['b'] },
-    { id: 'd', status: 'succeeded' },
-  ]
-  const r = nextActions(plan(units))
-  assert.deepEqual(kinds(r), ['finish:'])
-  assert.match(r.due[0].detail, /not started: b \(waits on a\), c \(waits on a\)/)
-})
-
-test('--resume reopens a unit wrongly marked blocked while it waited on its parents as not started', () => {
-  // A coordinator marked dependents blocked while their parent was still coding; reopening them
-  // in flight would resume them before their parent's code exists.
-  const units = [
-    { id: 'p', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement' },
-    { id: 'c', status: 'blocked', stage: 'implement', dependsOn: ['p'] },
-  ]
-  const r = nextActions(plan(units), {}, 4, { resume: true })
-  assert.deepEqual(kinds(r), ['unblock:c'], 'unblocked, but not resumed: its parent is still coding')
-  const ready = [{ ...units[0], stage: 'done', worker: null }, units[1]]
-  assert.deepEqual(kinds(nextActions(plan(ready), {}, 4, { resume: true })), ['unblock:c', 'open-pr:p', 'resume:c'], 'once the parent is done, it resumes in its kept workspace')
-  const partial = [units[0], { ...units[1], stage: 'validate', headSha: 'abc1234', workspace: '/w/c' }]
-  const early = nextActions(plan(partial), {}, 4, { resume: true })
-  assert.deepEqual(kinds(early), ['unblock:c'], 'partial commits do not let it run ahead of its parent')
-  assert.match(early.due[0].detail, /only waits on p: set it pending \(not started\)/)
-  const later = nextActions(plan([{ ...units[0], stage: 'done', worker: null }, { ...partial[1], status: 'pending' }]))
-  assert.match(later.due.find((a) => a.unit === 'c').detail, /in its kept workspace/)
-})
-
-test('a child starts once its parent code is done in both modes; in wait mode its PR waits for the merge', () => {
-  // wiki-kb #12 (no queue): children idled 45-114 minutes per hop until each parent merged.
-  const units = [{ id: 'p', status: 'in-flight', stage: 'done', worker: 1, workerKind: 'implement' }, { id: 'c', status: 'pending', dependsOn: ['p'] }]
-  assert.deepEqual(kinds(nextActions(plan(units))), ['fill-slot:c'])
-  assert.deepEqual(kinds(nextActions(plan(units, { deliveryMode: 'wait' }))), ['fill-slot:c'])
-  const coded = [{ id: 'p', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaa', worker: 1, workerKind: 'implement' }, { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['p'] }]
-  assert.deepEqual(kinds(nextActions(plan(coded, { deliveryMode: 'wait' }))), [], 'no PR until the parent merges')
-  const merged = nextActions(plan([{ ...coded[0], status: 'succeeded' }, coded[1]], { deliveryMode: 'wait' }))
-  assert.deepEqual(kinds(merged), ['open-pr:c'])
-  assert.match(merged.due[0].detail, /rebase it onto the target first/)
-})
-
-test('chain mode: a finished unit chains on the open run PR it shares files with, as soon as that PR is open', () => {
-  // skyee-ai-risk #3097: in wait mode 12 PRs edited the same six registration files; #3120's merge
-  // dequeued three queued PRs on conflicts and the run rebuilt everything as a hand-made train.
-  const pr = (id, files, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `rush/${id}`, files, ...extra })
-  const chainPlan = (units) => plan(units, { deliveryMode: 'chain' })
-  const open = (r, id) => r.due.find((a) => a.action === 'open-pr' && a.unit === id).detail
-  const shared = nextActions(chainPlan([pr('a', ['ci.yml', 'svc.py']), pr('b', ['docs/b.md']), { id: 'c', status: 'in-flight', stage: 'done', files: ['svc.py', 'c.py'] }]))
-  // stack mode picks its parent the same way; only the PR base differs.
-  const stackShared = nextActions(plan([pr('a', ['ci.yml', 'svc.py']), pr('b', ['docs/b.md']), { id: 'c', status: 'in-flight', stage: 'done', files: ['svc.py', 'c.py'] }]))
-  assert.match(open(stackShared, 'c'), /stacked on unit a \(#a; shares svc\.py\).*gh pr create --draft --base rush\/a, then link the line as one GitHub stack, bottom first: gh stack link #a the new PR/)
-  assert.match(open(shared, 'c'), /chained on unit a \(#a; shares svc\.py\): rebase onto rush\/a at aaaaaaa now/)
-  assert.match(open(shared, 'c'), /set stacksOn to \[a\] and parentHead to that HEAD/)
-  const lone = nextActions(chainPlan([pr('a', ['a.py']), { id: 'c', status: 'in-flight', stage: 'done', files: ['c.py'] }]))
-  assert.match(open(lone, 'c'), /on the target: no open run PR shares its files/)
-  const unrecorded = nextActions(chainPlan([pr('a', ['a.py']), { id: 'c', status: 'in-flight', stage: 'done' }]))
-  assert.match(open(unrecorded, 'c'), /record unit c's own changed files as files/)
-  // A dependent opens once its parent's PR is open (wait mode would hold it until the merge).
-  const dep = nextActions(chainPlan([pr('p', ['p.py']), { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['p'], files: ['c.py'] }]))
-  assert.match(open(dep, 'c'), /chained on unit p \(#p; it builds on its code\)/)
-  assert.deepEqual(kinds(nextActions(plan([pr('p', ['p.py']), { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['p'], files: ['c.py'] }], { deliveryMode: 'wait' }))).filter((k) => k.startsWith('open-pr')), [])
-})
-
-test('chain mode: the chain parent is the line that carries most of what the unit shares, and a second line is named', () => {
-  const pr = (id, files, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `rush/${id}`, files, ...extra })
-  const chainPlan = (units) => plan(units, { deliveryMode: 'chain' })
-  const open = (r, id) => r.due.find((a) => a.action === 'open-pr' && a.unit === id).detail
-  const deep = nextActions(chainPlan([pr('a', ['x']), pr('b', ['y'], { stacksOn: ['a'] }), { id: 'c', status: 'in-flight', stage: 'done', files: ['x', 'y'] }]))
-  assert.match(open(deep, 'c'), /chained on unit b/, 'b carries a, so chaining on b covers both')
-  // a1 #408 replay: 432 needs 429, but 431's line shared more of its files; chaining there made 432 wait
-  // for its own dependency to land.
-  const dep = nextActions(chainPlan([pr('p', ['x']), pr('d', ['y'], { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] }), pr('o', ['x', 'z'], { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] }), pr('o2', ['z'], { stacksOn: ['o'], parentHead: 'oaaaaaa', offLine: [] }), { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['d'], files: ['x', 'z'] }]))
-  assert.match(open(dep, 'c'), /chained on unit d /, 'the line with its dependency wins over a line sharing more files')
-  const split = nextActions(chainPlan([pr('a', ['x']), pr('b', ['y']), { id: 'c', status: 'in-flight', stage: 'done', files: ['x', 'y'] }]))
-  assert.match(open(split, 'c'), /chained on unit b .*also shares files with a on another line/)
-  const merged = nextActions(chainPlan([pr('a', ['x'], { status: 'succeeded' }), { id: 'c', status: 'in-flight', stage: 'done', files: ['x'] }]))
-  assert.match(open(merged, 'c'), /no open run PR shares its files/, 'a merged PR is part of the target, not a chain parent')
-})
-
-test('chain mode: a line is delivered once, by enqueueing its deepest PR whose whole line passed review', () => {
-  const ok = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, reviewedHead: `${id}aaaaaa`, files: [id], ...extra })
-  const chainPlan = (units, extra = {}) => plan(units, { deliveryMode: 'chain', ...extra })
-  const line = [ok('a'), ok('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] }), ok('c', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [] })]
-  const all = nextActions(chainPlan(line))
-  assert.deepEqual(kinds(all), ['deliver:c'])
-  assert.match(all.due[0].detail, /line \(a -> b -> c\).*enqueue only #c; its merge lands the line/)
-  // b took a fix after c was built on it: c's branch still carries b's old HEAD, so enqueueing c would
-  // land commits nobody reviewed. c restacks once b's new HEAD passes; until then only a and b ship.
-  const fixed = [line[0], { ...line[1], headSha: 'b2aaaaa', reviewedHead: 'b2aaaaa' }, line[2]]
-  const restack = nextActions(chainPlan(fixed))
-  assert.deepEqual(kinds(restack), ['restack:c', 'deliver:b'])
-  assert.match(restack.due[0].detail, /built on unit b's old HEAD baaaaaa; b passed at b2aaaaa: rebase onto it, set parentHead to b2aaaaa/)
-  const reviewing = [line[0], { ...line[1], headSha: 'b2aaaaa', reviewedHead: 'baaaaaa' }, line[2]]
-  assert.deepEqual(kinds(nextActions(chainPlan(reviewing))).filter((k) => k.startsWith('restack')), [], 'no restack while the parent\'s new HEAD is still in review')
-  const middle = [line[0], { ...line[1], reviewedHead: null }, line[2]]
-  assert.deepEqual(kinds(nextActions(chainPlan(middle))), ['start-review:b', 'deliver:a'], 'c waits for b; a ships alone meanwhile')
-  const landed = nextActions(chainPlan([{ ...line[0], status: 'succeeded' }, line[1], line[2]]))
-  assert.match(landed.due[0].detail, /line \(b -> c\)/)
-  const tree = nextActions(chainPlan([ok('p'), ok('x', { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] }), ok('y', { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] })]))
-  assert.deepEqual(kinds(tree), ['deliver:x', 'deliver:y'], 'two lines on one parent: each leaf delivers; the first merge lands the parent')
-  assert.match(nextActions(chainPlan(line, { mergeMode: 'supervised' })).due[0].detail, /hand them back merge-ready together/)
-  // Round-5 audit: a supervised stack is handed back whole; merging its deepest PR would only land it on its parent.
-  const supStack = nextActions(plan(line, { mergeMode: 'supervised' })).due[0].detail
-  assert.match(supStack, /hand the whole stack back merge-ready/)
-  assert.doesNotMatch(supStack, /lands the whole line/)
-  // A reciprocal stacksOn pair resolves to the lower id everywhere, so the pair still delivers once.
-  const recip = nextActions(plan([ok('1', { stacksOn: ['2'], parentHead: '2aaaaaa', offLine: [] }), ok('2', { stacksOn: ['1'], parentHead: '1aaaaaa', offLine: [] })]))
-  assert.deepEqual(kinds(recip), ['deliver:2'])
-  const stacked = nextActions(plan(line))
-  assert.deepEqual(kinds(stacked), ['deliver:c'], 'stack mode delivers a stack once, too')
-  assert.match(stacked.due[0].detail, /stack \(a -> b -> c\).*queue only #c \(@mergifyio queue\); the queue takes every PR below it/)
-})
-
-test('stack mode: a GitHub stack is a line, so a parent holds one stacked child and another opens after it lands', () => {
-  // Native stacks are linear (a PR belongs to one stack). Chain mode lets a parent have two lines (above).
-  const ok = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, reviewedHead: `${id}aaaaaa`, branch: `b/${id}`, files: [id], ...extra })
-  const built = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', files: ['p', id], ...extra })
-  const open = (r) => kinds(r).filter((k) => k.startsWith('open-pr'))
-  // Both children are built in one pass: only the first opens.
-  assert.deepEqual(kinds(nextActions(plan([ok('p', { reviewedHead: null }), built('x'), built('y')]))).filter((k) => k !== 'start-review:p'), ['open-pr:x'])
-  // Audit round 3: p is being queued, so no child links onto it this pass; after p lands, x opens on the target.
-  assert.deepEqual(kinds(nextActions(plan([ok('p'), built('x')]))), ['deliver:p'])
-  // One child already holds p: the other waits, in stack mode only.
-  const held = [ok('p'), ok('x', { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] }), built('y', { dependsOn: ['p'] })]
-  assert.deepEqual(open(nextActions(plan(held))), [])
-  assert.deepEqual(open(nextActions(plan(held, { deliveryMode: 'chain' }))), ['open-pr:y'], 'chain mode can fork')
-  // A blocked holder still sits in p's GitHub stack: y still waits, and p ships alone (audit round 1: relinking
-  // in the same pass raced p's queue entry, and gh stack unstack leaves a queued PR stacked).
-  for (const status of ['blocked', 'cancelled']) {
-    const blockedHolder = nextActions(plan([held[0], { ...held[1], status, blockedReason: 'review-handback' }, held[2]]))
-    assert.deepEqual(kinds(blockedHolder), ['deliver:p'], status)
-  }
-  // p landed: the waiting child opens on the target.
-  const landed = nextActions(plan([{ ...held[0], status: 'succeeded' }, held[1], held[2]]))
-  assert.match(landed.due.find((a) => a.unit === 'y').detail, /on the target: no open run PR shares its files/)
-  // A dependent never opens an early PR on a parent's branch in stack mode: its stack parent is picked once its code is done.
-  const early = [ok('p'), { id: 'c', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement', headSha: 'caaaaaa', dependsOn: ['p'] }]
-  assert.deepEqual(open(nextActions(plan(early))), [])
-  assert.deepEqual(open(nextActions(plan(early, { deliveryMode: 'chain' }))), ['open-pr:c'])
-  // A fork left by an older run: the lower id keeps the stack and delivers; the other ships after p lands.
-  const fork = [ok('p'), ok('x', { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] }), ok('y', { stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [] })]
-  assert.deepEqual(kinds(nextActions(plan(fork))), ['deliver:x'])
-  assert.deepEqual(kinds(nextActions(plan(fork, { deliveryMode: 'chain' }))), ['deliver:x', 'deliver:y'])
-  // Audit round 1: a blocked lower-id holder still holds p, so y is never delivered as p's stack.
-  const blockedFork = nextActions(plan([fork[0], { ...fork[1], status: 'blocked', blockedReason: 'review-handback', reviewedHead: null }, fork[2]]))
-  assert.deepEqual(kinds(blockedFork), ['deliver:p'])
-  assert.doesNotMatch(blockedFork.due[0].detail, /#y/)
-  const after = nextActions(plan([{ ...fork[0], status: 'succeeded' }, { ...fork[1], status: 'succeeded' }, fork[2]]))
-  assert.deepEqual(kinds(after), ['restack:y'])
-  assert.match(after.due[0].detail, /p landed, and unit y's PR sat outside its GitHub stack \(unit x held it\): rebase it onto the target, clear stacksOn and parentHead, retarget the PR/)
-  assert.deepEqual(kinds(nextActions(plan([{ ...fork[0], status: 'succeeded' }, fork[1], { ...fork[2], stacksOn: [], parentHead: null }]))), ['deliver:x', 'deliver:y'], 'once restacked, it ships alone')
-})
-
-test('stack mode: one change per GitHub stack per pass, restacks first (audit round 4)', () => {
-  const pr = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `b/${id}`, offLine: [], ...extra })
-  // b is built on a's old HEAD: restack it before a is queued; chain mode does both, as before.
-  const stale = [pr('a', { headSha: 'a222222', reviewedHead: 'a222222' }), pr('b', { reviewedHead: 'baaaaaa', stacksOn: ['a'], parentHead: 'a111111' })]
-  assert.deepEqual(kinds(nextActions(plan(stale))), ['restack:b'])
-  assert.deepEqual(kinds(nextActions(plan(stale, { deliveryMode: 'chain' }))), ['restack:b', 'deliver:a'])
-  // Audit round 5: a restack waiting for a slot holds nothing back; a queues meanwhile.
-  const full = nextActions(plan(stale), {}, 0)
-  assert.deepEqual(kinds(full), ['deliver:a'])
-  assert.deepEqual(full.waiting.map((a) => `${a.action}:${a.unit}`), ['restack:b'])
-  // A built c never links onto b while b is being rebased.
-  const opening = [pr('q', { reviewedHead: null }), pr('a', { headSha: 'a222222', reviewedHead: 'a222222', dependsOn: ['q'] }), pr('b', { reviewedHead: 'baaaaaa', stacksOn: ['a'], parentHead: 'a111111', files: ['shared'] }), { id: 'c', status: 'in-flight', stage: 'done', files: ['shared', 'c'] }]
-  assert.deepEqual(kinds(nextActions(plan(opening))).filter((k) => k !== 'start-review:q'), ['restack:b'])
-})
-
-test('stack mode: a passed PR moves off to the target, never onto a parent another child holds', () => {
-  const now = Date.parse('2026-10-16T10:00:00Z')
-  const pr = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `b/${id}`, files: ['src/index.ts'], ...extra })
-  const units = [pr('a', { reviewedHead: 'aaaaaaa' }), pr('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] }), pr('c', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [], reviewedHead: 'caaaaaa' })]
-  const fixRound = { b: { round: 1, head: 'baaaaaa', complete: true, blocking: true, fix: true, awaiting: false, at: now }, c: { round: 1, head: 'caaaaaa', complete: true, blocking: false, fix: false, awaiting: false, at: now - 60_000 } }
-  // Chain mode moves c onto a; in a GitHub stack b still holds a, so c goes to the target.
-  const r = nextActions(plan(units), fixRound, 4, { now })
-  const moved = r.due.find((a) => a.action === 'restack')
-  assert.match(moved.detail, /waits on b.*rebase onto the target, clear stacksOn and parentHead.*retarget the PR to the target.*leaves its GitHub stack: before any PR in that stack is queued .*gh stack checkout #c, gh stack unstack, then gh stack link #a #b \(bottom first\)/)
-  assert.ok(!kinds(r).includes('deliver:a'), 'a is not queued while its stack is taken apart')
-  assert.ok(kinds(nextActions(plan(units, { deliveryMode: 'chain' }), fixRound, 4, { now })).includes('deliver:a'), 'chain mode delivers a meanwhile')
-  // Audit round 2: c and its passed child d would both leave the stack, each relinking from the old shape.
-  // Only c moves this pass; d is reconsidered on the next plan.
-  const withD = [...units, pr('d', { stacksOn: ['c'], parentHead: 'caaaaaa', offLine: [], reviewedHead: 'daaaaaa', files: ['d.ts'] })]
-  const two = nextActions(plan(withD), fixRound, 4, { now })
-  assert.deepEqual(kinds(two).filter((k) => k.startsWith('restack') || k.startsWith('deliver')), ['restack:c'])
-  assert.match(two.due[0].detail, /gh stack link #a #b and gh stack link #c #d/)
-  // Audit round 3: while c leaves, a built d does not link onto c's old line.
-  const withBuilt = [...units, { id: 'd', status: 'in-flight', stage: 'done', files: ['src/index.ts', 'd.ts'] }]
-  assert.deepEqual(kinds(nextActions(plan(withBuilt), fixRound, 4, { now })).filter((k) => k.startsWith('restack') || k.startsWith('deliver') || k.startsWith('open-pr')), ['restack:c'])
-  // c needs a's code: dropping a is never allowed, so c waits on b.
-  const needsA = plan(units.map((u) => (u.id === 'c' ? { ...u, dependsOn: ['a'] } : u)))
-  assert.deepEqual(kinds(nextActions(needsA, fixRound, 4, { now })).filter((k) => k.startsWith('restack')), [])
-})
-
-test('chain mode: a passed PR moves off a shared-file ancestor in a fix round at once, and off a slow one after 30 minutes', () => {
-  // wiki-kb #12 replay: chained PRs waited 872 minutes in all behind slow shared-file reviews (wait mode: 534).
-  const now = Date.parse('2026-10-16T10:00:00Z')
-  const pr = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `b/${id}`, files: ['src/index.ts'], ...extra })
-  const units = [pr('a', { reviewedHead: 'aaaaaaa' }), pr('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] }), pr('c', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [], reviewedHead: 'caaaaaa' })]
-  const chainPlan = plan(units, { deliveryMode: 'chain' })
-  const passedAt = (min) => ({ round: 1, head: 'caaaaaa', complete: true, blocking: false, fix: false, awaiting: false, at: now - min * 60_000 })
-  const run = (reviews) => nextActions(chainPlan, reviews, 4, { now })
-  const fixRound = { b: { round: 1, head: 'baaaaaa', complete: true, blocking: true, fix: true, awaiting: false, at: now }, c: passedAt(1) }
-  const moved = run(fixRound)
-  assert.deepEqual(kinds(moved).filter((k) => k.startsWith('restack')), ['restack:c'])
-  assert.match(moved.due.find((a) => a.action === 'restack').detail, /waits on b.*b is in a fix round or blocked.*rebase onto unit a's branch at aaaaaaa, set stacksOn to \[a\] and parentHead to that HEAD/)
-  assert.deepEqual(kinds(run({ c: passedAt(10) })).filter((k) => k.startsWith('restack')), [], 'b is still in review: c waits a while')
-  assert.match(run({ c: passedAt(31) }).due.find((a) => a.action === 'restack').detail, /still in review 31m after this pass/)
-  const dependent = plan(units.map((u) => (u.id === 'c' ? { ...u, dependsOn: ['b'] } : u)), { deliveryMode: 'chain' })
-  assert.deepEqual(kinds(nextActions(dependent, fixRound, 4, { now })).filter((k) => k.startsWith('restack')), [], 'c needs b\'s code: it never moves off b')
-  const root = plan([pr('a', { stacksOn: [] }), { ...pr('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] }) }, pr('c', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [], reviewedHead: 'caaaaaa' })].map((u) => (u.id === 'b' ? { ...u, reviewedHead: u.headSha } : u)), { deliveryMode: 'chain' })
-  const viaA = nextActions(root, { a: { round: 1, head: 'aaaaaaa', complete: true, blocking: true, fix: true, awaiting: false, at: now }, c: passedAt(1) }, 4, { now })
-  assert.match(viaA.due.find((a) => a.action === 'restack').detail, /waits on a.*rebase onto the target, clear stacksOn/, 'b carries a, so c drops both and goes to the target')
-})
-
-test('chain mode audit: two-line dependencies, blocked dependencies, stacksOn loops, and headless parents', () => {
-  const pr = (id, extra = {}) => ({ id, status: 'in-flight', stage: 'done', pr: `#${id}`, headSha: `${id}aaaaaa`, branch: `b/${id}`, files: [`${id}.py`], ...extra })
-  const chainPlan = (units) => plan(units, { deliveryMode: 'chain' })
-  // c needs a and b, which sit on different lines. identity #1154 replay: holding c's PR until one line
-  // landed started its 884-minute review six hours late. c opens now on one line, carries the other as
-  // offLine, and ships only after that line lands and a restack drops the copy.
-  const both = nextActions(chainPlan([pr('a'), pr('b'), { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['a', 'b'], files: ['c.py'] }]))
-  assert.match(both.due.find((x) => x.unit === 'c').detail, /chained on unit b .*set offLine to \[a\]/)
-  const ok = (id, extra = {}) => pr(id, { reviewedHead: `${id}aaaaaa`, ...extra })
-  const carrying = [ok('a'), ok('b'), ok('c', { dependsOn: ['a', 'b'], stacksOn: ['b'], parentHead: 'baaaaaa', offLine: ['a'] })]
-  assert.deepEqual(kinds(nextActions(chainPlan(carrying))), ['deliver:a', 'deliver:b'], 'c waits while it carries a copy of a')
-  const landed = nextActions(chainPlan([{ ...carrying[0], status: 'succeeded' }, carrying[1], carrying[2]]))
-  assert.deepEqual(kinds(landed), ['restack:c', 'deliver:b'])
-  assert.match(landed.due[0].detail, /a landed: rebase unit c onto unit b's HEAD baaaaaa to drop the copies of their commits, set parentHead to baaaaaa, clear offLine/)
-  const clean = nextActions(chainPlan([{ ...carrying[0], status: 'succeeded' }, carrying[1], { ...carrying[2], offLine: [] }]))
-  assert.deepEqual(kinds(clean), ['deliver:c'])
-  // Round-3 audit: what c carries is derived from the plan, never trusted from offLine.
-  const unrecorded = nextActions(chainPlan([carrying[0], carrying[1], { ...carrying[2], offLine: undefined }]))
-  assert.deepEqual(kinds(unrecorded), ['restack:c', 'deliver:a', 'deliver:b'], 'a missing offLine holds c and restacks it')
-  const stray = nextActions(chainPlan([ok('x'), carrying[1], ok('c', { dependsOn: ['b'], stacksOn: ['b'], parentHead: 'baaaaaa', offLine: ['x'] })]))
-  assert.deepEqual(kinds(stray), ['deliver:x', 'deliver:c'], 'an offLine id that is not a dependency is ignored')
-  const blockedDep = nextActions(chainPlan([{ ...carrying[0], status: 'succeeded' }, { ...carrying[1], status: 'blocked', blockedReason: 'review-handback' }, carrying[2]]))
-  assert.deepEqual(kinds(blockedDep), ['finish:'], 'no cleanup while a dependency will not land')
-  const both2 = nextActions(chainPlan([{ ...carrying[0], status: 'succeeded' }, { ...carrying[1], reviewedHead: null }, carrying[2]]), { b: { round: 1, head: 'baaaaaa', complete: true, blocking: true, fix: true, awaiting: false, at: Date.now() } }, 4, { now: Date.now() })
-  assert.equal(kinds(both2).filter((k) => k === 'restack:c').length, 1, 'one restack per unit per pass')
-  // A blocked dependency is never dropped: its dependent's PR waits, and the run can finish around it.
-  const blocked = chainPlan([pr('p', { status: 'blocked', blockedReason: 'review-handback' }), pr('c', { dependsOn: ['p'], stacksOn: ['p'], parentHead: 'paaaaaa', offLine: [], reviewedHead: 'caaaaaa' })])
-  const r = nextActions(blocked)
-  assert.deepEqual(kinds(r), ['finish:'])
-  assert.match(r.due[0].detail, /PR open, cannot land: c \(#c, waits on p\)/)
-  // A built child whose parent is blocked but still has a PR is held, not opened, in chain and stack mode.
-  for (const mode of ['chain', 'stack']) {
-    const held = nextActions(plan([pr('p', { status: 'blocked', blockedReason: 'review-handback' }), { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['p'], files: ['c.py'] }], { deliveryMode: mode }))
-    assert.deepEqual(kinds(held), ['finish:'], mode)
-    assert.match(held.due[0].detail, /built, PR not opened: c \(waits on p\)/)
-  }
-  // Round-4 audit: a chained PR that never recorded offLine may carry copies that a landed dependency
-  // hides; it restacks before it can ship.
-  const legacy = nextActions(chainPlan([ok('b'), ok('c', { dependsOn: ['b'], stacksOn: ['b'], parentHead: 'baaaaaa' })]))
-  assert.deepEqual(kinds(legacy), ['restack:c', 'deliver:b'])
-  assert.match(legacy.due[0].detail, /has no recorded offLine: rebase it onto unit b's HEAD baaaaaa/)
-  // A reciprocal stacksOn pair resolves to the lower id as parent (as in stack mode); a longer loop is a cycle.
-  const pair = nextActions(chainPlan([pr('a', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [], reviewedHead: 'aaaaaaa' }), pr('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] })]), {}, 4, { now: Date.now() })
-  assert.ok(!kinds(pair).some((k) => k.startsWith('cycle:')), kinds(pair).join(' '))
-  const loop = nextActions(chainPlan([pr('a', { stacksOn: ['c'], parentHead: 'caaaaaa', offLine: [], reviewedHead: 'aaaaaaa' }), pr('b', { stacksOn: ['a'], parentHead: 'aaaaaaa', offLine: [] }), pr('c', { stacksOn: ['b'], parentHead: 'baaaaaa', offLine: [] })]), {}, 4, { now: Date.now() })
-  assert.ok(kinds(loop).some((k) => k.startsWith('cycle:')), kinds(loop).join(' '))
-  // A parent with no recorded HEAD cannot be chained on.
-  const headless = nextActions(chainPlan([pr('p', { headSha: undefined, files: ['x.py'] }), { id: 'c', status: 'in-flight', stage: 'done', files: ['x.py'] }]))
-  assert.match(headless.due.find((x) => x.unit === 'c').detail, /record headSha for unit p's PR/)
-})
-
-test('an unknown deliveryMode is refused, not read as stack', () => {
-  assert.throws(() => nextActions(plan([{ id: 'a', status: 'pending' }], { deliveryMode: 'chained' })), /deliveryMode must be stack, chain, or wait: "chained"/)
-})
-
-test('chain mode: a PR whose chain parent will not land is restacked onto the target', () => {
-  const units = [
-    { id: 'p', status: 'blocked', blockedReason: 'review-handback', stage: 'done', pr: '#p', headSha: 'paaaaaa', files: ['x'] },
-    { id: 'c', status: 'in-flight', stage: 'done', pr: '#c', headSha: 'caaaaaa', reviewedHead: 'caaaaaa', stacksOn: ['p'], files: ['x'], offLine: [] },
-  ]
-  const r = nextActions(plan(units, { deliveryMode: 'chain' }))
-  assert.deepEqual(kinds(r), ['restack:c'])
-  assert.match(r.due[0].detail, /rebase it onto the target without them/)
-  const legacy = nextActions(plan([units[0], { ...units[1], offLine: undefined }], { deliveryMode: 'chain' }))
-  assert.match(legacy.due.find((a) => a.action === 'restack').detail, /rebase it onto the target/, 'never onto a parent that will not land')
-  assert.deepEqual(kinds(nextActions(plan(units, { deliveryMode: 'chain' }), {}, 0)).filter((k) => k.startsWith('restack')), [], 'a restack needs a slot')
-})
-
-test('a block without a listed reason is reopened on every call, not only on --resume', () => {
-  // agentier #2366: the coordinator re-marked units blocked ("await actual suppliers", "gate
-  // holds") minutes after --resume unblocked them, and the scheduler then printed finish.
-  const units = [
-    { id: 'a', status: 'blocked', stage: 'implement', note: 'await actual suppliers' },
-    { id: 'b', status: 'blocked', stage: 'implement', blockedReason: 'awaiting-supplier' },
-    { id: 'c', status: 'blocked', stage: 'implement', blockedReason: 'human-decision', humanItem: 5, humanNeed: 'add the STRIPE_KEY secret' },
-    { id: 'd', status: 'succeeded' },
-  ]
-  const r = nextActions(plan(units))
-  assert.deepEqual(kinds(r), ['unblock:a', 'unblock:b', 'resume:a', 'resume:b'], 'no finish while a unit is wrongly blocked')
-  assert.match(r.due[0].detail, /without a reason from expire\.md's list \(blockedReason null\)/)
-  const waiting = [{ id: 'p', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement' }, { id: 'w', status: 'blocked', dependsOn: ['p'], blockedReason: 'awaiting-supplier' }]
-  const w = nextActions(plan(waiting))
-  assert.deepEqual(kinds(w), ['unblock:w'])
-  assert.match(w.due[0].detail, /only waits on p: set it pending/)
-  const sized = { id: 's', status: 'blocked', stage: 'implement', blockedReason: 'size-hold' }
-  assert.deepEqual(kinds(nextActions(plan([sized, units[3]], { skill: 'resolve-issues' }))), ['finish:'], 'resolve-issues hands a size hold back')
-  assert.deepEqual(kinds(nextActions(plan([sized, units[3]], { skill: 'rush-issues' }))), ['unblock:s', 'resume:s'], 'rush never blocks for size')
-})
-
-test('a child built on a parent that will not land this run settles instead of stalling silently', () => {
-  for (const mode of ['wait', 'stack']) {
-    const units = [
-      { id: '1', status: 'blocked', blockedReason: 'retry-ci', stage: 'done', autoRetries: 3 },
-      { id: '2', status: 'in-flight', stage: 'done', dependsOn: ['1'] },
-    ]
-    const r = nextActions(plan(units, { deliveryMode: mode }))
-    assert.deepEqual(kinds(r), ['finish:'], mode)
-    assert.match(r.due[0].detail, /built, PR not opened: 2 \(waits on 1\)/)
-    const cancelled = [{ ...units[0], status: 'cancelled' }, units[1]]
-    assert.deepEqual(kinds(nextActions(plan(cancelled, { deliveryMode: mode }))), ['finish:'], `${mode}, cancelled parent`)
-  }
-})
-
-test('a reasonless block with a stale worker never lets the run finish', () => {
-  const r = nextActions(plan([{ id: '1', status: 'blocked', worker: 'w1', workerKind: 'implement' }, { id: '2', status: 'succeeded' }]))
-  assert.deepEqual(kinds(r), ['unblock:1'])
-  assert.match(r.due[0].detail, /if that worker is gone, clear it/)
-})
-
-test('an action left undone says how long it has been printed', () => {
-  const units = [{ id: 'a', status: 'pending' }]
-  const t0 = Date.parse('2026-10-13T07:00:00Z')
-  const first = nextActions(plan(units), {}, 4, { now: t0 })
-  assert.deepEqual(first.seen, { 'fill-slot:a': t0 })
-  assert.doesNotMatch(first.due[0].detail, /still not done/)
-  const later = nextActions(plan(units), {}, 4, { now: t0 + 92 * 60_000, seen: first.seen })
-  assert.match(later.due[0].detail, /printed 92m ago and still not done/)
-  assert.deepEqual(later.seen, { 'fill-slot:a': t0 }, 'the first time is kept')
-  const started = nextActions(plan([{ id: 'a', status: 'in-flight', worker: 1, workerKind: 'implement' }]), {}, 4, { now: t0 + 93 * 60_000, seen: later.seen })
-  assert.deepEqual(started.seen, {}, 'a done action drops out')
-  const delivering = [{ id: 'd', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'abc1234', reviewedHead: 'abc1234' }]
-  const wait = nextActions(plan(delivering), {}, 4, { now: t0 + 30 * 60_000, seen: { 'deliver:d': t0 } })
-  assert.doesNotMatch(wait.due[0].detail, /still not done/, 'deliver repeats while CI and the queue run')
-})
-
-test('a written review without a recorded verdict asks for review-verdict before anything else', () => {
-  const r = nextActions(plan([
-    { id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaa' },
-    { id: 'b', status: 'pending' },
-  ]), { a: { round: 1, head: 'aaa', fix: false } })
-  assert.deepEqual(kinds(r), ['review-verdict:a', 'fill-slot:b'])
-})
-
-test('a fix brief for the current HEAD starts a fix; a pushed fix (new HEAD) starts the next review round', () => {
-  const unit = { id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaa' }
-  assert.deepEqual(kinds(nextActions(plan([unit]), { a: { round: 1, head: 'aaa', fix: true } })), ['start-fix:a'])
-  const r = nextActions(plan([{ ...unit, headSha: 'bbb' }]), { a: { round: 1, head: 'aaa', fix: true } })
-  assert.deepEqual(kinds(r), ['start-review:a'])
-  assert.match(r.due[0].detail, /round 2/)
-  assert.match(r.due[0].detail, /rereview-scope\.mjs --prior <run>\/reviews\/a-r1\.json .*--write-skip <run>\/reviews\/a-r2\.json; on skip run review-verdict/, 'a re-review picks its tier before spawning a reviewer')
-  assert.doesNotMatch(nextActions(plan([unit])).due[0].detail, /rereview-scope/, 'the first review is always full')
-})
-
-test('review passed on the current HEAD: deliver (supervised hands back instead of enqueueing)', () => {
-  const unit = { id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'abcdef12', reviewedHead: 'abcdef12' }
-  assert.match(nextActions(plan([unit])).due[0].detail, /mark ready and merge \(enqueue under a queue\)/)
-  assert.match(nextActions(plan([unit], { mergeMode: 'supervised' })).due[0].detail, /hand the PR back/)
-})
-
-test('code done without a PR opens one when the parents allow it', () => {
-  const units = [
-    { id: 'p', status: 'in-flight', stage: 'done', worker: 1, workerKind: 'implement' },
-    { id: 'c', status: 'in-flight', stage: 'done', dependsOn: ['p'] },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units))), [], 'stack: wait for the parent PR')
-  units[0].pr = '#9'
-  assert.deepEqual(kinds(nextActions(plan(units))), ['open-pr:c'])
-})
-
-test('an in-flight unit that lost its worker is resumed', () => {
-  assert.deepEqual(kinds(nextActions(plan([{ id: 'a', status: 'in-flight', stage: 'implement' }]))), ['resume:a'])
-})
-
-test('worker-needing actions are limited to free slots; the rest wait', () => {
-  const busy = [1, 2, 3].map((n) => ({ id: `w${n}`, status: 'in-flight', stage: 'implement', worker: n, workerKind: 'implement' }))
-  const r = nextActions(plan([...busy,
-    { id: 'r', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'x' },
-    { id: 'n', status: 'pending' },
-    { id: 'd', status: 'in-flight', stage: 'done', pr: '#2', headSha: 'y', reviewedHead: 'y' },
-  ]))
-  assert.deepEqual(kinds(r), ['start-review:r', 'deliver:d'], 'the review takes the last slot; deliver needs none')
-  assert.deepEqual(r.waiting.map((a) => a.unit), ['n'])
-})
-
-test('busy units, delivered and blocked units get no action; all terminal means finish', () => {
-  assert.deepEqual(kinds(nextActions(plan([{ id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'x', worker: 2, workerKind: 'review' }]))), [])
-  const r = nextActions(plan([{ id: 'a', status: 'succeeded' }, { id: 'b', status: 'blocked', blockedReason: 'retry-ci', autoRetries: 3 }, { id: 'c', status: 'cancelled' }]))
-  assert.deepEqual(kinds(r), ['finish:'])
-  assert.throws(() => nextActions({ units: [] }), NextActionsError)
-})
-
-test('--resume reopens units blocked in an earlier invocation and schedules their next step', () => {
-  const units = [
-    { id: 'a', status: 'blocked', stage: 'implement', blockedReason: 'spawn-death', note: 'spawn-death twice', autoRetries: 3 },
-    { id: 'b', status: 'blocked', stage: 'done', pr: '#1', headSha: 'abc1234', reviewedHead: 'abc1234', blockedReason: 'retry-ci', note: 'retry-ci: queue teardown, #1457', autoRetries: 3 },
-    { id: 'c', status: 'succeeded' },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units))), ['finish:'], 'without --resume a blocked unit is terminal')
-  const r = nextActions(plan(units), {}, 4, { resume: true })
-  assert.deepEqual(kinds(r), ['unblock:a', 'unblock:b', 'deliver:b', 'resume:a'])
-  assert.match(r.due[0].detail, /fresh limits/)
-})
-
-test('--resume reopens every block; a note never keeps a unit blocked', () => {
-  const units = ['human-decision: approve HTTPS fixture', 'external-blocker: custodian cleanup required', 'retry-review: review-verdict exit 4']
-    .map((note, i) => ({ id: `h${i}`, status: 'blocked', stage: 'implement', note }))
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { resume: true })), ['unblock:h0', 'unblock:h1', 'unblock:h2', 'resume:h0', 'resume:h1', 'resume:h2'])
-})
-
-test('--resume reviews a handed-back HEAD again, full, instead of re-reading the old verdict', () => {
-  const unit = { id: 'a', status: 'blocked', stage: 'done', pr: '#1', headSha: 'abc1234', note: 'retry-review: spec-question' }
-  const handback = { a: { round: 2, head: 'abc1234', fix: false, complete: true, awaiting: false, blocking: true } }
-  const r = nextActions(plan([unit]), handback, 4, { resume: true })
-  assert.deepEqual(kinds(r), ['unblock:a', 'start-review:a'])
-  assert.match(r.due[1].detail, /again against the issue as it reads now \(round 3, full\); review-verdict compares it with round 2/)
-  assert.doesNotMatch(r.due[1].detail, /rereview-scope/, 'the same HEAD must not be scoped to a skip')
-})
-
-test('--resume sends an incomplete review, an awaited GitHub reviewer, and an unrecorded pass through review-verdict', () => {
-  const unit = { id: 'a', status: 'blocked', stage: 'done', pr: '#1', headSha: 'abc1234', blockedReason: 'review-handback' }
-  const incomplete = { a: { round: 2, head: 'abc1234', fix: false, complete: false, awaiting: false, blocking: true } }
-  assert.deepEqual(kinds(nextActions(plan([unit]), incomplete, 4, { resume: true })), ['unblock:a', 'review-verdict:a'])
-  const awaiting = { a: { round: 2, head: 'abc1234', fix: false, complete: true, awaiting: true, blocking: true } }
-  assert.deepEqual(kinds(nextActions(plan([unit]), awaiting, 4, { resume: true })), ['unblock:a', 'review-verdict:a'])
-  const handback = { a: { round: 2, head: 'abc1234', fix: false, complete: true, awaiting: false, blocking: true } }
-  const unrecordedPass = { a: { round: 2, head: 'abc1234', fix: false, complete: true, awaiting: false, blocking: false } }
-  assert.deepEqual(kinds(nextActions(plan([unit]), unrecordedPass, 4, { resume: true })), ['unblock:a', 'review-verdict:a'], 'a pass whose verdict was never recorded needs no new round')
-  assert.deepEqual(kinds(nextActions(plan([unit]), handback)), ['finish:'], 'without --resume the handback stays terminal')
-})
-
-test('a stacksOn parent orders the PR in stack mode only; in wait mode PRs open as they are ready', () => {
-  // wiki-kb #12: a PR that passed review waited an hour behind shared-file siblings, with no queue.
-  const units = [
-    { id: 'p', status: 'blocked', stage: 'done', pr: '#1', headSha: 'aaa', reviewedHead: 'aaa' },
-    { id: 'c', status: 'blocked', stage: 'done', stacksOn: ['p'] },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units, { deliveryMode: 'wait' }), {}, 4, { resume: true })), ['unblock:p', 'unblock:c', 'deliver:p', 'open-pr:c'])
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { resume: true })), ['unblock:p', 'unblock:c', 'deliver:p', 'open-pr:c'])
-})
-
-test('two units stacked on each other: the lower id opens its PR first in stack mode', () => {
-  // Saved plans hold reciprocal stacksOn pairs; without a direction neither PR could ever open.
-  const units = [
-    { id: '1135', status: 'in-flight', stage: 'done', stacksOn: ['1134'] },
-    { id: '1134', status: 'in-flight', stage: 'done', stacksOn: ['1135'] },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units))), ['open-pr:1134'])
-  assert.deepEqual(kinds(nextActions(plan(units, { deliveryMode: 'wait' }))), ['open-pr:1135', 'open-pr:1134'])
-})
-
-test('a stacked unit whose stacksOn parent is blocked opens its PR on the target instead of waiting', () => {
-  const units = [{ id: 'p', status: 'blocked', stage: 'implement', blockedReason: 'retry-implement' }, { id: 's', status: 'in-flight', stage: 'done', stacksOn: ['p'] }]
-  assert.deepEqual(kinds(nextActions(plan(units))), ['open-pr:s'])
-})
-
-test('a dependsOn cycle is named as an action instead of idling, also after --resume', () => {
-  const units = [{ id: 'a', status: 'pending', dependsOn: ['b'] }, { id: 'b', status: 'pending', dependsOn: ['a'] }, { id: 'c', status: 'succeeded' }]
-  const r = nextActions(plan(units))
-  assert.deepEqual(kinds(r), ['cycle:a'])
-  assert.match(r.due[0].detail, /units a -> b -> a depend on each other/)
-  const blocked = units.map((u) => (u.id === 'c' ? u : { ...u, status: 'blocked', stage: 'implement' }))
-  assert.deepEqual(kinds(nextActions(plan(blocked), {}, 4, { resume: true })), ['cycle:a', 'unblock:a', 'unblock:b'])
-})
-
-test('a stacksOn parent never holds its child\'s start; a dependsOn parent does', () => {
-  const units = [
-    { id: 'p', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement' },
-    { id: 's', status: 'pending', stacksOn: ['p'] },
-    { id: 'd', status: 'pending', dependsOn: ['p'] },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units), {})), ['fill-slot:s'], 'the stacked unit codes alongside its parent')
-  const coded = [
-    { id: 'p', status: 'in-flight', stage: 'done' },
-    { id: 's', status: 'in-flight', stage: 'done', stacksOn: ['p'] },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(coded), {})), ['open-pr:p'], 'its PR still waits for the parent\'s PR')
-})
-
-test('CLI reads the newest review round per unit and exits 0 whether or not actions are due; --exit-due exits 1 when due', (t) => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-actions-'))
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
-  fs.mkdirSync(path.join(dir, 'reviews'))
-  fs.writeFileSync(path.join(dir, 'reviews', 'a-r1.json'), JSON.stringify({ head: 'old' }))
-  fs.writeFileSync(path.join(dir, 'reviews', 'a-r2.json'), JSON.stringify({ head: 'aaa', complete: true, external: { awaiting: ['vera932'] }, findings: [{ severity: 'P2' }, { severity: 'P1' }] }))
-  fs.writeFileSync(path.join(dir, 'reviews', 'a-r2.fix.json'), '{}')
-  const { at, ...newest } = readReviews(dir).a
-  assert.ok(Number.isFinite(at), 'the newest round records when it was written')
-  assert.deepEqual(newest, { round: 2, head: 'aaa', fix: true, complete: true, awaiting: true, blocking: true })
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaa' }])))
-  const due = spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir], { encoding: 'utf8' })
-  assert.equal(due.status, 0, due.stderr)
-  assert.match(due.stdout, /^start-fix\s+give reviews\/a-r2\.fix\.json/m)
-  assert.equal(spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir, '--exit-due', '--peek']).status, 1)
-  const dueJson = JSON.parse(spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir, '--json', '--peek'], { encoding: 'utf8' }).stdout)
-  assert.equal(dueJson.exitDue, true)
-  assert.ok(dueJson.due.length > 0 && 'waiting' in dueJson && dueJson.mode === 'full')
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaa', worker: 1, workerKind: 'implement' }])))
-  assert.equal(spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir]).status, 0)
-  assert.equal(spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir, '--exit-due']).status, 0, '--exit-due exits 0 when nothing is due')
-  assert.equal(JSON.parse(spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir, '--json', '--peek'], { encoding: 'utf8' }).stdout).exitDue, false)
-  assert.equal(spawnSync('node', [SCRIPT, '--slots', '4', '--run', path.join(dir, 'nope')]).status, 2)
-  // A plan without `skill` would read as resolve-issues; the CLI refuses it instead of guessing.
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify({ ...plan([{ id: 'a', status: 'pending' }]), skill: undefined }))
-  const unnamed = spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir], { encoding: 'utf8' })
-  assert.equal(unnamed.status, 2)
-  assert.match(unnamed.stderr, /needs "skill": "resolve-issues" or "rush-issues"/)
-  assert.equal(spawnSync('node', [SCRIPT, '--run', dir, '--exit-due', '--bogus']).status, 2)
-  assert.throws(() => parseCliArgs(['--slots', '-1', '--run', dir]), NextActionsError)
-  assert.equal(parseCliArgs(['--run', dir, '--slots', '4', '--resume']).resume, true)
-  assert.equal(parseCliArgs(['--run', dir, '--slots', '4']).resume, false)
-})
-
-test('CLI consumes a revisioned workflow plan without changing the plan', (t) => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-actions-workflow-'))
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
-  const planPath = path.join(dir, 'task-plan.json')
-  const savedPlan = JSON.stringify(plan([
-    { id: '2510', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'abc123' },
-  ], { planRevision: 12, runDir: dir, decisions: [] }), null, 2)
-  fs.writeFileSync(planPath, savedPlan)
-
-  const result = spawnSync('node', [SCRIPT, '--slots', '4', '--run', dir, '--json'], { encoding: 'utf8' })
-  assert.equal(result.status, 0, result.stderr)
-  assert.deepEqual(kinds(JSON.parse(result.stdout)), ['start-review:2510'])
-  assert.equal(fs.readFileSync(planPath, 'utf8'), savedPlan)
-})
-
-test('a worker silent past the quiet limit is checked first; an active or young one is not', () => {
-  const now = Date.parse('2026-10-11T11:19:00Z')
-  const units = [
-    { id: 'stuck', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement', workerSince: '2026-10-11T08:16:00Z' },
-    { id: 'busy', status: 'in-flight', stage: 'implement', worker: 2, workerKind: 'implement', workerSince: '2026-10-11T08:16:00Z' },
-    { id: 'young', status: 'in-flight', stage: 'implement', worker: 3, workerKind: 'implement', workerSince: '2026-10-11T11:00:00Z' },
-    { id: 'next', status: 'pending' },
-  ]
-  const activity = { stuck: Date.parse('2026-10-11T09:10:00Z'), busy: Date.parse('2026-10-11T11:15:00Z') }
-  const r = nextActions(plan(units), {}, 4, { now, activity })
-  assert.deepEqual(kinds(r), ['check-worker:stuck', 'fill-slot:next'])
-  assert.match(r.due[0].detail, /129m: read its latest output; if it is stuck, stop it and resume/)
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { now, activity, quietMinutes: 180 })), ['fill-slot:next'])
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { activity })), ['fill-slot:next'], 'no clock, no check')
-})
-
-test('readActivity finds the newest workspace change and ignores dependency output', (t) => {
-  const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'na-act-'))
-  t.after(() => fs.rmSync(ws, { recursive: true, force: true }))
-  fs.mkdirSync(path.join(ws, 'src'))
-  fs.mkdirSync(path.join(ws, 'node_modules'))
-  fs.writeFileSync(path.join(ws, 'src', 'a.ts'), 'x')
-  fs.writeFileSync(path.join(ws, 'node_modules', 'dep.js'), 'x')
-  const old = new Date('2026-10-11T09:00:00Z')
-  fs.utimesSync(path.join(ws, 'src', 'a.ts'), old, old)
-  const act = readActivity(plan([{ id: 'u', status: 'in-flight', worker: 1, workerKind: 'implement', workspace: ws }, { id: 'idle', status: 'in-flight', workspace: ws }]))
-  assert.deepEqual(Object.keys(act), ['u'], 'only units with a worker are probed')
-  assert.equal(act.u, old.getTime(), 'the newer node_modules file is skipped')
-})
-
-test('--quiet-minutes is parsed and validated', () => {
-  assert.equal(parseCliArgs(['--run', 'r', '--slots', '4', '--quiet-minutes', '30']).quietMinutes, 30)
-  assert.throws(() => parseCliArgs(['--run', 'r', '--slots', '4', '--quiet-minutes', '0']), NextActionsError)
-})
-
-test('issue-tree changes come first and hold finish until they are applied', () => {
-  const sync = { synced: true, source: 'live', actions: [{ action: 'add-unit', unit: '1343', detail: 'add unit 1343' }] }
-  assert.deepEqual(kinds(nextActions(plan([{ id: 'b', status: 'pending' }]), {}, 4, { sync })), ['add-unit:1343', 'fill-slot:b'])
-  assert.deepEqual(kinds(nextActions(plan([{ id: 'a', status: 'succeeded' }]), {}, 4, { sync })), ['add-unit:1343'], 'no finish while the tree has new work')
-})
-
-test('finish needs a fetch in the same call for a GitHub spec; a failed fetch never finishes', () => {
-  const done = plan([{ id: 'a', status: 'succeeded' }])
-  assert.deepEqual(kinds(nextActions(done, {}, 4, { sync: { synced: true, source: 'snapshot', actions: [] } })), ['sync:'])
-  assert.deepEqual(kinds(nextActions(done, {}, 4, { sync: { synced: false, source: 'none', missingTree: true, actions: [] } })), ['sync:'])
-  assert.deepEqual(kinds(nextActions(done, {}, 4, { sync: { synced: true, source: 'live', actions: [] } })), ['finish:'])
-  const down = nextActions(done, {}, 4, { sync: { synced: true, source: 'snapshot', fetchError: [{ key: 'o/r#1', error: 'HTTP 502' }], actions: [] } })
-  assert.deepEqual(kinds(down), ['sync:'], 'agentier #2366 finished twice on a failed GraphQL fetch')
-  assert.match(down.due[0].detail, /could not be read \(HTTP 502\)/)
-  assert.deepEqual(kinds(nextActions(done)), ['finish:'], 'a local spec has no tree to check')
-})
-
-test('CLI diffs the saved issue tree without a GitHub call', (t) => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-actions-tree-'))
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
-  const node = (n, extra = {}) => ({ key: `o/r#${n}`, repo: 'o/r', number: n, title: `t${n}`, state: 'open', labels: [], blockedBy: [], children: [], parent: 'o/r#1', ...extra })
-  fs.writeFileSync(path.join(dir, 'issue-tree.json'), JSON.stringify({ root: 'o/r#1', complete: true, nodes: { 'o/r#1': node(1, { children: ['o/r#2', 'o/r#3'], parent: null }), 'o/r#2': node(2), 'o/r#3': node(3) } }))
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: '2', status: 'succeeded' }], { spec: 'o/r#1' })))
-  const env = { ...process.env, PATH: dir } // no gh on PATH: any GitHub call would fail
-  const out = spawnSync(process.execPath, [SCRIPT, '--slots', '4', '--run', dir], { encoding: 'utf8', env })
-  assert.equal(out.status, 0, out.stderr)
-  assert.match(out.stdout, /^add-unit\s+add unit 3/m)
-  assert.doesNotMatch(out.stdout, /^finish/m)
-  assert.equal(parseCliArgs(['--run', dir, '--slots', '4', '--sync']).sync, true)
-})
-
-test('a rush run splits a size-held unit instead of finishing with it deferred', () => {
-  // fmm #1343: rush re-blocked a unit held at 9,386 lines on the strength of a sentence an
-  // earlier agent wrote into the issue, and the run finished with nothing split.
-  const held = { id: '1343', status: 'blocked', blockedReason: 'size-hold', sizeCheck: { verdict: 'stop', estimatedLines: 7220 } }
-  const done = { id: '1342', status: 'succeeded' }
-  const rush = (units) => plan(units, { skill: 'rush-issues' })
-  assert.deepEqual(kinds(nextActions(rush([held, done]))), ['split:1343'], 'no finish while a held unit waits')
-  assert.deepEqual(kinds(nextActions(rush([held, done]), {}, 4, { resume: true })), ['split:1343'], 'split, not unblock and resume')
-  assert.deepEqual(kinds(nextActions(rush([{ ...held, status: 'pending', sizeCheck: { scope: 'stop' } }]))), ['split:1343'], 'never started whole')
-  // `hold` is only the run's verdict; a unit's own verdict is ok, warn, or stop.
-  assert.deepEqual(kinds(nextActions(rush([{ ...held, status: 'pending', sizeCheck: { verdict: 'hold' } }]))), ['fill-slot:1343'], 'a runnable unit in a held run starts')
-  assert.deepEqual(kinds(nextActions(rush([{ ...held, sizeCheck: { verdict: 'warn' } }, done]))), ['unblock:1343', 'resume:1343'], 'a cleared unit is not held')
-  assert.deepEqual(kinds(nextActions(plan([held, done], { skill: 'resolve-issues' }))), ['finish:'], 'resolve-issues hands it back')
-  const whole = { ...held, status: 'in-flight', sizeCheck: { verdict: 'stop', runWhole: true } }
-  assert.deepEqual(kinds(nextActions(rush([whole]))), ['resume:1343'], 'no cut shrinks it: run it whole')
-})
-
-test('a human deferral that names no human-only item is the run\'s own and reopens (pi 01a147fb)', () => {
-  // fmm-express #1747: the rush run deferred the unit as human-decision because the harness
-  // refused its process_list tool, a refusal a shell or worker could route around, not item 5.
-  const done = { id: 'd', status: 'succeeded' }
-  const bare = { id: '1747', status: 'blocked', stage: 'implement', blockedReason: 'human-decision', note: 'process_list refused, no workaround' }
-  const r = nextActions(plan([bare, done], { skill: 'rush-issues' }))
-  assert.deepEqual(kinds(r), ['unblock:1747', 'resume:1747'], 'no finish around an unnamed deferral')
-  assert.match(r.due[0].detail, /without naming its human-only item \(humanItem 1-5 and humanNeed/)
-  for (const bad of [{ humanItem: 6, humanNeed: 'x' }, { humanItem: '5', humanNeed: 'x' }, { humanItem: 5 }, { humanItem: 5, humanNeed: ' ' }]) {
-    assert.deepEqual(kinds(nextActions(plan([{ ...bare, ...bad }, done]))).slice(0, 1), ['unblock:1747'], JSON.stringify(bad))
-  }
-  const named = { ...bare, humanItem: 3, humanNeed: 'route *.blob.core.windows.net past the router proxy' }
-  assert.deepEqual(kinds(nextActions(plan([named, done]))), ['finish:'], 'a named item stays deferred')
-})
-
-test('a rush split leaves alone what no split helps: a human gate, a running worker, finished code', () => {
-  const excluded = [{ issue: 'o/r#1142', reason: 'signed release' }]
-  const stop = { verdict: 'stop' }
-  const units = [
-    { id: 'gated', status: 'blocked', dependsOn: ['1142'], sizeCheck: stop },
-    { id: 'busy', status: 'in-flight', worker: 1, workerKind: 'implement', sizeCheck: stop },
-    { id: 'coded', status: 'blocked', stage: 'done', sizeCheck: stop, blockedReason: 'retry-ci' },
-    { id: '1142', status: 'blocked', sizeCheck: stop, blockedReason: 'human-decision', humanItem: 1, humanNeed: 'sign the release' },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units, { skill: 'rush-issues', spec: 'o/r#1', excluded }))), [])
-})
-
-test('a HEAD pushed after a passing review is carried, not reviewed', () => {
-  const unit = { id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'bbbbbbbb', reviewedHead: 'aaaaaaaa' }
-  const passed = { round: 3, head: 'aaaaaaaa', fix: false, complete: true, blocking: false, awaiting: false }
-  const r = nextActions(plan([unit]), { a: passed })
-  assert.deepEqual(kinds(r), ['carry:a'])
-  assert.match(r.due[0].detail, /review-verdict\.mjs --carry --review <run>\/reviews\/a-r4\.json --head bbbbbbbb --base /, 'nothing glued to the sha a caller copies')
-  assert.equal(r.busy, 0)
-  assert.deepEqual(kinds(nextActions(plan([unit]), { a: { ...passed, blocking: true } })), ['start-review:a'], 'a P0/P1 fix is reviewed')
-  assert.deepEqual(kinds(nextActions(plan([unit]), { a: { ...passed, awaiting: true } })), ['start-review:a'])
-  assert.deepEqual(kinds(nextActions(plan([unit]), { a: { ...passed, complete: false } })), ['start-review:a'])
-  assert.deepEqual(kinds(nextActions(plan([{ ...unit, reviewedHead: undefined }]), { a: passed })), ['start-review:a'], 'no recorded pass, no carry')
-})
-
-test('GitHub feedback merged after a pass sends the HEAD to a fix, not to delivery', () => {
-  const unit = { id: 'a', status: 'in-flight', stage: 'done', pr: '#1', headSha: 'aaaaaaaa', reviewedHead: 'aaaaaaaa' }
-  const r = nextActions(plan([unit]), { a: { round: 5, head: 'aaaaaaaa', fix: true, complete: true, blocking: true, awaiting: false } })
-  assert.deepEqual(kinds(r), ['start-fix:a'])
-  assert.deepEqual(kinds(nextActions(plan([unit]), { a: { round: 5, head: 'aaaaaaaa', fix: false, complete: true, blocking: false } })), ['deliver:a'])
-})
-
-test('a unit runs only implement, fix, and review workers: any other kind, or none, is flagged first', () => {
-  // fmm-express 1125 (2026-10-15): after a compaction dropped "no architecture or product
-  // workers", the coordinator ran architects and a product manager on units, recorded as
-  // workerRole "architect-provider". A missing workerKind is flagged too, or such a worker hides.
-  const units = [
-    { id: 'arch', status: 'in-flight', stage: 'validate', worker: 1, workerRole: 'architect-provider' },
-    { id: 'pm', status: 'in-flight', stage: 'validate', worker: 2, workerKind: 'product-manager' },
-    { id: 'ok', status: 'in-flight', stage: 'implement', worker: 3, workerKind: 'fix' },
-    { id: 'n', status: 'pending' },
-  ]
-  const r = nextActions(plan(units))
-  assert.deepEqual(kinds(r), ['worker-kind:arch', 'worker-kind:pm', 'fill-slot:n'])
-  assert.match(r.due[0].detail, /has no workerKind: set it to implement, fix, or review/)
-  assert.match(r.due[1].detail, /is a "product-manager": a unit runs only implement, fix, and review workers\. Stop it/)
-  const clean = units.map((u) => (u.worker ? { ...u, workerKind: 'implement' } : u))
-  assert.deepEqual(kinds(nextActions(plan(clean))), ['fill-slot:n'])
-})
-
-test('text output prints the long rules only with --resume or --rules, and otherwise a one-line pointer to the skill', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'na-rules-'))
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: 'a', status: 'pending' }])))
-  const call = (...extra) => spawnSync(process.execPath, [SCRIPT, '--slots', '4', '--run', dir, '--peek', ...extra], { encoding: 'utf8' })
-  const lastOf = (out) => out.stdout.trim().split('\n').at(-1)
-  const short = call()
-  assert.equal(lastOf(short), `${'rules'.padEnd(15)}Rules: ${SKILL_PATH} (--rules prints them)`)
-  assert.ok(!short.stdout.includes(RULES), 'the long RULES line is off by default')
-  assert.equal(lastOf(call('--rules')), `${'rules'.padEnd(15)}${RULES} Full text: ${SKILL_PATH}`)
-  assert.equal(lastOf(call('--resume')), `${'rules'.padEnd(15)}${RULES} Full text: ${SKILL_PATH}`)
-  for (const mode of ['narrow', 'off']) {
-    assert.ok(!lastOf(call('--mode', mode)).includes('The run ends only when'), `${mode}: short by default`)
-    assert.match(lastOf(call('--mode', mode, '--rules')), /The run ends only when this prints "run done"/)
-  }
-  assert.ok(fs.existsSync(SKILL_PATH), 'the path points at the installed SKILL.md')
-  const json = spawnSync(process.execPath, [SCRIPT, '--slots', '4', '--run', dir, '--json', '--peek'], { encoding: 'utf8' })
-  assert.doesNotThrow(() => JSON.parse(json.stdout), 'JSON output stays parseable')
-})
-
-test('rush decides a worker question before resuming or deferring, and finish waits for it (agentier #2533)', () => {
-  // The fix worker reported it needed a transport-boundary choice; the run resumed it twice with
-  // the same scope and deferred it as timeout-task. The question now holds the unit until answered.
-  const rush = (units, extra = {}) => plan(units, { skill: 'rush-issues', ...extra })
-  const ask = { '2533': [{ key: 'results/2533-attempt2.json', ask: 'which boundary proves the upload body completed' }] }
-  const live = { id: '2533', status: 'in-flight', stage: 'implement', workspace: '/w/2533' }
-  const r = nextActions(rush([live]), {}, 4, { questions: ask })
-  assert.deepEqual(kinds(r), ['decide:2533'], 'no resume while the question is open')
-  assert.match(r.due[0].detail, /automatic answer.*answers "results\/2533-attempt2\.json" and source agent-recommendation/)
-  // Deferring without answering is not settled: finish waits.
-  const deferred = { ...live, status: 'blocked', blockedReason: 'timeout-task' }
-  const d = nextActions(rush([deferred]), {}, 4, { questions: ask })
-  assert.deepEqual(kinds(d), ['decide:2533'])
-  assert.match(d.due[0].detail, /set it in-flight/)
-  // Once a decision answers it, the unit's normal steps return: resume, or a settled deferral.
-  const answered = { decisions: [{ id: 'd-9', answers: 'results/2533-attempt2.json' }] }
-  assert.deepEqual(kinds(nextActions(rush([live], answered), {}, 4, { questions: ask })), ['resume:2533'])
-  // An answered timeout-task block gets its fresh attempt with the decision, instead of ending the run.
-  assert.deepEqual(kinds(nextActions(rush([deferred], answered), {}, 4, { questions: ask })), ['retry-blocked:2533'])
-  // A busy unit's question waits for its worker.
-  assert.deepEqual(kinds(nextActions(rush([{ ...live, worker: 1, workerKind: 'fix' }]), {}, 4, { questions: ask })), [])
-})
-
-test('resolve-issues never blocks on the human: it takes the automatic answer, even for a unit already blocked on the question', () => {
-  // rush-3097: the run stopped to ask which merge path to take; the stop hook had to push it back.
-  const ask = { a: [{ key: 'results/a-1.json', ask: 'keep the old endpoint?' }] }
-  const live = { id: 'a', status: 'in-flight', stage: 'implement' }
-  const r = nextActions(plan([live]), {}, 4, { questions: ask })
-  assert.deepEqual(kinds(r), ['decide:a'])
-  assert.match(r.due[0].detail, /Take the automatic answer \(preflight\.md#never-block-on-the-human\)/)
-  assert.doesNotMatch(r.due[0].detail, /Ask the human/)
-  const waiting = nextActions(plan([{ ...live, status: 'blocked', blockedReason: 'human-decision' }]), {}, 4, { questions: ask })
-  assert.deepEqual(kinds(waiting), ['decide:a'], 'a unit blocked waiting for a reply is answered, not left waiting')
-  const deferred = plan([{ ...live, status: 'blocked', blockedReason: 'human-decision', humanItem: 2, humanNeed: 'approve dropping the required check' }], { decisions: [{ id: 'd1', answers: 'results/a-1.json' }] })
-  assert.deepEqual(kinds(nextActions(deferred, {}, 4, { questions: ask })), ['finish:'], 'once a decision defers it, the run finishes around it')
-})
-
-test('a review decide file at HEAD is decided, then review-verdict reruns with --decision (agentier #2521)', () => {
-  const unit = { id: '2521', status: 'in-flight', stage: 'done', pr: '#2541', headSha: 'a00ccf9' }
-  const decide = { '2521': { round: 2, head: 'a00ccf9', fix: false, complete: true, awaiting: false, blocking: true, decide: true, ask: 'R1: mixed selectors bypass refusal' } }
-  const rush = (extra = {}) => plan([unit], { skill: 'rush-issues', ...extra })
-  const r = nextActions(rush(), decide)
-  assert.deepEqual(kinds(r), ['decide:2521'])
-  assert.match(r.due[0].detail, /reviews\/2521-r2\.decide\.json: R1: mixed selectors bypass refusal/)
-  const after = nextActions(rush({ decisions: [{ id: 'd-3', answers: ['reviews/2521-r2.decide.json'] }] }), decide)
-  assert.deepEqual(kinds(after), ['review-verdict:2521'])
-  assert.match(after.due[0].detail, /with --decision d-3/)
-  // A deferred decide unit on --resume is decided, not reviewed again as a handback.
-  const blocked = { ...unit, status: 'blocked', blockedReason: 'review-handback' }
-  assert.deepEqual(kinds(nextActions(plan([blocked], { skill: 'rush-issues' }), decide, 4, { resume: true })), ['decide:2521', 'unblock:2521'])
-  // A decide file for an older HEAD asks nothing.
-  assert.deepEqual(kinds(nextActions(rush(), { '2521': { ...decide['2521'], head: 'old' } })), ['start-review:2521'])
-})
-
-test('CLI reads worker questions from results and decide files from reviews', (t) => {
-  const run = fs.mkdtempSync(path.join(os.tmpdir(), 'next-actions-decide-'))
-  t.after(() => fs.rmSync(run, { recursive: true, force: true }))
-  fs.mkdirSync(path.join(run, 'results'))
-  fs.mkdirSync(path.join(run, 'reviews'))
-  fs.writeFileSync(path.join(run, 'results', '7-attempt1.json'), JSON.stringify({ decisionNeeded: { question: 'retry or rewrite?', recommendation: 'rewrite' } }))
-  fs.writeFileSync(path.join(run, 'results', 'x-done.json'), JSON.stringify({ unit: '8', decisionNeeded: null }))
-  fs.writeFileSync(path.join(run, 'results', 'named.json'), JSON.stringify({ unit: '9', decisionNeeded: 'which schema?' }))
-  fs.writeFileSync(path.join(run, 'results', 'broken.json'), '{')
-  assert.deepEqual(readQuestions(run), { 7: [{ key: 'results/7-attempt1.json', ask: 'retry or rewrite?' }], 9: [{ key: 'results/named.json', ask: 'which schema?' }] })
-  fs.writeFileSync(path.join(run, 'reviews', '7-r2.json'), JSON.stringify({ head: 'h', complete: true, findings: [{ severity: 'P1' }] }))
-  fs.writeFileSync(path.join(run, 'reviews', '7-r2.decide.json'), JSON.stringify({ question: [{ id: 'R1', summary: 'void the receipt too?' }] }))
-  const { at: _at, ...seven } = readReviews(run)['7']
-  assert.deepEqual(seven, { round: 2, head: 'h', fix: false, complete: true, awaiting: false, blocking: true, decide: true, ask: 'R1: void the receipt too?' })
-  fs.writeFileSync(path.join(run, 'task-plan.json'), JSON.stringify(plan([{ id: '7', status: 'in-flight', stage: 'implement' }], { skill: 'rush-issues' })))
-  const out = spawnSync(process.execPath, [SCRIPT, '--slots', '4', '--run', run, '--peek', '--rules'], { encoding: 'utf8' })
-  assert.equal(out.status, 0, out.stderr)
-  assert.match(out.stdout, /^decide +unit 7 needs a decision \(results\/7-attempt1\.json: retry or rewrite\?\)/m)
-  assert.match(out.stdout, /Decide before you defer/)
-})
-
-test('a unit still proving itself with commits gets its draft PR before it resumes', () => {
-  // #1688 ran 11 hours of emulator work on 28 local commits: the PR waited for code done.
-  const units = [{ id: '1688', status: 'in-flight', stage: 'validate', headSha: 'abc123' }]
-  assert.deepEqual(kinds(nextActions(plan(units))), ['open-pr:1688', 'resume:1688'])
-  const open = [{ id: '1688', status: 'in-flight', stage: 'validate', headSha: 'abc123', pr: 'https://github.com/o/r/pull/1' }]
-  assert.deepEqual(kinds(nextActions(plan(open))), ['resume:1688'])
-  const fresh = [{ id: '1688', status: 'in-flight', stage: 'implement' }]
-  assert.deepEqual(kinds(nextActions(plan(fresh))), ['resume:1688'])
-})
-
-test('a block that can clear by itself gets automatic attempts at growing gaps before the run finishes', () => {
-  // skyee #3179/#3180 and agentier #2509 printed finish on offline runners and a GitHub TLS fault;
-  // the human had to type "try again" each time.
-  const at = Date.parse('2026-10-17T04:00:00Z')
-  const units = [{ id: '3187', status: 'blocked', blockedReason: 'retry-ci', blockedAt: '2026-10-17T04:00:00Z' }, { id: '3186', status: 'succeeded' }]
-  const early = nextActions(plan(units), {}, 4, { now: at + 10 * 60_000 })
-  assert.deepEqual(kinds(early), ['wait:3187'])
-  assert.match(early.due[0].detail, /2026-10-17T04:30:00\.000Z.*do not finish/)
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { now: at + 31 * 60_000 })), ['retry-blocked:3187'])
-  const second = [{ ...units[0], autoRetries: 1 }, units[1]]
-  assert.deepEqual(kinds(nextActions(plan(second), {}, 4, { now: at + 60 * 60_000 })), ['wait:3187'], 'the second gap is two hours')
-  const spent = [{ ...units[0], autoRetries: 3 }, units[1]]
-  assert.deepEqual(kinds(nextActions(plan(spent), {}, 4, { now: at + 24 * 3600_000 })), ['finish:'], 'after three attempts the block is settled')
-  const human = [{ id: '2493', status: 'blocked', blockedReason: 'human-decision', humanItem: 1, humanNeed: 'product owner resolves the runtime limit' }, units[1]]
-  assert.deepEqual(kinds(nextActions(plan(human), {}, 4, { now: at })), ['finish:'], 'a human-only block never retries by itself')
-})
-
-test('an outage blocker the run cannot fix is rechecked over time, so its dependents ship once it clears', () => {
-  // skyee #3201: every shared runner went offline; the run deferred and printed finish, and the
-  // runners were back hours later. The blocker unit now rechecks instead of ending the run.
-  const at = Date.parse('2026-10-16T16:00:00Z')
-  const units = [
-    { id: '3201', status: 'blocked', blockedReason: 'external-blocker', blockedAt: '2026-10-16T16:00:00Z' },
-    { id: '3179', status: 'pending', dependsOn: ['3201'] },
-    { id: '3118', status: 'succeeded' },
-  ]
-  assert.deepEqual(kinds(nextActions(plan(units), {}, 4, { now: at + 5 * 60_000 })), ['wait:3201'])
-  const due = nextActions(plan(units), {}, 4, { now: at + 40 * 60_000 })
-  assert.deepEqual(kinds(due), ['retry-blocked:3201'])
-  assert.match(due.due[0].detail, /rerun the command its issue records.*close the blocker issue and mark 3201 succeeded so the units behind it continue/)
-  const cleared = [{ ...units[0], status: 'succeeded' }, units[1], units[2]]
-  assert.deepEqual(kinds(nextActions(plan(cleared), {}, 4, { now: at + 41 * 60_000 })), ['fill-slot:3179'])
-})
-
-test('the narrow view says whether the run is done and which units have work, not each step', async () => {
-  const { narrowView } = await import('./next-actions.mjs')
-  const units = [{ id: '1688', status: 'in-flight', stage: 'validate', headSha: 'abc' }, { id: '1677', status: 'succeeded' }]
-  const view = narrowView(plan(units), nextActions(plan(units)))
-  assert.match(view, /run not done: units have work/)
-  assert.match(view, /units with work: 1688 \(choose each unit's next step yourself\)/)
-  assert.doesNotMatch(view, /open-pr|resume/)
-  const done = [{ id: '1677', status: 'succeeded' }]
-  assert.match(narrowView(plan(done), nextActions(plan(done))), /run done/)
-})
-
-test('the scheduler mode sets how much the text output prescribes; the run plan picks the default', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'na-mode-'))
-  const write = (extra) => fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: '1688', status: 'in-flight', stage: 'validate', headSha: 'abc' }], extra)))
-  const run = (...args) => spawnSync(process.execPath, [SCRIPT, '--run', dir, '--slots', '2', '--peek', ...args], { encoding: 'utf8' }).stdout
-  write({})
-  assert.match(run(), /^open-pr\s+open unit 1688's PR as a draft now/m, 'full is the default')
-  assert.match(run('--mode', 'narrow'), /run not done: units have work\nunits with work: 1688/)
-  const off = run('--mode', 'off')
-  assert.match(off, /^run not done\n/)
-  assert.doesNotMatch(off, /open-pr|1688/)
-  write({ schedulerMode: 'narrow' })
-  assert.match(run(), /units with work: 1688/, 'the plan\'s schedulerMode is the default')
-  assert.equal(JSON.parse(run('--json')).mode, 'narrow')
-  const bad = spawnSync(process.execPath, [SCRIPT, '--run', dir, '--slots', '2', '--peek', '--mode', 'loose'], { encoding: 'utf8' })
-  assert.match(bad.stderr, /scheduler mode must be full, narrow, off/)
-})
-
-test('the early draft PR opens while the worker still runs, but never behind a parent that will not land', () => {
-  const working = [{ id: '1688', status: 'in-flight', stage: 'implement', headSha: 'abc1234', worker: 4, workerKind: 'implement' }]
-  assert.deepEqual(kinds(nextActions(plan(working))), ['open-pr:1688'])
-  const behind = [{ id: 'p', status: 'blocked', blockedReason: 'human-decision', humanItem: 3, humanNeed: 'run the live migration' },
-    { id: 'c', status: 'in-flight', stage: 'implement', headSha: 'abc1234', dependsOn: ['p'], worker: 2, workerKind: 'implement' }]
-  assert.deepEqual(kinds(nextActions(plan(behind))).filter((k) => k.startsWith('open-pr')), [])
-})
-
-test('only blocks that can clear by waiting are retried over time; a due retry prints while other units work', () => {
-  const at = Date.parse('2026-10-17T04:00:00Z')
-  const stuck = [{ id: 'a', status: 'blocked', blockedReason: 'retry-implement', blockedAt: '2026-10-17T04:00:00Z' }, { id: 'b', status: 'succeeded' }]
-  assert.deepEqual(kinds(nextActions(plan(stuck), {}, 4, { now: at + 9 * 3600_000 })), ['finish:'], 'retry-implement settles: waiting does not fix it')
-  const busy = [{ id: 'ci', status: 'blocked', blockedReason: 'retry-ci', blockedAt: '2026-10-17T04:00:00Z' },
-    { id: 'w', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement' }]
-  assert.deepEqual(kinds(nextActions(plan(busy), {}, 4, { now: at + 31 * 60_000 })), ['retry-blocked:ci'])
-  const older = [{ id: 'ci', status: 'blocked', blockedReason: 'retry-ci' }, { id: 'w', status: 'in-flight', stage: 'implement', worker: 1, workerKind: 'implement' }]
-  assert.deepEqual(kinds(nextActions(plan(older), {}, 4, { now: at })), [], 'an untimed block waits until nothing else is left')
-  assert.deepEqual(kinds(nextActions(plan([older[0], { id: 'w', status: 'succeeded' }]), {}, 4, { now: at })), ['retry-blocked:ci'], 'then it gets one fresh attempt instead of finish')
-})
-
-test('finish and wait exit 0 like any other answer; --exit-due makes any due action exit 1', (t) => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'na-finish-'))
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
-  fs.writeFileSync(path.join(dir, 'task-plan.json'), JSON.stringify(plan([{ id: 'a', status: 'succeeded', stage: 'done' }])))
-  const call = (...extra) => spawnSync(process.execPath, [SCRIPT, '--slots', '4', '--run', dir, '--peek', ...extra], { encoding: 'utf8' })
-  const done = call('--json')
-  assert.equal(done.status, 0, done.stderr)
-  const out = JSON.parse(done.stdout)
-  assert.deepEqual(out.due.map((a) => a.action), ['finish'])
-  assert.equal(out.exitDue, true)
-  assert.equal(call('--exit-due').status, 1)
-})