@1aboveio/skills 1.0.8 → 1.0.9

package/skills/cicd/mergify/scripts/watch-pr-delivery.test.mjs

@@ -1,1826 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, writeFileSync, chmodSync, readFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-// @characterizes mergify-watch-pr-delivery-cli
-// @covers mergify-watch-pr-delivery-core
-// @level integration
-import { DEFAULT_ADMISSION_STALL_MINUTES, DEFAULT_INTERVAL_SECONDS, DEFAULT_MAX_MINUTES, DEFAULT_SLOW_JOB_MINUTES, DEFAULT_STALL_MINUTES, MAX_MINUTES_CEILING, checkTimings, ciProfile, ciProfileSummary, mergeCiJobs, newSlowJobs, nextPhaseTimings, slowJobWarning, classifyDequeue, classifyObservation, dequeueInfoFromComments, dequeuedAtFromComments, effectiveStallMinutes, mergifyQueueShowArgs, nextMissingActiveReads, nextPhases, nextStallObservation, observationKey, parseArgs, progressRecord, readTimeoutForArgs, readTimeoutMs, run, runCli, stallVerdict, summarizeStatusChecks } from './watch-pr-delivery-core.mjs'
-
-// ---- fake `gh`/`mergify` on PATH, for loop-level (runCli-driven) regression tests ----
-//
-// The pure-function tests above pin `nextMissingActiveReads`/`readTimeoutMs` in isolation —
-// review of PR #612 proved that is not enough: reverting the poll loop's wiring of either
-// helper back to its pre-fix inline form (helpers still exported, just unused) left the
-// whole suite green, because nothing exercised `runCli` itself. These tests drive the real
-// CLI against fake `gh`/`mergify` executables placed first on `PATH`, so a wiring regression
-// at the call site — not just in the helper — turns them red.
-function makeFakeBin(dir, name, script) {
-  const p = join(dir, name)
-  writeFileSync(p, `#!/bin/sh\n${script}\n`)
-  chmodSync(p, 0o755)
-}
-
-async function withFakeBinsOnPath(fn) {
-  const dir = mkdtempSync(join(tmpdir(), 'watch-pr-delivery-fakebin-'))
-  const originalPath = process.env.PATH
-  process.env.PATH = `${dir}:${originalPath}`
-  try {
-    return await fn(dir)
-  } finally {
-    process.env.PATH = originalPath
-    rmSync(dir, { recursive: true, force: true })
-  }
-}
-
-// A `gh` fake that emits arbitrary JSON via a quoted heredoc rather than `echo '...'`. Needed
-// whenever the JSON contains a comment body with a real embedded newline (the Mergify status-
-// comment payload block below is multi-line) — `echo`'ing a JS string's `\n` escape sequence
-// verbatim round-trips through macOS `/bin/sh` (bash in POSIX/XSI mode) as an ACTUAL newline,
-// which is an unescaped control character inside a JSON string and makes the observation
-// silently `readable: false` instead of exercising the logic under test (discovered while
-// testing issue #629's first fix; see the regression tests below). A heredoc with a quoted
-// delimiter (`<<'EOF'`) is never escape-processed by the shell, so it reproduces the file's
-// real newlines byte for byte.
-function makeFakeGhReturning(dir, jsonObj) {
-  const json = JSON.stringify(jsonObj)
-  const p = join(dir, 'gh')
-  writeFileSync(p, `#!/bin/sh\ncat <<'GH_FIXTURE_EOF'\n${json}\nGH_FIXTURE_EOF\n`)
-  chmodSync(p, 0o755)
-}
-
-// Captures BOTH streams. stderr matters as much as stdout now that the loop emits a per-poll
-// progress heartbeat there: tests that only watched stdout would let the heartbeat regress to
-// silence (the original defect) while staying green, and would also spray heartbeats over the
-// test runner's own output.
-async function runCliCapturingLastPayload(argv) {
-  const lines = []
-  const errLines = []
-  const originalLog = console.log
-  const originalError = console.error
-  console.log = (value) => lines.push(String(value))
-  console.error = (value) => errLines.push(String(value))
-  let code
-  try {
-    code = await runCli(argv)
-  } finally {
-    console.log = originalLog
-    console.error = originalError
-  }
-  return { code, payload: JSON.parse(lines[lines.length - 1]), stdoutLines: lines, progressLines: errLines }
-}
-
-// Formats a Date as the "YYYY-MM-DD HH:MM UTC" shape Mergify's status comment uses, for
-// building fixture comment bodies whose timestamp is guaranteed FRESH relative to `Date.now()`
-// at test time — a fixed clock-independent offset (`+minutesFromNow`), not "now" truncated to
-// the minute, which would flake depending on where in the minute the test happens to run.
-function mergifyTimestamp(minutesFromNow) {
-  const d = new Date(Date.now() + minutesFromNow * 60_000)
-  const pad = (n) => String(n).padStart(2, '0')
-  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())} UTC`
-}
-
-// Builds a REALISTIC Mergify status-comment body: the machine-readable payload block
-// `dequeuedAtFromComments` now keys off (BLOCK-1/2 fix, review on PR #637), plus the human-
-// rendered "Entered queue"/"Left the queue" lines it still parses for the actual timestamp.
-// Shape verified against the real PR #620 payload — see `pr-620-mergify-comments.fixture.json`.
-function mergifyStatusComment({ state, enteredAt, leftAt, batchPrNumber = null, rawReason = null, failingChecks = [] }) {
-  const payload = JSON.stringify({
-    version: 1, state, queue_rule_name: 'default',
-    queued_at: '2026-01-01T00:00:00.000000+00:00', estimated_time_of_merge: null,
-    speculative_check_pr: null, required_conditions: [],
-  })
-  const lines = [
-    '<!---', 'DO NOT EDIT', '-*- Mergify Payload -*-', payload, '-*- Mergify Payload End -*-', '-->',
-    '', '# Merge Queue Status', '',
-    `- ✅ **Entered queue** — \`${enteredAt}\` · Rule: \`default\``,
-  ]
-  if (batchPrNumber) lines.push(`- ❌ **Checks failed** · on draft #${batchPrNumber}`)
-  if (leftAt) lines.push(`- 🚫 **Left the queue** — \`${leftAt}\` · at \`abc123\``)
-  if (rawReason) lines.push('', '## Reason', '', rawReason)
-  if (failingChecks.length > 0) {
-    lines.push('', 'Failing checks:')
-    for (const check of failingChecks) {
-      const icon = check.status === 'CANCELLED' ? '🟠' : (check.status === 'TIMED_OUT' ? '🛑' : '❌')
-      lines.push(`- ${icon} [${check.name}](${check.detailsUrl || 'https://example.test/check'})`)
-    }
-  }
-  return lines.join('\n')
-}
-
-function makeFakeGhForBatch(dir, { original, batches = {} }) {
-  const cases = [
-    `1) cat <<'GH_ORIGINAL_EOF'\n${JSON.stringify(original)}\nGH_ORIGINAL_EOF\n;;`,
-    ...Object.entries(batches).map(([number, value]) => value
-      ? `${number}) cat <<'GH_BATCH_${number}_EOF'\n${JSON.stringify(value)}\nGH_BATCH_${number}_EOF\n;;`
-      : `${number}) exit 1 ;;`),
-  ]
-  makeFakeBin(dir, 'gh', `case "$3" in\n${cases.join('\n')}\n*) exit 1 ;;\nesac`)
-}
-
-async function runSyntheticBatchDequeue({ queueBatchNumbers, batches, rawReason, providerChecks, commentBatchNumber = null }) {
-  return withFakeBinsOnPath(async (dir) => {
-    const renderedBatchNumber = commentBatchNumber ?? queueBatchNumbers[queueBatchNumbers.length - 1]
-    makeFakeGhForBatch(dir, {
-      original: {
-        state: 'OPEN', mergedAt: null, mergeCommit: null, headRefOid: 'unchanged-head',
-        labels: [{ name: 'dequeued' }], url: 'https://example.test/original', statusCheckRollup: [],
-        comments: [{
-          author: { login: 'mergify' },
-          body: mergifyStatusComment({
-            state: 'dequeued', enteredAt: mergifyTimestamp(1), leftAt: mergifyTimestamp(2),
-            batchPrNumber: renderedBatchNumber, rawReason, failingChecks: providerChecks,
-          }),
-        }],
-      },
-      batches,
-    })
-    const counter = join(dir, 'batch-poll-count')
-    const activeCases = queueBatchNumbers.map((number, index) => (
-      `${index}) echo '${JSON.stringify({ number: 1, position: 0, queue_rule_name: 'main', mergeability_check: { state: 'pending', queue_pull_request_number: number } })}' ;;`
-    ))
-    makeFakeBin(dir, 'mergify', [
-      `n=$(cat ${counter} 2>/dev/null || echo 0)`,
-      `echo $((n + 1)) > ${counter}`,
-      'case "$n" in',
-      ...activeCases,
-      '*) echo \'{"number":1,"queued":false}\' ;;',
-      'esac',
-    ].join('\n'))
-    return runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.01', '--stall-minutes', '5', '--max-minutes', '5',
-    ])
-  })
-}
-
-// A non-status mergify comment — a `@mergifyio queue` command acknowledgement, matching PR
-// #620's actual last comment verbatim in shape — used to prove the fix does not simply pick
-// "the last mergify comment" (BLOCK-1/2's exact defect).
-const MERGIFY_COMMAND_ACK_BODY = '> queue\n\n#### ☑️ Command `queue` ignored because it is already running from a previous command.'
-
-// The real PR #620 comments payload (`gh pr view --json comments`, mergify-authored only) —
-// issue #629 reproduced on this PR, and review of PR #637 verified live that the first fix's
-// `dequeuedAtFromComments` returned `null` against it. Committed as a fixture because it is
-// the one input that distinguishes "last mergify comment" from "last comment whose payload
-// state is dequeued" (NOTE-1).
-//
-// issue #639 (p3): this fixture is the SOLE proof `dequeuedAtFromComments` reads real Mergify
-// output rather than an idealised shape, and nothing re-checks it against a live PR. It
-// depends on two rendering details Mergify controls, not this repo: the
-// `<!--- ... -*- Mergify Payload -*- ... -->` marker block, and the minute-precision
-// "Left the queue — YYYY-MM-DD HH:MM UTC" text line. If either changes, this suite stays
-// green while the production parser silently degrades to `null` for every PR, forever.
-//
-// Deliberately left undetected rather than given a periodic re-fetch script, in or out of
-// CI, for three reasons: (1) a meaningful check needs a CURRENTLY-dequeuing PR, not #620 —
-// #620 is merged, so re-fetching only catches GitHub retroactively rewriting old comment
-// text, not Mergify changing its rendering going forward, and finding "the current live
-// dequeue" well enough to assert against is real ongoing infrastructure, not a fixture
-// refresh; (2) this repo has no gh-authenticated, network-reachable cron to run it from —
-// a script nobody invokes is a check that LOOKS like coverage while providing none, which is
-// worse than documenting the gap plainly; (3) the failure mode is fail-safe by construction —
-// `dequeuedAtFromComments` returning `null` makes `classifyObservation`/`classifyPrState` fail
-// toward WAITING (see NOTE-2 below), never toward a false terminal verdict, so silent drift
-// costs a watch running out its stall/max-minutes bound on a live PR, not a wrong answer
-// reported as fact. That bounded, visible cost — not a green check nobody wrote — is the
-// actual signal: if Mergify's rendering ever changes, a real delivery watch stalls instead of
-// settling promptly, which is noticeable in exactly the place someone would look. Refresh
-// this fixture from that PR's real comments (`gh pr view <pr> --json comments -q
-// '[.comments[] | select(.author.login=="mergify")]'`) if that happens.
-const PR_620_MERGIFY_COMMENTS = JSON.parse(readFileSync(new URL('./pr-620-mergify-comments.fixture.json', import.meta.url), 'utf8'))
-
-test('merged PR returns MERGED with the merge commit SHA', () => {
-  const verdict = classifyObservation({ pr: { state: 'MERGED', mergedAt: '2026-07-27T00:00:00Z', mergeCommitOid: 'abc123' } })
-  assert.equal(verdict.terminal, true)
-  assert.equal(verdict.outcome, 'MERGED')
-  assert.equal(verdict.mergedSha, 'abc123')
-})
-
-test('merged PR without merge SHA is terminal but not a proved merge', () => {
-  const verdict = classifyObservation({ pr: { state: 'MERGED', mergedAt: '2026-07-27T00:00:00Z' } })
-  assert.equal(verdict.terminal, true)
-  assert.equal(verdict.outcome, 'CLOSED_UNMERGED')
-  assert.equal(verdict.reason, 'merged-without-sha')
-})
-
-test('dequeued label is a terminal queue exit when applied at or after this watch started', () => {
-  const verdict = classifyObservation({ pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: 1000, dequeuedAtMs: 1000 })
-  assert.equal(verdict.terminal, true)
-  assert.equal(verdict.outcome, 'DEQUEUED')
-  assert.equal(verdict.reason, 'dequeued-label')
-})
-
-test('NOTE-2: a dequeue timestamped up to 60s BEFORE watch start still settles terminal — the minute-truncation grace period', () => {
-  // `dequeuedAtMs` is minute-truncated (no seconds in Mergify's rendered text) while
-  // `startedMs` is millisecond-precision, so without a grace period a genuine dequeue landing
-  // in the SAME wall-clock minute as watch start always parses to a value below `startedMs`
-  // and reads as stale — a blind spot for the first minute of every watch. 59_999ms before
-  // start is the tightest case still inside the grace window; 60_001ms before start is just
-  // outside it.
-  const insideGrace = classifyObservation({ pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: 100_000, dequeuedAtMs: 100_000 - 59_999 })
-  assert.equal(insideGrace.terminal, true, 'a dequeue 59999ms before start must still settle, or every watch has a blind first minute')
-  assert.equal(insideGrace.outcome, 'DEQUEUED')
-
-  const outsideGrace = classifyObservation({ pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: 100_000, dequeuedAtMs: 100_000 - 60_001 })
-  assert.notEqual(outsideGrace.outcome, 'DEQUEUED', 'a dequeue over 60s before start is genuinely stale, not a truncation artifact')
-})
-
-// ---- issue #629: a `dequeued` label is a lifecycle mirror, not the queue itself, and it is
-// never removed on re-enqueue — so a PR dequeued once, fixed, and re-enqueued still carries
-// the label into a watch launched for the second attempt. Reproduced live on PR #620: a
-// watcher returned terminal DEQUEUED in 3.9s while the PR was in fact queued and later merged.
-
-test('an active queue (queued label OR queue tool) wins over even a freshly-timestamped dequeued label', () => {
-  // startedMs/dequeuedAtMs are deliberately FRESH here (would settle DEQUEUED on their own) —
-  // this isolates the "prefer the queue tool" guard from the freshness guard: if the `!active`
-  // check were dropped, this alone would still read DEQUEUED even though the queue is active.
-  for (const input of [
-    { pr: { state: 'OPEN', labels: ['dequeued', 'queued'] }, startedMs: 1000, dequeuedAtMs: 2000 },
-    { pr: { state: 'OPEN', labels: ['dequeued'] }, queue: { queued: true }, startedMs: 1000, dequeuedAtMs: 2000 },
-  ]) {
-    const verdict = classifyObservation(input)
-    assert.equal(verdict.terminal, false, JSON.stringify(input))
-    assert.equal(verdict.outcome, 'QUEUED', JSON.stringify(input))
-  }
-})
-
-test('a dequeued label whose timestamp predates this watch is not this attempt\'s outcome', () => {
-  // The gap must exceed the NOTE-2 60s grace period (see the guard's comment in the source),
-  // or this would pass for the wrong reason — a genuinely stale label inside the grace window
-  // reads as fresh by design, so the fixture needs an unambiguous, much-larger gap.
-  const verdict = classifyObservation({ pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: 10 * 60_000, dequeuedAtMs: 0 })
-  assert.notEqual(verdict.outcome, 'DEQUEUED')
-  assert.equal(verdict.terminal, false)
-})
-
-test('a dequeued label with no reliable timestamp fails toward WAITING, never toward a terminal verdict', () => {
-  for (const input of [
-    { pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: 10 * 60_000, dequeuedAtMs: null },
-    { pr: { state: 'OPEN', labels: ['dequeued'] }, startedMs: null, dequeuedAtMs: 9999 },
-    { pr: { state: 'OPEN', labels: ['dequeued'] } },
-  ]) {
-    const verdict = classifyObservation(input)
-    assert.notEqual(verdict.outcome, 'DEQUEUED', JSON.stringify(input))
-  }
-})
-
-// ---- dequeuedAtFromComments (BLOCK-1/2 fix, review on PR #637) ----
-//
-// The first version read `mergifyComments[mergifyComments.length - 1]` on the premise that
-// "the last mergify comment reflects the most recent cycle" — false on real data: Mergify also
-// posts merge-protection summaries and command acknowledgements from the same account, and
-// those interleave with (and are often more recent than) the actual queue-status comments.
-// Verified live against PR #620 (the PR issue #629 reproduces on): the shipped helper returned
-// `null` against its real payload. The fix scans every mergify comment's embedded
-// `-*- Mergify Payload -*-` block and selects the LAST one whose `state` is `"dequeued"`.
-
-test('dequeuedAtFromComments finds the dequeued status comment even with a non-status comment after it', () => {
-  // The exact PR #620 shape (NOTE-1's required rewrite): an earlier STATUS comment reporting
-  // state:"dequeued" with a "Left the queue" line, then a LATER mergify comment that carries
-  // no payload at all (a command acknowledgement) — the old "last comment" logic returned
-  // null here; the fix must still recover the timestamp from the correct, earlier comment.
-  const ms = dequeuedAtFromComments([
-    { author: { login: 'someone-else' }, body: 'Left the queue** — `2099-01-01 00:00 UTC`' },
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2026-07-28 11:02 UTC', leftAt: '2026-07-28 11:04 UTC' }) },
-    { author: { login: 'mergify' }, body: MERGIFY_COMMAND_ACK_BODY },
-  ])
-  assert.equal(ms, Date.UTC(2026, 6, 28, 11, 4))
-})
-
-test('dequeuedAtFromComments recovers the real PR #620 payload correctly', () => {
-  // The committed fixture is the exact `gh pr view --json comments` output for the PR issue
-  // #629 reproduced on — the one input that distinguishes "last mergify comment" (broken) from
-  // "last mergify comment whose payload state is dequeued" (this fix). Its 4 mergify comments
-  // are: a merge-protections summary, a status comment ending state:"dequeued" (this is the
-  // one), a LATER status comment ending state:"merged", and a command-ack with no payload at
-  // all as the actual last comment.
-  const ms = dequeuedAtFromComments(PR_620_MERGIFY_COMMENTS)
-  assert.equal(ms, Date.UTC(2026, 6, 28, 11, 4), 'must recover 2026-07-28 11:04 UTC from the real payload, not null')
-})
-
-test('dequeuedAtFromComments does NOT key off "the last status comment, whatever its state" — a later merged state must not be read as dequeued', () => {
-  // The deliberate design decision (stated in the source comment): select the most recent
-  // comment whose state HAPPENS TO BE "dequeued", not the most recent status comment period.
-  // On #620 the last status comment is state:"merged" — keying off "last status comment"
-  // would read a freshly-MERGED PR as still dequeued, which is #629's failure mode from the
-  // opposite direction. This exercises exactly that shape without the fixture's other noise.
-  const ms = dequeuedAtFromComments([
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2026-07-28 11:02 UTC', leftAt: '2026-07-28 11:04 UTC' }) },
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'merged', enteredAt: '2026-07-28 11:20 UTC' }) },
-  ])
-  assert.equal(ms, Date.UTC(2026, 6, 28, 11, 4), 'the earlier DEQUEUED-state comment is the correct answer; a later merged-state comment must not be read as a fresh dequeue')
-})
-
-test('dequeuedAtFromComments prefers the LAST dequeued-state comment when there have been multiple dequeue cycles', () => {
-  const ms = dequeuedAtFromComments([
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2026-01-01 00:00 UTC', leftAt: '2026-01-01 00:05 UTC' }) },
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'queued', enteredAt: '2026-01-02 00:00 UTC' }) },
-    { author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2026-01-02 00:00 UTC', leftAt: '2026-01-02 00:10 UTC' }) },
-  ])
-  assert.equal(ms, Date.UTC(2026, 0, 2, 0, 10), 'must recover the SECOND dequeue cycle, not the first')
-})
-
-test('dequeuedAtFromComments returns null with no mergify comment, no dequeued-state comment, or a malformed payload', () => {
-  assert.equal(dequeuedAtFromComments([]), null)
-  assert.equal(dequeuedAtFromComments(undefined), null)
-  assert.equal(dequeuedAtFromComments([{ author: { login: 'mergify' }, body: 'nothing relevant here' }]), null)
-  assert.equal(
-    dequeuedAtFromComments([{ author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'queued', enteredAt: '2026-01-01 00:00 UTC' }) }]),
-    null,
-    'a status comment whose state is not "dequeued" must not be treated as one',
-  )
-  assert.equal(
-    dequeuedAtFromComments([{ author: { login: 'mergify' }, body: '<!---\nDO NOT EDIT\n-*- Mergify Payload -*-\n{not valid json\n-*- Mergify Payload End -*-\n-->' }]),
-    null,
-    'an unparseable payload must be skipped, not thrown',
-  )
-  assert.equal(
-    dequeuedAtFromComments([{ author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2026-01-01 00:00 UTC' }) }]),
-    null,
-    'a dequeued-state comment with no "Left the queue" line has no timestamp to recover',
-  )
-})
-
-test('issue #1232: dequeueInfoFromComments retains the provider reason, batch PR, and reported checks', () => {
-  const comments = [{
-    author: { login: 'mergify' },
-    body: mergifyStatusComment({
-      state: 'dequeued',
-      enteredAt: '2026-08-30 07:00 UTC',
-      leftAt: '2026-08-30 07:05 UTC',
-      batchPrNumber: 706,
-      rawReason: 'The merge conditions cannot be satisfied due to failing checks',
-      failingChecks: [
-        { name: 'TypeScript typecheck', status: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' },
-        { name: 'Vitest', status: 'FAILURE', detailsUrl: 'https://example.test/vitest' },
-        { name: 'Full gate', status: 'TIMED_OUT', detailsUrl: 'https://example.test/full-gate' },
-      ],
-    }),
-  }]
-  const info = dequeueInfoFromComments(comments)
-  assert.equal(info.dequeuedAtMs, Date.UTC(2026, 7, 30, 7, 5))
-  assert.equal(info.rawReason, 'The merge conditions cannot be satisfied due to failing checks')
-  assert.equal(info.batchPrNumber, 706)
-  assert.deepEqual(info.providerFailedChecks, [
-    { name: 'TypeScript typecheck', status: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' },
-    { name: 'Vitest', status: 'FAILURE', detailsUrl: 'https://example.test/vitest' },
-    { name: 'Full gate', status: 'TIMED_OUT', detailsUrl: 'https://example.test/full-gate' },
-  ])
-})
-
-test('issue #1232: dequeue routing separates cancellation, hard failure, stale HEAD, conflict, and unknown reasons', () => {
-  assert.equal(classifyDequeue({ failedChecks: [{ status: 'CANCELLED' }] }), 'checks-cancelled')
-  for (const status of ['FAILURE', 'ERROR', 'TIMED_OUT']) {
-    assert.equal(classifyDequeue({ failedChecks: [{ status }] }), 'checks-failed')
-  }
-  assert.equal(classifyDequeue({ rawReason: 'pull-request-updated' }), 'pull-request-updated')
-  assert.equal(classifyDequeue({ rawReason: 'conflict-with-base-branch' }), 'conflict')
-  assert.equal(classifyDequeue({ rawReason: 'Pull request #1234 has been dequeued by @user with a `dequeue` command' }), 'manual')
-  assert.equal(classifyDequeue({ rawReason: 'provider added a new reason' }), 'unknown')
-})
-
-test('issue #1232: a synthetic batch failure reports the retained batch PR and actionable check', async () => {
-  const { code, payload, stdoutLines } = await runSyntheticBatchDequeue({
-    queueBatchNumbers: [706],
-    rawReason: 'The merge conditions cannot be satisfied due to failing checks',
-    providerChecks: [{ name: 'TypeScript typecheck', status: 'FAILURE' }],
-    batches: {
-      706: {
-        state: 'CLOSED', url: 'https://example.test/batch/706',
-        statusCheckRollup: [{ name: 'TypeScript typecheck', status: 'COMPLETED', conclusion: 'FAILURE', detailsUrl: 'https://example.test/typecheck' }],
-      },
-    },
-  })
-  assert.equal(code, 4)
-  assert.equal(stdoutLines.length, 1, 'stdout remains exactly one terminal JSON document')
-  assert.equal(payload.outcome, 'DEQUEUED')
-  assert.equal(payload.reason, 'checks-failed')
-  assert.equal(payload.rawReason, 'The merge conditions cannot be satisfied due to failing checks')
-  assert.equal(payload.batchPrNumber, 706)
-  assert.deepEqual(payload.failedChecks, [{ name: 'TypeScript typecheck', status: 'FAILURE', detailsUrl: 'https://example.test/typecheck' }])
-  assert.equal(payload.batchPr.readable, true)
-})
-
-test('issue #1232: cancellation during dependency installation is distinct from a hard check failure', async () => {
-  const { payload } = await runSyntheticBatchDequeue({
-    queueBatchNumbers: [706],
-    rawReason: 'The merge conditions cannot be satisfied due to failing checks',
-    providerChecks: [{ name: 'TypeScript typecheck', status: 'CANCELLED' }],
-    batches: {
-      706: {
-        state: 'CLOSED', url: 'https://example.test/batch/706',
-        statusCheckRollup: [{ name: 'TypeScript typecheck', status: 'COMPLETED', conclusion: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' }],
-      },
-    },
-  })
-  assert.equal(payload.reason, 'checks-cancelled')
-  assert.deepEqual(payload.failedChecks, [{ name: 'TypeScript typecheck', status: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' }])
-})
-
-test('issue #1232: an unavailable batch PR preserves the provider reason and truthful read failure', async () => {
-  const { payload } = await runSyntheticBatchDequeue({
-    queueBatchNumbers: [706],
-    rawReason: 'The merge conditions cannot be satisfied due to failing checks',
-    providerChecks: [{ name: 'TypeScript typecheck', status: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' }],
-    batches: { 706: null },
-  })
-  assert.equal(payload.outcome, 'DEQUEUED')
-  assert.equal(payload.rawReason, 'The merge conditions cannot be satisfied due to failing checks')
-  assert.equal(payload.batchPrNumber, 706)
-  assert.equal(payload.batchPr.readable, false)
-  assert.match(payload.batchPr.error, /failed|status 1/i)
-  assert.deepEqual(payload.failedChecks, [{ name: 'TypeScript typecheck', status: 'CANCELLED', detailsUrl: 'https://example.test/typecheck' }])
-})
-
-test('issue #1232: unchanged-SHA requeue replaces stale batch context with the newest active batch', async () => {
-  const { payload } = await runSyntheticBatchDequeue({
-    queueBatchNumbers: [706, 707],
-    commentBatchNumber: 706,
-    rawReason: 'The merge conditions cannot be satisfied due to failing checks',
-    providerChecks: [{ name: 'old batch check', status: 'FAILURE' }],
-    batches: {
-      706: { state: 'CLOSED', url: 'https://example.test/batch/706', statusCheckRollup: [{ name: 'old batch check', conclusion: 'FAILURE' }] },
-      707: { state: 'CLOSED', url: 'https://example.test/batch/707', statusCheckRollup: [{ name: 'new batch check', conclusion: 'FAILURE' }] },
-    },
-  })
-  assert.equal(payload.pr.headRefOid, 'unchanged-head')
-  assert.equal(payload.batchPrNumber, 707, 'the last active queue observation wins over stale comment fallback')
-  assert.equal(payload.batchPr.url, 'https://example.test/batch/707')
-  assert.equal(payload.failedChecks[0].name, 'new batch check')
-})
-
-test('regression #629: the queue tool reporting active must win even over a FRESHLY-timestamped dequeued label', async () => {
-  // The comment's "Left the queue" timestamp is deliberately in the future relative to now
-  // (so it would read as fresh/this-watch's on its own) — this isolates the "prefer the queue
-  // tool" guard: dropping it would let this settle DEQUEUED despite `mergify queue show`
-  // simultaneously reporting the PR active.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, {
-      state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'dequeued' }], url: 'https://x',
-      comments: [{ author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: mergifyTimestamp(3), leftAt: mergifyTimestamp(5) }) }],
-    })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":true}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.notEqual(payload.outcome, 'DEQUEUED', `the queue tool reporting active must win over the stale dequeued label mirror: ${JSON.stringify(payload)}`)
-    assert.notEqual(payload.reason, 'dequeued-label')
-  })
-})
-
-test('regression #629: a dequeued label whose Mergify comment timestamp predates the watch is not reported as this attempt\'s outcome', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, {
-      state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'dequeued' }], url: 'https://x',
-      // Years stale — unambiguously outside the NOTE-2 60s grace period.
-      comments: [{ author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: '2020-01-01 00:00 UTC', leftAt: '2020-01-01 00:05 UTC' }) }],
-    })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.notEqual(payload.outcome, 'DEQUEUED', `a dequeue timestamped before this watch started must not be reported as this attempt's outcome: ${JSON.stringify(payload)}`)
-  })
-})
-
-test('regression #629: the REAL PR #620 payload must not settle DEQUEUED immediately (the exact live repro)', async () => {
-  // The exact shape review of PR #637 verified live: this fixture's most recent mergify
-  // comment (a command acknowledgement) carries no payload, and its most recent STATUS
-  // comment is state:"merged" — the actual dequeue happened two comments back. The PR also
-  // no longer carries the `dequeued` label in real life (it went on to merge), so this test
-  // adds that label back onto the fixture PR deliberately, to pin the specific claim: given
-  // this real comment history, a `dequeued` label reads as the FIRST cycle's stale leftover,
-  // not a fresh terminal verdict — the mechanism BLOCK-1/2 was about.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, {
-      state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'dequeued' }], url: 'https://x',
-      comments: PR_620_MERGIFY_COMMENTS,
-    })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.notEqual(payload.outcome, 'DEQUEUED', `the real #620 payload's dequeue (2026-07-28 11:04 UTC) predates this watch and must not settle terminal: ${JSON.stringify(payload)}`)
-  })
-})
-
-test('regression #629: a GENUINELY fresh dequeue (not stale, not active) still settles DEQUEUED promptly', async () => {
-  // The positive-path counterpart to the two tests above: proves `startedMs`/`dequeuedAtMs`
-  // are actually WIRED from `runCli` into `classifyObservation`, not just correct in
-  // isolation. Without the wiring, this would never settle DEQUEUED and would instead run out
-  // the clock to STALLED — which the assertions below catch by requiring the FAST exit path
-  // (few observations, well under the stall bound) rather than merely "terminal, eventually".
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, {
-      state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'dequeued' }], url: 'https://x',
-      // +2min, not +1min: `mergifyTimestamp` truncates to the minute, so a +1min value only
-      // exceeds `startedMs` if fixture-build and `runCli`'s own `Date.now()` land in the same
-      // wall-clock minute — margin as low as -1999ms across a build interval up to 2000ms
-      // (BLOCK-3/4, review on PR #637, reproduced deterministically: building at 59500ms into
-      // the minute with a 1000ms build interval yields a false STALLED). +2min's worst-case
-      // margin across the same interval range is +58001ms — safe for any interval under 60s.
-      comments: [{ author: { login: 'mergify' }, body: mergifyStatusComment({ state: 'dequeued', enteredAt: mergifyTimestamp(-2), leftAt: mergifyTimestamp(2) }) }],
-    })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'DEQUEUED', `a dequeue timestamped at/after this watch started must settle as this attempt's outcome: ${JSON.stringify(payload)}`)
-    assert.equal(payload.reason, 'dequeued-label')
-    assert.equal(payload.observations, 1, 'must settle on the FIRST poll, not by running out the stall clock')
-  })
-})
-
-// issue #639 (round-2 review of PR #637): the test above uses `mergifyTimestamp(2)`, not `(1)`,
-// but nothing pinned WHY — mutating it back to `(1)` while leaving the NOTE-2 grace period
-// intact left the whole suite green, because the grace period alone already absorbs a `(1)`
-// dequeue at every clock position. This test pins the margin itself, independent of the CLI
-// and the grace period: `mergifyTimestamp` truncates to the minute, so the gap between "now"
-// and the parsed, minute-floored timestamp is `offset*60_000 - s`, where `s` is milliseconds
-// already elapsed in the current minute. For `offset = 2` that gap exceeds 60_000 at every `s`
-// in `[0, 60_000)`; for `offset = 1` it is always below 60_000 (reviewer-measured margins:
-// `(2)` 60100ms-109872ms, `(1)` 100ms-49872ms) — so this assertion discriminates the two at
-// every position in the minute, not just on average.
-test('regression #639: mergifyTimestamp(2)\'s dequeue margin clears 60s at any position in the minute', () => {
-  const before = Date.now()
-  const body = mergifyStatusComment({ state: 'dequeued', enteredAt: mergifyTimestamp(-2), leftAt: mergifyTimestamp(2) })
-  const parsed = dequeuedAtFromComments([{ author: { login: 'mergify' }, body }])
-  assert.ok(parsed - before >= 60_000, `mergifyTimestamp(2)'s margin over the 60s grace must hold at every clock position: parsed=${parsed}, before=${before}, margin=${parsed - before}`)
-})
-
-test('queued label or queue membership marks active queue membership', () => {
-  for (const input of [
-    { pr: { state: 'OPEN', labels: ['queued'] }, queue: { queued: false } },
-    { pr: { state: 'OPEN', labels: [] }, queue: { queued: true, position: 2 } },
-  ]) {
-    const verdict = classifyObservation(input)
-    assert.equal(verdict.terminal, false)
-    assert.equal(verdict.outcome, 'QUEUED')
-    assert.equal(verdict.seenQueued, true)
-  }
-})
-
-test('queued:false before queue entry is NOT_YET_QUEUED, not a dequeue', () => {
-  const verdict = classifyObservation({ pr: { state: 'OPEN', labels: [] }, queue: { queued: false }, seenQueued: false, missingActiveReads: 9 })
-  assert.equal(verdict.terminal, false)
-  assert.equal(verdict.outcome, 'NOT_YET_QUEUED')
-})
-
-test('failed non-Mergify checks stop pre-admission without claiming a dequeue', () => {
-  const verdict = classifyObservation({
-    pr: {
-      state: 'OPEN',
-      labels: [],
-      failedChecks: [{ name: 'Warehouse ETL tests', status: 'FAILURE', detailsUrl: 'https://ci/job/1' }],
-    },
-    queue: { queued: false },
-    everActive: false,
-  })
-  assert.equal(verdict.terminal, true)
-  assert.equal(verdict.outcome, 'STALLED')
-  assert.equal(verdict.reason, 'admission-checks-failed')
-  assert.equal(verdict.preAdmission, true)
-  assert.deepEqual(verdict.failedChecks.map((check) => check.name), ['Warehouse ETL tests'])
-})
-
-test('active queue membership remains authoritative over a failed GitHub check', () => {
-  const verdict = classifyObservation({
-    pr: { state: 'OPEN', labels: [], failedChecks: [{ name: 'Warehouse ETL tests', status: 'FAILURE' }] },
-    queue: { queued: true, position: 1 },
-    everActive: true,
-  })
-  assert.equal(verdict.terminal, false)
-  assert.equal(verdict.outcome, 'QUEUED')
-})
-
-test('status check summary ignores Mergify lifecycle checks and classifies terminal CI', () => {
-  const summary = summarizeStatusChecks([
-    { name: 'Warehouse ETL tests', status: 'COMPLETED', conclusion: 'FAILURE', detailsUrl: 'https://ci/warehouse' },
-    { name: 'Frontend tests', status: 'IN_PROGRESS', conclusion: null, detailsUrl: 'https://ci/frontend' },
-    { name: 'Mergify Merge Protections', status: 'COMPLETED', conclusion: 'FAILURE' },
-    { name: 'Mergify Merge Queue', status: 'COMPLETED', conclusion: 'NEUTRAL' },
-    { context: 'legacy-status', state: 'ERROR', targetUrl: 'https://ci/legacy' },
-  ])
-  assert.deepEqual(summary.failedChecks, [
-    { name: 'Warehouse ETL tests', status: 'FAILURE', detailsUrl: 'https://ci/warehouse' },
-    { name: 'legacy-status', status: 'ERROR', detailsUrl: 'https://ci/legacy' },
-  ])
-  assert.deepEqual(summary.pendingChecks, [
-    { name: 'Frontend tests', status: 'IN_PROGRESS', detailsUrl: 'https://ci/frontend' },
-  ])
-})
-
-test('live loop exits on a failed admission check in the first poll', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, {
-      state: 'OPEN', mergedAt: null, mergeCommit: null, headRefOid: 'head-1', labels: [], url: 'https://x', comments: [],
-      statusCheckRollup: [
-        { name: 'Warehouse ETL tests', status: 'COMPLETED', conclusion: 'FAILURE', detailsUrl: 'https://ci/warehouse' },
-      ],
-    })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '1', '--stall-minutes', '1', '--admission-stall-minutes', '1', '--max-minutes', '1',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.reason, 'admission-checks-failed')
-    assert.equal(payload.observations, 1)
-    assert.deepEqual(payload.phases, ['NOT_YET_QUEUED', 'STALLED'])
-    assert.equal(payload.pr.headRefOid, 'head-1')
-    assert.deepEqual(payload.failedChecks.map((check) => check.name), ['Warehouse ETL tests'])
-    assert.deepEqual(payload.pr.failedChecks.map((check) => check.name), ['Warehouse ETL tests'])
-  })
-})
-
-test('after observed entry, lost queue membership across rereads is DEQUEUED', () => {
-  const firstMissing = classifyObservation({ pr: { state: 'OPEN', labels: [] }, queue: { queued: false }, seenQueued: true, missingActiveReads: 1 })
-  assert.equal(firstMissing.terminal, false)
-  assert.equal(firstMissing.outcome, 'WAITING')
-
-  const settled = classifyObservation({ pr: { state: 'OPEN', labels: [] }, queue: { queued: false }, seenQueued: true, missingActiveReads: 2 })
-  assert.equal(settled.terminal, true)
-  assert.equal(settled.outcome, 'DEQUEUED')
-  assert.equal(settled.reason, 'lost-queue-membership')
-})
-
-test('merge wins over lost queue membership', () => {
-  const verdict = classifyObservation({ pr: { state: 'MERGED', mergeCommitOid: 'abc123', labels: [] }, queue: { queued: false }, seenQueued: true, missingActiveReads: 4 })
-  assert.equal(verdict.outcome, 'MERGED')
-})
-
-// ---- epic-824 #859: --seen-queued before admission must not false-DEQUEUE ----
-//
-// Orchestrators often launch `watch-pr-delivery --seen-queued` in the same turn as
-// `@mergifyio queue`, before Mergify has admitted the PR. The flag is a resume *hint*,
-// not proof this process observed membership. Before the everActive gate, two clean
-// "not in the merge queue" reads settled DEQUEUED/lost-queue-membership while the PR
-// was still pre-admission — and the real merge landed minutes later under a re-watch.
-
-test('epic-824: --seen-queued without everActive stays NOT_YET_QUEUED, never DEQUEUED', () => {
-  // Explicit everActive=false is what the poll loop passes until membership is seen.
-  const first = classifyObservation({
-    pr: { state: 'OPEN', labels: [] },
-    queue: { queued: false },
-    seenQueued: true,
-    everActive: false,
-    missingActiveReads: 1,
-  })
-  assert.equal(first.terminal, false)
-  assert.equal(first.outcome, 'NOT_YET_QUEUED')
-  assert.equal(first.seenQueued, true)
-  assert.equal(first.everActive, false)
-
-  const second = classifyObservation({
-    pr: { state: 'OPEN', labels: [] },
-    queue: { queued: false },
-    seenQueued: true,
-    everActive: false,
-    missingActiveReads: 2,
-  })
-  assert.equal(second.terminal, false, 'must not settle DEQUEUED before process-local membership')
-  assert.equal(second.outcome, 'NOT_YET_QUEUED')
-  assert.notEqual(second.reason, 'lost-queue-membership')
-})
-
-test('epic-824: nextMissingActiveReads does not advance when everActive is false', () => {
-  assert.equal(
-    nextMissingActiveReads({ active: false, everActive: false, seenQueued: true, missingActiveReads: 0, readable: true }),
-    0,
-    'seeded seenQueued alone must not start the absence counter',
-  )
-  assert.equal(
-    nextMissingActiveReads({ active: false, everActive: false, seenQueued: true, missingActiveReads: 5, readable: true }),
-    5,
-    'counter is carried unchanged, not advanced, while everActive is false',
-  )
-})
-
-test('epic-824: after everActive, two clean absences still settle DEQUEUED', () => {
-  const waiting = classifyObservation({
-    pr: { state: 'OPEN', labels: [] },
-    queue: { queued: false },
-    seenQueued: true,
-    everActive: true,
-    missingActiveReads: 1,
-  })
-  assert.equal(waiting.outcome, 'WAITING')
-
-  const settled = classifyObservation({
-    pr: { state: 'OPEN', labels: [] },
-    queue: { queued: false },
-    seenQueued: true,
-    everActive: true,
-    missingActiveReads: 2,
-  })
-  assert.equal(settled.terminal, true)
-  assert.equal(settled.outcome, 'DEQUEUED')
-  assert.equal(settled.reason, 'lost-queue-membership')
-})
-
-test('epic-824: nextMissingActiveReads advances only after everActive', () => {
-  assert.equal(
-    nextMissingActiveReads({ active: false, everActive: true, seenQueued: true, missingActiveReads: 0, readable: true }),
-    1,
-  )
-  assert.equal(
-    nextMissingActiveReads({ active: true, everActive: false, seenQueued: true, missingActiveReads: 3, readable: true }),
-    0,
-    'active membership resets the counter regardless of prior everActive',
-  )
-})
-
-test('legacy callers without everActive keep seenQueued lost-membership semantics', () => {
-  // everActive omitted (null default): seenQueued alone still counts, matching pre-fix unit tests.
-  const settled = classifyObservation({
-    pr: { state: 'OPEN', labels: [] },
-    queue: { queued: false },
-    seenQueued: true,
-    missingActiveReads: 2,
-  })
-  assert.equal(settled.outcome, 'DEQUEUED')
-  assert.equal(settled.reason, 'lost-queue-membership')
-})
-
-// ---- issue #611 defect 1: a transient read failure is not a dequeue signal ----
-//
-// `prObservation`/`queueObservation` set `readable: false` on a failed subprocess read, and
-// the resulting snapshot (`labels: []`, `queued: false`) is indistinguishable from a genuine
-// loss of queue membership unless the caller treats an unreadable poll as NO INFORMATION.
-// `nextMissingActiveReads` is the pure decision the poll loop uses to gate the counter.
-
-test('nextMissingActiveReads does not advance on an unreadable poll', () => {
-  assert.equal(
-    nextMissingActiveReads({ active: false, seenQueued: true, missingActiveReads: 0, readable: false }),
-    0,
-  )
-  assert.equal(
-    nextMissingActiveReads({ active: false, seenQueued: true, missingActiveReads: 1, readable: false }),
-    1,
-    'an unreadable poll carries the counter forward unchanged rather than resetting or advancing it',
-  )
-})
-
-test('nextMissingActiveReads advances only on a clean read that reports absence', () => {
-  assert.equal(nextMissingActiveReads({ active: false, seenQueued: true, missingActiveReads: 0, readable: true }), 1)
-  assert.equal(nextMissingActiveReads({ active: false, seenQueued: true, missingActiveReads: 1, readable: true }), 2)
-})
-
-test('nextMissingActiveReads resets to 0 the moment either source reports active', () => {
-  assert.equal(nextMissingActiveReads({ active: true, seenQueued: true, missingActiveReads: 2, readable: true }), 0)
-  assert.equal(nextMissingActiveReads({ active: true, seenQueued: true, missingActiveReads: 2, readable: false }), 0)
-})
-
-test('nextMissingActiveReads is inert before seenQueued', () => {
-  assert.equal(nextMissingActiveReads({ active: false, seenQueued: false, missingActiveReads: 0, readable: true }), 0)
-})
-
-test('regression #611: two consecutive unreadable polls after seenQueued never settle DEQUEUED', () => {
-  let seenQueued = true
-  let missingActiveReads = 0
-  for (let i = 0; i < 2; i += 1) {
-    const pr = { readable: false }
-    const queue = { readable: false }
-    missingActiveReads = nextMissingActiveReads({ active: false, seenQueued, missingActiveReads, readable: false })
-    const verdict = classifyObservation({ pr, queue, seenQueued, missingActiveReads })
-    assert.notEqual(verdict.outcome, 'DEQUEUED', `poll ${i + 1} must not be classified DEQUEUED on an unreadable read`)
-    seenQueued = verdict.seenQueued
-  }
-})
-
-test('one source failing to read does not block the other from counting a clean absence', () => {
-  // pr read failed, but the queue read succeeded and reported not-queued — that IS information.
-  const missing = nextMissingActiveReads({ active: false, seenQueued: true, missingActiveReads: 0, readable: true })
-  assert.equal(missing, 1)
-})
-
-test('BLOCK-1 regression (review #612): the live loop never settles DEQUEUED on two consecutive unreadable gh+mergify reads', async () => {
-  // Reproduces the independent review's exact repro: both `gh` and `mergify` failing
-  // (exit 1, no stdout) after `--seen-queued`. Before this fix, `queueObservation` parsed
-  // the failed mergify call's empty stdout as `{}` (truthy) and reported `readable: true`
-  // regardless of the failure — the one place in this file that still treated an unreadable
-  // read as informative, defeating `nextMissingActiveReads` entirely.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'exit 1')
-    makeFakeBin(dir, 'mergify', 'exit 1')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1', '--seen-queued',
-      '--interval-seconds', '0.1', '--stall-minutes', '0.02', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.notEqual(payload.outcome, 'DEQUEUED', `must not falsely dequeue on unreadable reads: ${JSON.stringify(payload)}`)
-    assert.notEqual(payload.reason, 'lost-queue-membership', `must not settle via the missing-active-reads counter: ${JSON.stringify(payload)}`)
-    assert.equal(payload.missingActiveReads, 0, 'an unreadable read must never advance the counter')
-    assert.equal(payload.pr.readable, false)
-    assert.equal(payload.queue.readable, false, 'BLOCK-1: a failed mergify read must report readable:false, not the empty-stdout-parses-truthy false positive')
-    assert.equal(payload.reason, 'unreadable', 'the terminal stall must be attributed to unreadable reads, not a generic stall-bound')
-  })
-})
-
-test('a merge hidden by a failed PR read is not a dequeue (ai #1762)', async () => {
-  // ai #1762 (2026-10-17): the PR merged while `gh pr view` was rate limited. Mergify read
-  // "not in the merge queue" twice, which counted as two readable absences, and the watch
-  // reported DEQUEUED for a merged PR. Only the PR read can show a merge, so an absence
-  // counts only when that read succeeded.
-  await withFakeBinsOnPath(async (dir) => {
-    const ghCount = join(dir, 'gh-count')
-    const queueCount = join(dir, 'queue-count')
-    makeFakeBin(dir, 'gh', [
-      `count=$(cat '${ghCount}' 2>/dev/null || echo 0)`,
-      'count=$((count + 1))',
-      `echo "$count" > '${ghCount}'`,
-      '[ "$count" -eq 1 ] && { echo \'{"state":"OPEN","mergedAt":null,"mergeCommit":null,"headRefOid":"h","labels":["queued"],"url":"https://x","comments":[]}\'; exit 0; }',
-      '[ "$count" -le 4 ] && { echo "GraphQL: API rate limit already exceeded" >&2; exit 1; }',
-      'echo \'{"state":"MERGED","mergedAt":"2026-10-17T04:20:34Z","mergeCommit":{"oid":"ee212fdc"},"headRefOid":"h","labels":[],"url":"https://x","comments":[]}\'',
-    ].join('\n'))
-    makeFakeBin(dir, 'mergify', [
-      `count=$(cat '${queueCount}' 2>/dev/null || echo 0)`,
-      'count=$((count + 1))',
-      `echo "$count" > '${queueCount}'`,
-      '[ "$count" -eq 1 ] && { echo \'{"queued":true,"status":"checking"}\'; exit 0; }',
-      'echo "PR #1 is not in the merge queue"; exit 1',
-    ].join('\n'))
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1', '--quiet',
-      '--interval-seconds', '0.02', '--stall-minutes', '1', '--max-minutes', '1',
-    ])
-    assert.equal(payload.outcome, 'MERGED', JSON.stringify(payload))
-    assert.equal(code, 0)
-    assert.equal(payload.mergedSha, 'ee212fdc')
-  })
-})
-
-test('BLOCK-2/3 regression (review #612): the live loop actually wires the per-read timeout at both call sites, not just run() in isolation', async () => {
-  // Both fake binaries hang well past the clamped per-read timeout (`--stall-minutes 0.02`
-  // clamps the read timeout to ~1.2s here, far under the 8s hang). If the timeout option
-  // were stripped from either `prObservation`'s or `queueObservation`'s `run()` call, this
-  // test would take at least 8s per hung read instead of finishing in ~1-2s.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'sleep 8\nexit 1')
-    makeFakeBin(dir, 'mergify', 'sleep 8\nexit 1')
-    const startedMs = Date.now()
-    const { code } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1', '--seen-queued',
-      '--interval-seconds', '0.1', '--stall-minutes', '0.02', '--max-minutes', '0.05',
-    ])
-    const elapsedMs = Date.now() - startedMs
-    assert.equal(code, 4)
-    assert.ok(elapsedMs < 6000, `expected the clamped per-read timeout to bound both hung reads well under the 8s+8s an unwired call would take, got ${elapsedMs}ms`)
-  })
-})
-
-test('observation key changes on queue position and ignores label order', () => {
-  const a = observationKey({ pr: { state: 'OPEN', labels: ['queued', 'urgent'] }, queue: { queued: true, queueState: 'pending', position: 3 } })
-  const same = observationKey({ pr: { state: 'OPEN', labels: ['urgent', 'queued'] }, queue: { queued: true, queueState: 'pending', position: 3 } })
-  const moved = observationKey({ pr: { state: 'OPEN', labels: ['queued', 'urgent'] }, queue: { queued: true, queueState: 'pending', position: 2 } })
-  assert.equal(a, same)
-  assert.notEqual(a, moved)
-})
-
-test('observation key changes when HEAD or admission checks change', () => {
-  const base = observationKey({
-    pr: { state: 'OPEN', headRefOid: 'aaa', failedChecks: [], pendingChecks: [{ name: 'CI', status: 'IN_PROGRESS' }] },
-    queue: { queued: false },
-  })
-  const completed = observationKey({
-    pr: { state: 'OPEN', headRefOid: 'aaa', failedChecks: [{ name: 'CI', status: 'FAILURE' }], pendingChecks: [] },
-    queue: { queued: false },
-  })
-  const newHead = observationKey({
-    pr: { state: 'OPEN', headRefOid: 'bbb', failedChecks: [], pendingChecks: [{ name: 'CI', status: 'IN_PROGRESS' }] },
-    queue: { queued: false },
-  })
-  assert.notEqual(base, completed)
-  assert.notEqual(base, newHead)
-})
-
-const STALL_BASE_PR = {
-  readable: true,
-  state: 'OPEN',
-  headRefOid: 'head-1',
-  labels: [],
-  failedChecks: [],
-  pendingChecks: [{ name: 'CI', status: 'IN_PROGRESS' }],
-}
-const STALL_BASE_QUEUE = { readable: true, queued: true, queueState: 'checking', position: 3 }
-
-function advanceStall(cache, pr, queue) {
-  return nextStallObservation({ cache, pr, queue })
-}
-
-test('stall observation retains both sources across a fully unreadable poll and recovery', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  assert.equal(baseline.changed, true)
-
-  const unreadable = advanceStall(baseline.cache, { readable: false }, { readable: false })
-  assert.equal(unreadable.changed, false)
-  assert.equal(unreadable.key, baseline.key)
-
-  const recovered = advanceStall(unreadable.cache, STALL_BASE_PR, STALL_BASE_QUEUE)
-  assert.equal(recovered.changed, false)
-  assert.equal(recovered.key, baseline.key)
-})
-
-test('stall observation retains the PR contribution when PR is unreadable and queue is stable', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const partial = advanceStall(baseline.cache, { readable: false }, STALL_BASE_QUEUE)
-  const recovered = advanceStall(partial.cache, STALL_BASE_PR, STALL_BASE_QUEUE)
-
-  assert.equal(partial.changed, false)
-  assert.equal(partial.key, baseline.key)
-  assert.equal(recovered.changed, false)
-})
-
-test('stall observation retains the queue contribution when queue is unreadable and PR is stable', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const partial = advanceStall(baseline.cache, STALL_BASE_PR, { readable: false })
-  const recovered = advanceStall(partial.cache, STALL_BASE_PR, STALL_BASE_QUEUE)
-
-  assert.equal(partial.changed, false)
-  assert.equal(partial.key, baseline.key)
-  assert.equal(recovered.changed, false)
-})
-
-test('stall observation retains a genuine PR change made while queue is unreadable', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const changedPr = { ...STALL_BASE_PR, headRefOid: 'head-2' }
-  const changed = advanceStall(baseline.cache, changedPr, { readable: false })
-  const recovered = advanceStall(changed.cache, changedPr, STALL_BASE_QUEUE)
-
-  assert.equal(changed.changed, true)
-  assert.equal(changed.cache.pr.headRefOid, 'head-2')
-  assert.equal(recovered.changed, false)
-  assert.equal(recovered.key, changed.key)
-})
-
-test('stall observation retains a genuine queue change made while PR is unreadable', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const changedQueue = { ...STALL_BASE_QUEUE, position: 2 }
-  const changed = advanceStall(baseline.cache, { readable: false }, changedQueue)
-  const recovered = advanceStall(changed.cache, STALL_BASE_PR, changedQueue)
-
-  assert.equal(changed.changed, true)
-  assert.equal(changed.cache.queue.position, 2)
-  assert.equal(recovered.changed, false)
-  assert.equal(recovered.key, changed.key)
-})
-
-test('stall observation still detects later fully readable changes', () => {
-  const baseline = advanceStall(null, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const partial = advanceStall(baseline.cache, STALL_BASE_PR, { readable: false })
-  const recovered = advanceStall(partial.cache, STALL_BASE_PR, STALL_BASE_QUEUE)
-  const laterChange = advanceStall(
-    recovered.cache,
-    { ...STALL_BASE_PR, pendingChecks: [] },
-    { ...STALL_BASE_QUEUE, queueState: 'ready', position: 1 },
-  )
-
-  assert.equal(laterChange.changed, true)
-  assert.notEqual(laterChange.key, recovered.key)
-})
-
-test('stall verdict is based on last observable change', () => {
-  const now = 1000 * 60 * 60
-  assert.equal(stallVerdict({ lastChangeMs: now - 5 * 60_000, nowMs: now, stallMinutes: 30 }).stalled, false)
-  assert.equal(stallVerdict({ lastChangeMs: now - 31 * 60_000, nowMs: now, stallMinutes: 30 }).stalled, true)
-})
-
-test('invalid stall bound does not instantly stall', () => {
-  for (const stallMinutes of [0, -1, NaN, 'soon', undefined]) {
-    assert.equal(stallVerdict({ lastChangeMs: 0, nowMs: 999999, stallMinutes }).stalled, false, String(stallMinutes))
-  }
-})
-
-test('pre-admission with a pending CI check uses the full bound: waiting on CI is not a dead admission path', () => {
-  // 2026-10-16: fmm-express #1816, identity #1378 and kyc #283 were enqueued, their required CI
-  // waited on busy runners, and each watch ended admission-stall after 3 minutes.
-  assert.deepEqual(effectiveStallMinutes({ everActive: false, stallMinutes: 45, admissionStallMinutes: 3, ciPending: true }), { minutes: 45, phase: 'admission-ci' })
-  assert.deepEqual(effectiveStallMinutes({ everActive: false, stallMinutes: 45, admissionStallMinutes: 3, ciPending: false }), { minutes: 3, phase: 'admission' })
-  assert.deepEqual(effectiveStallMinutes({ everActive: true, stallMinutes: 45, admissionStallMinutes: 3, ciPending: true }), { minutes: 45, phase: 'queued' })
-})
-
-test('effectiveStallMinutes is phase-aware: shorter pre-admission, full post-entry', () => {
-  assert.deepEqual(
-    effectiveStallMinutes({ everActive: false, stallMinutes: 10, admissionStallMinutes: 3 }),
-    { minutes: 3, phase: 'admission' },
-  )
-  assert.deepEqual(
-    effectiveStallMinutes({ everActive: true, stallMinutes: 10, admissionStallMinutes: 3 }),
-    { minutes: 10, phase: 'queued' },
-  )
-  // A short --stall-minutes keeps both phases tight; admission never exceeds post-entry.
-  assert.deepEqual(
-    effectiveStallMinutes({ everActive: false, stallMinutes: 0.02, admissionStallMinutes: 3 }),
-    { minutes: 0.02, phase: 'admission' },
-  )
-  assert.deepEqual(
-    effectiveStallMinutes({ everActive: true, stallMinutes: 0.02, admissionStallMinutes: 3 }),
-    { minutes: 0.02, phase: 'queued' },
-  )
-})
-
-test('readTimeoutForArgs tracks the phase stall bound, not a permanent min of both', () => {
-  // Pre-admission: clamp to admission (3m) so a hung poll cannot outlive admission-stall.
-  // Post-entry: clamp to the full stall (10m) — permanently min(admission, stall) would leave
-  // every post-entry poll clamped to 3m forever, which is not the phase-aware design.
-  const pre = readTimeoutForArgs({
-    intervalSeconds: 90,
-    stallMinutes: 10,
-    admissionStallMinutes: 3,
-    maxMinutes: 60,
-    everActive: false,
-  })
-  const post = readTimeoutForArgs({
-    intervalSeconds: 90,
-    stallMinutes: 10,
-    admissionStallMinutes: 3,
-    maxMinutes: 60,
-    everActive: true,
-  })
-  assert.equal(pre, readTimeoutMs(90, 3, 2))
-  assert.equal(post, readTimeoutMs(90, 10, 2))
-  assert.ok(post > pre, 'post-entry reads must be allowed the longer phase bound')
-})
-
-// ---- issue #611 defect 2: a hung child must not outlive the poll bounds ----
-
-test('readTimeoutMs scales with the poll interval and floors at 10s', () => {
-  assert.equal(readTimeoutMs(30), 60_000)
-  assert.equal(readTimeoutMs(2), 10_000, 'a tiny interval still gets a sane floor, not a near-instant timeout')
-  assert.equal(readTimeoutMs(undefined), readTimeoutMs(DEFAULT_INTERVAL_SECONDS), 'a missing interval falls back to the documented default')
-})
-
-test('readTimeoutMs clamps to boundMinutes so a single read cannot outlive the stall/ceiling bound it sits inside of', () => {
-  assert.equal(readTimeoutMs(30, 0.01), 600, 'a 0.01-minute (600ms) bound wins over the usual 60s computed timeout')
-  assert.equal(readTimeoutMs(2, 1), 10_000, 'a generous bound (60s) never shrinks a timeout that is already under it')
-  assert.equal(readTimeoutMs(30, 0), 60_000, 'a non-positive bound is ignored, not treated as an instant timeout')
-  assert.equal(readTimeoutMs(30, -5), 60_000)
-  assert.equal(readTimeoutMs(30, NaN), 60_000)
-})
-
-// ---- issue #615 item 1: the clamp must divide by reads-per-poll, not clamp to the whole bound ----
-//
-// #612's clamp bounded a single read's timeout to `min(--stall-minutes, --max-minutes)`, but
-// this watcher makes TWO reads per poll (`gh pr view` + `mergify queue show`) and the bounds
-// are only evaluated after a poll returns — so a single poll could still take up to
-// `2 x bound` before the loop ever noticed, which the round-2 reviewer measured live as 58s
-// against a 12s stall bound (4.8x overrun). Dividing the per-read clamp by the reads-per-poll
-// count keeps a poll's reads, summed, inside the bound.
-
-test('readTimeoutMs divides the clamp by readsPerPoll, so N reads together cannot outlive the bound', () => {
-  assert.equal(readTimeoutMs(30, 1, 2), 30_000, 'a 1-minute bound with 2 reads per poll clamps each read to half the bound')
-  assert.equal(readTimeoutMs(30, 1), 60_000, 'omitting readsPerPoll keeps the pre-existing single-read behaviour (divide by 1)')
-  assert.equal(readTimeoutMs(2, 1, 4), 10_000, 'the 10s floor still wins over an even smaller divided clamp')
-  assert.equal(readTimeoutMs(30, 0, 2), 60_000, 'a non-positive bound is still ignored regardless of readsPerPoll')
-  assert.equal(readTimeoutMs(30, 1, 0), 60_000, 'a non-positive readsPerPoll falls back to 1 rather than dividing by zero')
-})
-
-test('regression (issue #615 item 1): a hung read must not consume the whole stall bound when two reads happen per poll', async () => {
-  // Mirrors the round-2 reviewer's live repro (58s against a 12s stall bound), scaled down to
-  // finish quickly. Both `gh` and `mergify` hang well past either candidate per-read clamp
-  // (600ms fixed vs 1200ms unfixed), so the timeout always cuts them off — the assertion is
-  // on the RESULTING WALL-CLOCK TIME to reach STALLED, not on which code path was taken.
-  // With the item-1 fix, each read is clamped to half the 1200ms stall bound (~600ms), so two
-  // polls' worth of hung reads settle STALLED in a measured, stable ~2.52s across repeat runs.
-  // Reverting the `/ readsPerPoll` division (or the `READS_PER_POLL` wiring at the call site)
-  // clamps each read to the whole 1200ms bound instead, measured equally stable at ~4.92s —
-  // confirmed by running both variants 3x each before picking the threshold below, so it sits
-  // with real margin on both sides rather than a loose bound that passes either way.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'sleep 8\nexit 1')
-    makeFakeBin(dir, 'mergify', 'sleep 8\nexit 1')
-    const startedMs = Date.now()
-    const { code } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.1', '--stall-minutes', '0.02', '--max-minutes', '1',
-    ])
-    const elapsedMs = Date.now() - startedMs
-    assert.equal(code, 4)
-    assert.ok(
-      elapsedMs < 3800,
-      `expected two hung-read polls to settle STALLED in ~2.5s (measured stable, fixed); reverting the readsPerPoll division measures ~4.9s (also stable) — well over this threshold, got ${elapsedMs}ms`,
-    )
-  })
-})
-
-test('regression (issue #615 item 2): a clean, unchanging read settles STALLED with reason stall-bound, not just unreadable', () => {
-  // Round-2 NOTE-4: the `readable ? 'stall-bound' : 'unreadable'` branch at the STALLED site
-  // had only its `unreadable` side exercised. This drives the loop with reads that succeed
-  // every poll and report a stable (never-queued) snapshot, so the watcher stalls on a clean
-  // read rather than an unreadable one.
-  return withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'echo \'{"state":"OPEN","mergedAt":null,"mergeCommit":null,"labels":[],"url":"https://x"}\'')
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    // Bounds are deliberately not the smallest that would work. `readTimeoutMs` clamps each
-    // read to `min(--stall-minutes, --max-minutes) / READS_PER_POLL`, so on this watcher the
-    // per-read timeout is exactly **half the stall bound** — the two are the same number, and a
-    // "fast" bound silently buys a fragile test. At the original `--stall-minutes 0.01` each
-    // read got 300ms, which is under the spawn jitter of `sh` + `echo` when `node --test` is
-    // running ~77 files in parallel: the fake `gh` was killed, `readable` flipped false, and
-    // both assertions below failed. Measured 2 of 6 full-gate runs red (#630).
-    //
-    // 0.05min gives each read 1500ms — 5x the headroom — for 3s of runtime, and the interval is
-    // 10x longer so the loop spawns ~12 children instead of ~120, which is itself less to
-    // schedule. If you tighten these, work out the derived timeout first: it is bound/2 here,
-    // bound/1 on the sibling watcher.
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--max-minutes', '0.5',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.pr.readable, true)
-    assert.equal(payload.queue.readable, true)
-    assert.equal(payload.reason, 'admission-stall', 'a stable, readable never-admitted snapshot must settle as admission-stall, not unreadable or post-entry stall-bound')
-  })
-})
-
-test('an admitted then frozen watch settles STALLED with reason stall-bound, not admission-stall', async () => {
-  // Phase-aware bound: once everActive, the post-entry --stall-minutes applies and the reason
-  // must not be the pre-admission class — callers can distinguish dead admission from a wedged
-  // queue without reconstructing phases alone.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'echo \'{"state":"OPEN","mergedAt":null,"mergeCommit":null,"labels":[{"name":"queued"}],"url":"https://x","comments":[]}\'')
-    makeFakeBin(dir, 'mergify', 'echo \'{"queue_rule_name":"default","position":1,"status":"waiting_for_batch"}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.5', '--stall-minutes', '0.05', '--admission-stall-minutes', '0.05', '--max-minutes', '0.5',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.everActive, true)
-    assert.equal(payload.reason, 'stall-bound', 'post-entry freeze must report stall-bound, not admission-stall')
-    assert.ok(payload.phases.includes('QUEUED'), `phases must record admission: ${JSON.stringify(payload.phases)}`)
-  })
-})
-
-test('pre-admission watch uses the short admission bound, not the full post-entry stall', async () => {
-  // With admission=0.05m and stall=5m, a never-admitted PR must hand back on the short bound
-  // (seconds), not burn the 5-minute post-entry clock. Wall time is the signal that the phase
-  // switch is live in the loop, not only in the pure helper.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'echo \'{"state":"OPEN","mergedAt":null,"mergeCommit":null,"labels":[],"url":"https://x","comments":[]}\'')
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const startedMs = Date.now()
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.2',
-      '--stall-minutes', '5',
-      '--admission-stall-minutes', '0.05',
-      '--max-minutes', '5',
-    ])
-    const elapsedMs = Date.now() - startedMs
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.reason, 'admission-stall')
-    assert.deepEqual(payload.phases, ['NOT_YET_QUEUED', 'STALLED'])
-    assert.ok(
-      elapsedMs < 15_000,
-      `dead admission must hand back on the short bound (~3s), not the 5m post-entry stall; got ${elapsedMs}ms`,
-    )
-  })
-})
-
-test('regression (issue #615 items 3-4): gh exiting 0 with empty stdout is not manufactured into a readable observation', async () => {
-  // Round-2 NOTE-1: `prObservation` called the bare `parseJson(result.stdout)`, and
-  // `parseJson` was `JSON.parse(text || '{}')` — an empty string parsed to a truthy `{}`,
-  // manufacturing a `readable: true` observation from a `gh` that printed nothing. Unreachable
-  // via any current caller (a failed/timed-out `gh` is already caught by `if (!result.ok)`
-  // one line earlier), but the same invariant class BLOCK-1 closed for `queueObservation`.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeBin(dir, 'gh', 'exit 0')
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'\nexit 0')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.02', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.pr.readable, false, 'gh exiting 0 with empty stdout must not be treated as a readable, empty-but-valid observation')
-  })
-})
-
-test('run() bounds a hung child on the timeout instead of blocking forever', () => {
-  const startedMs = Date.now()
-  const result = run('sleep', ['5'], { timeout: 200 })
-  const elapsedMs = Date.now() - startedMs
-  assert.equal(result.ok, false)
-  assert.ok(elapsedMs < 4000, `expected the timeout to cut the 5s sleep short, took ${elapsedMs}ms`)
-})
-
-test('Mergify queue query is scoped to the requested repository', () => {
-  assert.deepEqual(
-    mergifyQueueShowArgs({ repo: '1aboveio/skyee-ai-risk', pr: 1302 }),
-    ['queue', '--repository', '1aboveio/skyee-ai-risk', 'show', '1302', '--json'],
-  )
-})
-
-test('CLI help documents the dequeue contract and exits 0', async () => {
-  const lines = []
-  const original = console.log
-  console.log = (value) => lines.push(String(value))
-  try {
-    assert.equal(await runCli(['--help']), 0)
-  } finally {
-    console.log = original
-  }
-  const help = lines.join('\n')
-  assert.match(help, /DEQUEUED/)
-  assert.match(help, /queued:false is a queue exit/)
-  assert.match(help, /ancestry proof/)
-})
-
-test('CLI validates required arguments and numeric bounds', async () => {
-  assert.equal(await runCli(['--repo', 'owner/repo']), 2)
-  assert.equal(await runCli(['--pr', '1']), 2)
-  // A URL, `#n`, or a full repo URL is refused before any read, not watched into STALLED.
-  for (const pr of ['https://github.com/owner/repo/pull/1', '#1', '1a']) assert.equal(await runCli(['--repo', 'owner/repo', '--pr', pr]), 2)
-  assert.equal(await runCli(['--repo', 'https://github.com/owner/repo', '--pr', '1']), 2)
-  assert.equal(await runCli(['--repo', 'owner/repo', '--pr', '1', '--interval-seconds', '0']), 2)
-  assert.equal(await runCli(['--repo', 'owner/repo', '--pr', '1', '--stall-minutes', '-1']), 2)
-  assert.equal(await runCli(['--repo', 'owner/repo', '--pr', '1', '--admission-stall-minutes', '0']), 2)
-  assert.equal(await runCli(['--repo', 'owner/repo', '--pr', '1', '--max-minutes', 'later']), 2)
-})
-
-// ---- the silent-watcher defect: a non-terminal watch must not write zero bytes ----
-//
-// Reproduced live on PR #1396 (1aboveio/skyee-ai-risk): the loop's only output sites were the
-// terminal verdicts, so a 25-minute watch of a never-queued PR produced a log containing
-// nothing but the supervisor's own spawn banner. The caller cannot tell that from a hung or
-// dead process — and the process was in fact working correctly the whole time. These tests pin
-// the heartbeat at the LOOP level, because the defect was never in a helper: `progressRecord`
-// could be perfect and unused and the watcher would still be mute.
-
-test('every non-terminal poll emits progress on stderr and one terminal verdict on stdout', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    // NOT_YET_QUEUED forever — the exact #1396 shape: open, unlabelled, never in the queue.
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload, stdoutLines, progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.ok(progressLines.length >= 1, 'a watch that polls at all must say so at least once, not run mute to its stall bound')
-
-    const first = JSON.parse(progressLines[0])
-    assert.equal(first.progress, true, 'heartbeats must be distinguishable from the terminal verdict')
-    assert.equal(first.terminal, false)
-    assert.equal(first.outcome, 'NOT_YET_QUEUED', 'the heartbeat must carry the live state, not just a liveness ping')
-    assert.equal(first.queue.queued, false)
-    assert.equal(typeof first.sinceChangeMs, 'number', 'how long the picture has been frozen is the stall bound made visible')
-    assert.match(first.at, /^\d{4}-\d{2}-\d{2}T/)
-    assert.ok(!progressLines[0].includes('\n'), 'heartbeats are one NDJSON record per line, not pretty-printed')
-
-    // stdout is the machine contract: callers `JSON.parse` it whole. Interleaving heartbeats
-    // there would break every one of them, so the stream split is load-bearing, not cosmetic.
-    assert.equal(stdoutLines.length, 1, `stdout must carry exactly the terminal verdict: ${JSON.stringify(stdoutLines)}`)
-    assert.doesNotThrow(() => JSON.parse(stdoutLines[0]), 'stdout must remain parseable as one whole JSON document')
-  })
-})
-
-test('--quiet suppresses the heartbeat but never the terminal verdict', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload, progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1', '--quiet',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    const records = progressLines.map((line) => JSON.parse(line))
-    assert.equal(records.filter((record) => record.progress).length, 0, 'no heartbeat under --quiet')
-    assert.deepEqual(records.map((record) => Object.keys(record)[0]), ['ciProfileSummary'], 'only the closing profile line')
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED', 'opting out of progress must not opt out of the answer')
-  })
-})
-
-test('a queued PR heartbeats its queue position, so a healthy slow queue is visibly alive', async () => {
-  // The other half of #1396: after the enqueue landed, the PR sat legitimately QUEUED at
-  // position 0 for minutes. QUEUED is non-terminal, so that healthy progress was just as
-  // invisible as the unqueued case.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'queued' }], url: 'https://x', comments: [] })
-    // The real `mergify queue show --json` shape for a QUEUED PR carries no `queued` field at
-    // all — membership is inferred from `queue_rule_name`. Verified live against PR #1396.
-    makeFakeBin(dir, 'mergify', 'echo \'{"number":1,"position":0,"queue_rule_name":"main","queued_at":"2026-07-29T06:18:48Z"}\'')
-    const { progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    const first = JSON.parse(progressLines[0])
-    assert.equal(first.outcome, 'QUEUED')
-    assert.equal(first.queue.queued, true, 'a payload with queue_rule_name but no `queued` field is still queue membership')
-    assert.equal(first.queue.position, 0)
-    assert.equal(first.seenQueued, true)
-  })
-})
-
-test('the heartbeat reports whether the picture changed since the last poll', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.01', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    const records = progressLines.map((line) => JSON.parse(line)).filter((record) => record.progress === true)
-    assert.ok(records.length >= 2, 'need at least two polls to compare')
-    assert.equal(records[0].changed, true, 'the first observation is a change from nothing')
-    assert.equal(records[records.length - 1].changed, false, 'an unchanging queue picture must report itself as unchanged')
-    assert.ok(
-      records[records.length - 1].sinceChangeMs >= records[1].sinceChangeMs,
-      'sinceChangeMs is the stall clock, so it must climb while nothing moves',
-    )
-  })
-})
-
-test('the live stall clock survives an unreadable poll and readable recovery', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    const ghCount = join(dir, 'gh-count')
-    const queueCount = join(dir, 'queue-count')
-    makeFakeBin(dir, 'gh', [
-      `count=$(cat '${ghCount}' 2>/dev/null || echo 0)`,
-      'count=$((count + 1))',
-      `echo "$count" > '${ghCount}'`,
-      '[ "$count" -eq 2 ] && exit 1',
-      'echo \'{"state":"OPEN","mergedAt":null,"mergeCommit":null,"headRefOid":"head-1","labels":[],"url":"https://x","comments":[]}\'',
-    ].join('\n'))
-    makeFakeBin(dir, 'mergify', [
-      `count=$(cat '${queueCount}' 2>/dev/null || echo 0)`,
-      'count=$((count + 1))',
-      `echo "$count" > '${queueCount}'`,
-      '[ "$count" -eq 2 ] && exit 1',
-      'echo \'{"queued":false,"status":"not-queued"}\'',
-    ].join('\n'))
-
-    const { progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.02', '--stall-minutes', '0.02', '--max-minutes', '0.04',
-    ])
-    assert.ok(progressLines.length >= 3, 'need baseline, unreadable, and recovered polls')
-    const records = progressLines.slice(0, 3).map((line) => JSON.parse(line))
-    assert.deepEqual(records.map(({ changed }) => changed), [true, false, false])
-    assert.equal(records[1].pr.readable, false)
-    assert.equal(records[1].queue.readable, false)
-    assert.ok(
-      records[2].sinceChangeMs >= records[1].sinceChangeMs,
-      'recovery to the retained baseline must not restart lastChangeMs',
-    )
-  })
-})
-
-test('progressRecord marks the record and preserves the observation payload', () => {
-  const payload = { outcome: 'QUEUED', terminal: false, queue: { queued: true, position: 2 } }
-  const record = JSON.parse(progressRecord({ payload, changed: false, sinceChangeMs: 4_000, nowIso: '2026-07-29T06:20:00.000Z' }))
-  assert.equal(record.progress, true)
-  assert.equal(record.changed, false)
-  assert.equal(record.sinceChangeMs, 4_000)
-  assert.equal(record.at, '2026-07-29T06:20:00.000Z')
-  assert.equal(record.outcome, 'QUEUED', 'the observation itself must survive intact')
-  assert.deepEqual(record.queue, { queued: true, position: 2 })
-})
-
-// ---- defaults ----
-
-test('watch defaults are a 90s poll, a 3-minute admission stall, a 45-minute post-entry stall, and a 1-hour ceiling', () => {
-  const args = parseArgs(['--repo', 'o/r', '--pr', '1'])
-  assert.equal(args.intervalSeconds, 90)
-  assert.equal(args.admissionStallMinutes, DEFAULT_ADMISSION_STALL_MINUTES)
-  assert.equal(args.admissionStallMinutes, 3)
-  assert.equal(args.stallMinutes, 45)
-  assert.equal(args.maxMinutes, 60)
-  assert.equal(args.quiet, undefined, 'progress is on by default — silence must be opted into, not out of')
-})
-
-test('the default poll interval keeps both of a poll\'s reads inside the shortest default stall bound', () => {
-  // The bounds are only evaluated after a poll RETURNS, so two hung reads must not be able to
-  // outlive the stall bound they sit inside of — the #615 item 1 guarantee, re-pinned against
-  // the phase-aware defaults (admission is the shortest and clamps the per-read timeout).
-  const shortest = Math.min(DEFAULT_ADMISSION_STALL_MINUTES, DEFAULT_STALL_MINUTES, DEFAULT_MAX_MINUTES)
-  const perRead = readTimeoutMs(DEFAULT_INTERVAL_SECONDS, shortest, 2)
-  assert.ok(perRead * 2 <= shortest * 60_000, `two reads (${perRead * 2}ms) must fit inside the ${shortest}m shortest stall bound`)
-})
-
-test('CLI help documents the heartbeat, the new defaults, and the enqueue-first precondition', async () => {
-  const lines = []
-  const original = console.log
-  console.log = (value) => lines.push(String(value))
-  try {
-    assert.equal(await runCli(['--help']), 0)
-  } finally {
-    console.log = original
-  }
-  const help = lines.join('\n')
-  assert.match(help, /--quiet/)
-  assert.match(help, /stderr/)
-  assert.match(help, /default 90/)
-  assert.match(help, /default 45/)
-  assert.match(help, /default 3/, 'pre-admission stall default must be documented')
-  assert.match(help, /--admission-stall-minutes/)
-  assert.match(help, /admission-stall/)
-  assert.match(help, /While a check is pending, the\s+post-entry bound applies/, 'help says CI-gated admission needs no relaunch')
-  assert.doesNotMatch(help, /relaunch/, 'no manual relaunch advice: the watcher handles CI-gated admission itself')
-  assert.match(help, /Enqueue first/, 'the watch cannot enqueue, and a watch on an unqueued manual-delivery PR can only end STALLED')
-})
-
-// ---- progression, not a single state poke (pi session 019fae8f) ----
-//
-// The incident these pin: an agent asked to "watch #1407" handed a background-task runner a
-// one-shot shell predicate — `state ∈ {MERGED, CLOSED}` — re-evaluated from scratch each tick.
-// That shape cannot see a dequeue at all (a dequeued PR is plain `OPEN`), and its successors
-// settled terminal on a SINGLE absent read while defaulting a failed `mergify` invocation to
-// `{"queued":false}`. It reported a mid-`checking` PR as DEQUEUED.
-//
-// `phases` is the progression made a first-class output, so "did this watch actually observe a
-// lifecycle, or just poke one state?" is answerable from the verdict rather than inferred.
-
-test('nextPhases records a transition once, and repeats collapse', () => {
-  let phases = []
-  phases = nextPhases(phases, 'NOT_YET_QUEUED')
-  phases = nextPhases(phases, 'NOT_YET_QUEUED')
-  phases = nextPhases(phases, 'QUEUED')
-  phases = nextPhases(phases, 'QUEUED')
-  phases = nextPhases(phases, 'MERGED')
-  assert.deepEqual(phases, ['NOT_YET_QUEUED', 'QUEUED', 'MERGED'])
-})
-
-test('nextPhases ignores WAITING, so a re-read suspicion never oscillates the progression', () => {
-  // WAITING is the missing-membership re-read state INSIDE queued (classifyObservation's
-  // `queue-membership-missing-reread`). Recording it would turn a healthy queued PR into
-  // QUEUED/WAITING/QUEUED/WAITING noise and destroy the signal this list exists for.
-  let phases = nextPhases([], 'QUEUED')
-  phases = nextPhases(phases, 'WAITING')
-  phases = nextPhases(phases, 'QUEUED')
-  assert.deepEqual(phases, ['QUEUED'])
-})
-
-test('nextPhases ignores unknown outcomes and tolerates a non-array', () => {
-  assert.deepEqual(nextPhases(['QUEUED'], 'SOMETHING_NEW'), ['QUEUED'])
-  assert.deepEqual(nextPhases(undefined, 'QUEUED'), ['QUEUED'])
-  assert.deepEqual(nextPhases(null, 'QUEUED'), ['QUEUED'])
-})
-
-test('a never-admitted watch is distinguishable from an admitted-then-wedged one by phases alone', async () => {
-  // Both end STALLED with the same exit code. Only the progression separates "nobody enqueued
-  // it" (fix: enqueue) from "it entered the queue and wedged" (fix: read the blocking
-  // condition) — the two diagnoses the pi session conflated.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    // max-minutes must sit above the stall bound: the loop checks the absolute ceiling first, so
-    // equal bounds always report max-minutes and hide the phase-aware reason this test pins.
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--admission-stall-minutes', '0.05', '--max-minutes', '0.5',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.reason, 'admission-stall', 'never-admitted freeze is the short admission phase, not post-entry stall-bound')
-    assert.deepEqual(payload.phases, ['NOT_YET_QUEUED', 'STALLED'], 'never admitted: the queue never saw this PR')
-    assert.equal(payload.seenQueued, false)
-  })
-})
-
-test('an admitted-then-stalled watch carries the queue entry in its phases', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [{ name: 'queued' }], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"number":1,"position":0,"queue_rule_name":"main"}\'')
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--admission-stall-minutes', '0.05', '--max-minutes', '0.5',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'STALLED')
-    assert.equal(payload.reason, 'stall-bound', 'post-entry freeze is stall-bound, not admission-stall')
-    assert.deepEqual(payload.phases, ['QUEUED', 'STALLED'], 'admitted, then wedged inside the queue')
-    assert.equal(payload.seenQueued, true)
-  })
-})
-
-test('regression (pi session 019fae8f): a dequeue while the PR stays OPEN is observed as a transition, not a state', async () => {
-  // The exact failure. `gh pr view` reports OPEN on EVERY poll — before entry, during
-  // membership, and after the drop — so no snapshot of PR state distinguishes them. Only the
-  // progression does. A watcher testing `state ∈ {MERGED, CLOSED}` runs to its ceiling here
-  // and reports nothing wrong.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    // Poll 1: queued. Polls 2+: cleanly absent — two readable absences settle the dequeue.
-    const counter = join(dir, 'poll-count')
-    makeFakeBin(dir, 'mergify', [
-      `n=$(cat ${counter} 2>/dev/null || echo 0)`,
-      `echo $((n + 1)) > ${counter}`,
-      'if [ "$n" -lt 1 ]; then',
-      '  echo \'{"number":1,"position":0,"queue_rule_name":"main"}\'',
-      'else',
-      '  echo \'{"number":1,"queued":false}\'',
-      'fi',
-    ].join('\n'))
-    const { code, payload } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.01', '--stall-minutes', '5', '--max-minutes', '5',
-    ])
-    assert.equal(code, 4)
-    assert.equal(payload.outcome, 'DEQUEUED')
-    assert.equal(payload.reason, 'lost-queue-membership')
-    assert.equal(payload.pr.state, 'OPEN', 'the PR never left OPEN — a state poke has nothing to fire on')
-    assert.deepEqual(payload.phases, ['QUEUED', 'DEQUEUED'], 'the verdict is the transition, and the transition is in the record')
-  })
-})
-
-test('the heartbeat carries the progression too, so a live watch is auditable mid-flight', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'OPEN', mergedAt: null, mergeCommit: null, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { progressLines } = await runCliCapturingLastPayload([
-      '--repo', 'o/r', '--pr', '1',
-      '--interval-seconds', '0.05', '--stall-minutes', '0.05', '--max-minutes', '0.05',
-    ])
-    assert.deepEqual(JSON.parse(progressLines[0]).phases, ['NOT_YET_QUEUED'])
-  })
-})
-
-test('CLI help states that this watches a progression and documents phases', async () => {
-  const lines = []
-  const original = console.log
-  console.log = (value) => lines.push(String(value))
-  try {
-    assert.equal(await runCli(['--help']), 0)
-  } finally {
-    console.log = original
-  }
-  const help = lines.join('\n')
-  assert.match(help, /progression/i, 'the one-line reason a hand-rolled state poke is wrong must survive in the help')
-  assert.match(help, /phases/)
-})
-
-// ---- the one-hour watch ceiling ----
-//
-// `--max-minutes` is the only bound standing between a busy-but-unfinishing queue and a watch
-// that outlives the session that launched it: `--stall-minutes` cannot catch that case by
-// design, because any movement resets it. So the ceiling is enforced rather than advised.
-
-test('the default absolute ceiling is one hour, and it is the hard maximum too', () => {
-  assert.equal(DEFAULT_MAX_MINUTES, 60)
-  assert.equal(MAX_MINUTES_CEILING, 60)
-  assert.equal(parseArgs(['--repo', 'o/r', '--pr', '1']).maxMinutes, MAX_MINUTES_CEILING,
-    'the default must sit AT the ceiling — a default above it would make every no-flag run a usage error')
-})
-
-test('--max-minutes above the ceiling is refused, not silently clamped', async () => {
-  const errors = []
-  const original = console.error
-  console.error = (v) => errors.push(String(v))
-  let code
-  try {
-    code = await runCli(['--repo', 'o/r', '--pr', '1', '--max-minutes', '240'])
-  } finally {
-    console.error = original
-  }
-  assert.equal(code, 2, 'an over-ceiling bound is a usage error')
-  const message = errors.join('\n')
-  assert.match(message, /240/, 'the message must quote what was asked for')
-  assert.match(message, /60/, 'and the ceiling it exceeded')
-  // Clamping is the tempting alternative and the wrong one: the caller would believe it had a
-  // four-hour watch while getting one hour, and neither stream here can carry a warning
-  // (stdout is exactly one terminal verdict, stderr is one NDJSON heartbeat per poll).
-  assert.equal(errors.filter((l) => l.startsWith('{')).length, 0, 'the refusal must not be emitted as a heartbeat record')
-})
-
-test('--max-minutes exactly at the ceiling is accepted', async () => {
-  // Boundary: `>` not `>=`, so the documented maximum is usable rather than off-by-one.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, { state: 'MERGED', mergedAt: '2026-01-01T00:00:00Z', mergeCommit: { oid: 'abc123' }, labels: [], url: 'https://x', comments: [] })
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code } = await runCliCapturingLastPayload(['--repo', 'o/r', '--pr', '1', '--max-minutes', String(MAX_MINUTES_CEILING)])
-    assert.equal(code, 0)
-  })
-})
-
-test('CLI help documents the hard maximum, not just the default', async () => {
-  const lines = []
-  const original = console.log
-  console.log = (value) => lines.push(String(value))
-  try {
-    assert.equal(await runCli(['--help']), 0)
-  } finally {
-    console.log = original
-  }
-  assert.match(lines.join('\n'), /hard maximum 60/,
-    'a ceiling a caller only discovers by tripping it is a ceiling that reads as a bug')
-})
-
-
-// ---- CI profiling ---------------------------------------------------------------------
-
-const isoAt = (ms) => new Date(ms).toISOString()
-const T0 = Date.parse('2026-09-29T10:00:00Z')
-// An unfinished job is IN_PROGRESS with GitHub's 0001-01-01 completedAt sentinel, as real
-// rollups report it; a finished one is COMPLETED.
-const check = (name, startMin, endMin, extra = {}) => ({
-  __typename: 'CheckRun', name, workflowName: 'CI',
-  status: endMin === null ? 'IN_PROGRESS' : 'COMPLETED', conclusion: endMin === null ? null : 'SUCCESS',
-  startedAt: isoAt(T0 + startMin * 60_000),
-  completedAt: endMin === null ? '0001-01-01T00:00:00Z' : isoAt(T0 + endMin * 60_000),
-  detailsUrl: `https://example.test/${name}`, ...extra,
-})
-
-test('checkTimings times completed and still-running jobs and skips Mergify and untimed checks', () => {
-  const jobs = checkTimings([
-    check('unit', 0, 2),
-    check('e2e', 0, null, { status: 'IN_PROGRESS', conclusion: null }),
-    check('Mergify Merge Queue', 0, 30),
-    { __typename: 'StatusContext', context: 'legacy', state: 'SUCCESS' },
-  ], { source: 'pr', nowMs: T0 + 7 * 60_000 })
-  assert.deepEqual(jobs.map((j) => [j.name, j.running, j.durationMs / 60_000]), [['unit', false, 2], ['e2e', true, 7]])
-  assert.equal(jobs[1].completedAt, null)
-  assert.equal(jobs[0].source, 'pr')
-})
-
-test('a slow job is warned about once, even across polls and while still running', () => {
-  const thresholdMs = 5 * 60_000
-  const warned = new Set()
-  let jobs = mergeCiJobs({}, checkTimings([check('e2e', 0, null)], { nowMs: T0 + 4 * 60_000 }))
-  assert.equal(newSlowJobs(jobs, { thresholdMs, warned }).length, 0, 'under the threshold: no warning yet')
-  jobs = mergeCiJobs(jobs, checkTimings([check('e2e', 0, null)], { nowMs: T0 + 6 * 60_000 }))
-  const first = newSlowJobs(jobs, { thresholdMs, warned })
-  assert.equal(first.length, 1, 'crossing the threshold while running warns')
-  first.forEach(({ key }) => warned.add(key))
-  jobs = mergeCiJobs(jobs, checkTimings([check('e2e', 0, 8)], { nowMs: T0 + 9 * 60_000 }))
-  assert.equal(Object.keys(jobs).length, 1, 'the finished reading replaces the running one')
-  assert.equal(newSlowJobs(jobs, { thresholdMs, warned }).length, 0, 'the same job run is not warned twice')
-  const line = JSON.parse(slowJobWarning(first[0].job, { thresholdMs, nowIso: 'now' }))
-  assert.equal(line.warning, 'slow-ci-job')
-  assert.equal(line.thresholdSec, 300)
-})
-
-test('exactly the threshold is not slow; one second over is', () => {
-  const thresholdMs = 5 * 60_000
-  const at = (sec) => mergeCiJobs({}, [{ source: 'pr', name: 'j', startedAt: 'x', durationMs: sec * 1000 }])
-  assert.equal(newSlowJobs(at(300), { thresholdMs }).length, 0)
-  assert.equal(newSlowJobs(at(301), { thresholdMs }).length, 1)
-})
-
-test('ciProfile reports slow jobs slowest-first, a verdict, and how long each phase lasted', () => {
-  const jobs = mergeCiJobs({}, checkTimings([check('unit', 0, 2), check('e2e', 0, 6), check('lint', 0, 1)], { nowMs: T0 + 10 * 60_000 }))
-  const timings = nextPhaseTimings(nextPhaseTimings([], ['NOT_YET_QUEUED'], T0), ['NOT_YET_QUEUED', 'QUEUED'], T0 + 3 * 60_000)
-  const profile = ciProfile(jobs, {
-    thresholdMs: 5 * 60_000,
-    phaseTimings: nextPhaseTimings(timings, ['NOT_YET_QUEUED', 'QUEUED', 'MERGED'], T0 + 10 * 60_000),
-    startedMs: T0, endMs: T0 + 10 * 60_000,
-  })
-  assert.equal(profile.verdict, 'slow')
-  assert.deepEqual(profile.jobs.map((j) => j.name), ['e2e', 'unit', 'lint'])
-  assert.deepEqual(profile.slowJobs.map((j) => [j.name, j.durationSec]), [['e2e', 360]])
-  assert.equal(profile.slowestJob.name, 'e2e')
-  assert.deepEqual(profile.phases, [
-    { phase: 'NOT_YET_QUEUED', atSec: 0, durationSec: 180 },
-    { phase: 'QUEUED', atSec: 180, durationSec: 420 },
-    { phase: 'MERGED', atSec: 600, durationSec: null },
-  ])
-  assert.equal(ciProfile({}, { thresholdMs: 1 }).verdict, 'no-timing-data')
-  assert.equal(ciProfile(mergeCiJobs({}, checkTimings([check('unit', 0, 2)])), { thresholdMs: 5 * 60_000 }).verdict, 'ok')
-})
-
-test('the slow-job threshold defaults to 5 minutes and is a validated flag', async () => {
-  assert.equal(DEFAULT_SLOW_JOB_MINUTES, 5)
-  assert.equal(parseArgs(['--repo', 'o/r', '--pr', '1']).slowJobMinutes, 5)
-  assert.equal(parseArgs(['--slow-job-minutes', '8']).slowJobMinutes, 8)
-  const originalError = console.error
-  console.error = () => {}
-  try {
-    assert.equal(await runCli(['--repo', 'o/r', '--pr', '1', '--slow-job-minutes', '0']), 2)
-  } finally {
-    console.error = originalError
-  }
-})
-
-function mergedPrWithChecks(checks) {
-  return {
-    state: 'MERGED', mergedAt: isoAt(T0 + 20 * 60_000), mergeCommit: { oid: 'abc' }, headRefOid: 'h',
-    labels: [], url: 'https://x', comments: [], statusCheckRollup: checks,
-  }
-}
-
-test('a watch warns on stderr for a CI job over the threshold and carries ciProfile on the verdict', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, mergedPrWithChecks([check('e2e', 0, 6), check('unit', 0, 2), check('Mergify Merge Queue', 0, 20)]))
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { code, payload, progressLines } = await runCliCapturingLastPayload(['--repo', 'o/r', '--pr', '1', '--quiet'])
-    assert.equal(code, 0, 'profiling never changes the exit code')
-    assert.equal(payload.outcome, 'MERGED')
-    const warnings = progressLines.map((l) => JSON.parse(l)).filter((l) => l.warning === 'slow-ci-job')
-    assert.deepEqual(warnings.map((w) => [w.name, w.durationSec]), [['e2e', 360]], 'warned once, even under --quiet')
-    assert.equal(payload.ciProfile.verdict, 'slow')
-    assert.deepEqual(payload.ciProfile.slowJobs.map((j) => j.name), ['e2e'])
-    assert.ok(!payload.ciProfile.jobs.some((j) => j.name.startsWith('Mergify')), 'Mergify queue wait is not a CI job')
-    const summary = JSON.parse(progressLines[progressLines.length - 1])
-    assert.deepEqual(summary, {
-      ciProfileSummary: true, outcome: 'MERGED', verdict: 'slow', jobCount: 2, slowJobMinutes: 5,
-      slowest: 'e2e 360s', slowJobs: ['e2e 360s'],
-    }, 'the last stderr line carries the profile, even under --quiet')
-  })
-})
-
-test('regression (identity #894): the profile summary is the last line of a short log tail', async () => {
-  // Pi's bg_task_status reports only the exit code and bg_task_log tails 10 lines, which landed
-  // inside the pretty-printed verdict's `phases`; the slow job was warned about and never read.
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, mergedPrWithChecks([check('Vitest unit + integration tests', 0, 338 / 60), check('unit', 0, 2)]))
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const combined = []
-    const originalLog = console.log
-    const originalError = console.error
-    console.log = (value) => combined.push(...String(value).split('\n'))
-    console.error = (value) => combined.push(...String(value).split('\n'))
-    try {
-      assert.equal(await runCli(['--repo', 'o/r', '--pr', '1']), 0)
-    } finally {
-      console.log = originalLog
-      console.error = originalError
-    }
-    const tail = combined.slice(-10).join('\n')
-    assert.match(tail, /"ciProfileSummary":true/)
-    assert.match(tail, /Vitest unit \+ integration tests 338s/)
-  })
-})
-
-test('ciProfileSummary names at most three slow jobs and counts the rest', () => {
-  const slowJobs = ['a', 'b', 'c', 'd', 'e'].map((name, i) => ({ name, durationSec: 600 - i }))
-  const line = JSON.parse(ciProfileSummary({ outcome: 'DEQUEUED' }, { verdict: 'slow', jobCount: 9, slowJobMinutes: 5, slowestJob: slowJobs[0], slowJobs }))
-  assert.deepEqual(line.slowJobs, ['a 600s', 'b 599s', 'c 598s', '+2 more'])
-  assert.equal(line.outcome, 'DEQUEUED')
-  assert.deepEqual(JSON.parse(ciProfileSummary({ outcome: 'STALLED' }, { verdict: 'no-timing-data', jobCount: 0, slowestJob: null, slowJobs: [] })).slowJobs, [])
-})
-
-test('a higher --slow-job-minutes silences the warning but keeps the profile', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    makeFakeGhReturning(dir, mergedPrWithChecks([check('e2e', 0, 6)]))
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":false}\'')
-    const { payload, progressLines } = await runCliCapturingLastPayload(['--repo', 'o/r', '--pr', '1', '--quiet', '--slow-job-minutes', '10'])
-    assert.equal(progressLines.filter((l) => l.includes('slow-ci-job')).length, 0)
-    assert.equal(payload.ciProfile.verdict, 'ok')
-    assert.equal(payload.ciProfile.jobs[0].durationSec, 360)
-  })
-})
-
-test('the queue batch PR checks are profiled once at the end of a merged watch', async () => {
-  await withFakeBinsOnPath(async (dir) => {
-    const prOpen = { state: 'OPEN', mergedAt: null, mergeCommit: null, headRefOid: 'h', labels: [], url: 'https://x', comments: [], statusCheckRollup: [check('unit', 0, 2)] }
-    const prMerged = { ...prOpen, state: 'MERGED', mergedAt: isoAt(T0), mergeCommit: { oid: 'abc' } }
-    const batch = { state: 'CLOSED', url: 'https://x/42', statusCheckRollup: [check('queue-suite', 0, 7)] }
-    const counter = join(dir, 'gh-count')
-    const write = (name, obj) => writeFileSync(join(dir, name), JSON.stringify(obj))
-    write('open.json', prOpen); write('merged.json', prMerged); write('batch.json', batch)
-    makeFakeBin(dir, 'gh', [
-      `if [ "$3" = "42" ]; then cat ${join(dir, 'batch.json')}; exit 0; fi`,
-      `n=$(cat ${counter} 2>/dev/null || echo 0); echo $((n + 1)) > ${counter}`,
-      `if [ "$n" -lt 1 ]; then cat ${join(dir, 'open.json')}; else cat ${join(dir, 'merged.json')}; fi`,
-    ].join('\n'))
-    makeFakeBin(dir, 'mergify', 'echo \'{"queued":true,"position":0,"queue_rule_name":"default","mergeability_check":{"queue_pull_request_number":42}}\'')
-    const { code, payload, progressLines } = await runCliCapturingLastPayload(['--repo', 'o/r', '--pr', '1', '--interval-seconds', '0.01', '--quiet'])
-    assert.equal(code, 0)
-    assert.deepEqual(payload.phases, ['QUEUED', 'MERGED'])
-    const batchJob = payload.ciProfile.jobs.find((j) => j.source === 'queue-batch')
-    assert.equal(batchJob?.name, 'queue-suite')
-    assert.deepEqual(progressLines.map((l) => JSON.parse(l)).filter((l) => l.warning).map((l) => [l.source, l.name]), [['queue-batch', 'queue-suite']])
-  })
-})
-
-
-test('regression (PR #1483): a skipped job with completedAt before startedAt is not a running slow job', () => {
-  // The exact rollup entry GitHub returned for the canary on #1483: SKIPPED, completed 8s
-  // BEFORE it "started". Reading out-of-order timestamps as "still running" timed it for the
-  // whole watch (580s) and raised a false slow-ci-job warning.
-  const skipped = {
-    __typename: 'CheckRun', name: 'external-source-canary', workflowName: 'CI', status: 'COMPLETED', conclusion: 'SKIPPED',
-    startedAt: '2026-09-28T16:24:06Z', completedAt: '2026-09-28T16:23:58Z', detailsUrl: 'https://x',
-  }
-  const nowMs = Date.parse('2026-09-28T16:34:00Z')
-  assert.deepEqual(checkTimings([skipped], { nowMs }), [], 'a job that did no work is not profiled')
-  const outOfOrder = { ...skipped, conclusion: 'SUCCESS' }
-  const [job] = checkTimings([outOfOrder], { nowMs })
-  assert.equal(job.running, false, 'COMPLETED status decides, not the timestamps')
-  assert.equal(job.durationMs, 0)
-  assert.equal(newSlowJobs(mergeCiJobs({}, [job]), { thresholdMs: 5 * 60_000 }).length, 0)
-})
-
-test('a job is running only while GitHub reports it is not COMPLETED', () => {
-  const nowMs = T0 + 6 * 60_000
-  const queued = { ...check('e2e', 0, null), status: 'QUEUED', conclusion: null }
-  const [job] = checkTimings([queued], { nowMs })
-  assert.equal(job.running, true)
-  assert.equal(job.durationMs, 6 * 60_000)
-})