claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/lib/__tests__/reaperHelpers.test.cjs

@@ -1,577 +0,0 @@
-/**
- * reaperHelpers.test.cjs — selectReapableJobs: the pure predicate behind
- * reapDeadRunningJobs()'s pidless-zombie fix.
- *
- * Prior behaviour: a 'running' row with no runtime.pid was skipped forever,
- * unconditionally ("spawn may be mid-flight; give it a cycle") — no age
- * bound. Repro 2026-09-01: a row sat pidless for 464 minutes against a
- * 24-minute estimate, empty run dir, no claude process anywhere — nothing
- * pid-bound (deadman, idle watchdog, supervisor) could ever see it.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/reaperHelpers.test.cjs
- */
-
-'use strict';
-
-// vitest, NOT node:test — this repo's suite is vitest-only (CLAUDE.md).
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawn } = require('node:child_process');
-const {
-  selectReapableJobs, mapOutcomeToGateOutcome, classifyRunOutcome,
-  findLiveProcessForJob, logHasOutput, resolvePidlessGateOutcome,
-  isAlreadySatisfiedOnMain, resolvePidlessFailureOverride,
-  readSpawnedPidFromLog, isLogFresh,
-} = require('../reaperHelpers.cjs');
-const { detectRateLimitInLog } = require('../rateLimitDetect.cjs');
-
-const NOW = Date.parse('2026-09-01T12:00:00.000Z');
-const agoMin = (m) => new Date(NOW - m * 60_000).toISOString();
-const GRACE = 10 * 60_000;
-const alwaysDead = () => false;
-const alwaysAlive = () => true;
-
-test('pidless + older than grace → reaped, with a named reason', () => {
-  const jobs = [{ slug: 'zombie', status: 'running', startedAt: agoMin(464) }];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(warnings.length, 0);
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].slug, 'zombie');
-  assert.strictEqual(reapable[0].pid, null);
-  assert.strictEqual(reapable[0].pidless, true);
-  assert.match(reapable[0].reason, /no runtime\.pid recorded after 10m/);
-});
-
-test('pidless + within grace → skipped (the genuine mid-flight-spawn case)', () => {
-  const jobs = [{ slug: 'fresh', status: 'running', startedAt: agoMin(2) }];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(warnings, []);
-});
-
-test('pidless + exactly at grace boundary → reaped (>= not >)', () => {
-  const jobs = [{ slug: 'boundary', status: 'running', startedAt: agoMin(10) }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-});
-
-test('live pid → skipped regardless of age', () => {
-  const jobs = [{ slug: 'live', status: 'running', runtime: { pid: 4242 }, startedAt: agoMin(500) }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-});
-
-// ---------- dispatchPhase breadcrumb (PRD: dispatch-region diagnostic) ----------
-
-test('pidless + dispatchPhase present → reason names the phase and timestamp', () => {
-  const jobs = [{
-    slug: 'zombie-phase',
-    status: 'running',
-    startedAt: agoMin(464),
-    dispatchPhase: 'baseline-persisted',
-    dispatchPhaseAt: '2026-09-12T02:46:10.000Z',
-  }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(
-    reapable[0].reason,
-    'reaped: no runtime.pid recorded after 10m — spawn never completed '
-    + '(last dispatch phase: baseline-persisted at 2026-09-12T02:46:10.000Z)',
-  );
-});
-
-test('pidless + no dispatchPhase (older-build row) → reason byte-identical to the pre-breadcrumb message', () => {
-  const jobs = [{ slug: 'zombie-noph', status: 'running', startedAt: agoMin(464) }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(
-    reapable[0].reason,
-    'reaped: no runtime.pid recorded after 10m — spawn never completed',
-  );
-});
-
-test('pidless + dispatchPhase present but dispatchPhaseAt missing/unparseable → phase named, no "at" clause, never throws', () => {
-  const jobs = [
-    { slug: 'zombie-noat', status: 'running', startedAt: agoMin(464), dispatchPhase: 'exec-entered' },
-    { slug: 'zombie-badat', status: 'running', startedAt: agoMin(464), dispatchPhase: 'exec-entered', dispatchPhaseAt: 'not-a-date' },
-  ];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 2);
-  for (const r of reapable) {
-    assert.strictEqual(
-      r.reason,
-      'reaped: no runtime.pid recorded after 10m — spawn never completed (last dispatch phase: exec-entered)',
-    );
-  }
-});
-
-test('pidless + dispatchPhase === "spawned" with no pid → still reapable, breadcrumb changes message only', () => {
-  const jobs = [{
-    slug: 'torn-write',
-    status: 'running',
-    startedAt: agoMin(464),
-    dispatchPhase: 'spawned',
-    dispatchPhaseAt: agoMin(465),
-  }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].pidless, true);
-  assert.match(reapable[0].reason, /last dispatch phase: spawned/);
-});
-
-test('dead pid → reaped exactly as before (pidless: false, no reason string)', () => {
-  const jobs = [{ slug: 'dead', status: 'running', runtime: { pid: 4242 }, startedAt: agoMin(500) }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysDead, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].slug, 'dead');
-  assert.strictEqual(reapable[0].pid, 4242);
-  assert.strictEqual(reapable[0].pidless, false);
-});
-
-test('pidless + missing startedAt → skipped and warned, not reaped', () => {
-  const jobs = [{ slug: 'no-started-at', status: 'running' }];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-  assert.strictEqual(warnings.length, 1);
-  assert.strictEqual(warnings[0].slug, 'no-started-at');
-});
-
-test('pidless + unparseable startedAt → skipped and warned, not reaped', () => {
-  const jobs = [{ slug: 'bad-started-at', status: 'running', startedAt: 'not-a-date' }];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-  assert.strictEqual(warnings.length, 1);
-  assert.strictEqual(warnings[0].slug, 'bad-started-at');
-});
-
-test('pidless + startedAt in the future (clock skew) → skipped, not reaped', () => {
-  const jobs = [{ slug: 'future', status: 'running', startedAt: agoMin(-60) }];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(warnings, []);
-});
-
-test('non-running rows are never considered, pidless or not', () => {
-  const jobs = [
-    { slug: 'a', status: 'pending', startedAt: agoMin(500) },
-    { slug: 'b', status: 'completed', startedAt: agoMin(500) },
-    { slug: 'c', status: 'failed', runtime: { pid: 1 }, startedAt: agoMin(500) },
-  ];
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysDead, grace: GRACE });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(warnings, []);
-});
-
-test('pidless + past grace + findLiveProcess finds a pid → recovered, never reaped', () => {
-  const jobs = [{ slug: 'zombie-alive', status: 'running', startedAt: agoMin(464) }];
-  const findLiveProcess = () => 2174739;
-  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(warnings, []);
-  assert.strictEqual(recovered.length, 1);
-  assert.strictEqual(recovered[0].slug, 'zombie-alive');
-  assert.strictEqual(recovered[0].pid, 2174739);
-});
-
-test('pidless + past grace + findLiveProcess finds nothing → reaped exactly as today', () => {
-  const jobs = [{ slug: 'zombie-dead', status: 'running', startedAt: agoMin(464) }];
-  const findLiveProcess = () => null;
-  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE, findLiveProcess });
-  assert.deepStrictEqual(recovered, []);
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].pidless, true);
-});
-
-test('pidless + past grace + no findLiveProcess supplied → reaped exactly as before this PRD', () => {
-  const jobs = [{ slug: 'zombie', status: 'running', startedAt: agoMin(464) }];
-  const { reapable, recovered } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.deepStrictEqual(recovered, []);
-});
-
-test('mixed batch: each row classified independently', () => {
-  const jobs = [
-    { slug: 'zombie', status: 'running', startedAt: agoMin(464) },
-    { slug: 'fresh', status: 'running', startedAt: agoMin(2) },
-    { slug: 'live', status: 'running', runtime: { pid: 1 }, startedAt: agoMin(500) },
-    { slug: 'dead', status: 'running', runtime: { pid: 2 }, startedAt: agoMin(500) },
-    { slug: 'bad-started-at', status: 'running', startedAt: 'nope' },
-  ];
-  const pidAlive = (pid) => pid === 1;
-  const { reapable, warnings } = selectReapableJobs(jobs, NOW, { pidAlive, grace: GRACE });
-  assert.deepStrictEqual(reapable.map((r) => r.slug).sort(), ['dead', 'zombie']);
-  assert.deepStrictEqual(warnings.map((w) => w.slug), ['bad-started-at']);
-});
-
-// mapOutcomeToGateOutcome — classifyRunOutcome's four-way result collapsed
-// onto the persisted `gateOutcome` field (PRD 1109). 'no_result' -> 'never_ran'
-// is the one non-obvious mapping: a missing verdict event means the gate
-// never fired, a distinct fact from 'failed' (a verdict event exists and
-// says error).
-test('mapOutcomeToGateOutcome: success -> passed', () => {
-  assert.strictEqual(mapOutcomeToGateOutcome('success'), 'passed');
-});
-
-test('mapOutcomeToGateOutcome: failed -> failed', () => {
-  assert.strictEqual(mapOutcomeToGateOutcome('failed'), 'failed');
-});
-
-test('mapOutcomeToGateOutcome: no_result -> never_ran', () => {
-  assert.strictEqual(mapOutcomeToGateOutcome('no_result'), 'never_ran');
-});
-
-test('mapOutcomeToGateOutcome: unknown -> unknown', () => {
-  assert.strictEqual(mapOutcomeToGateOutcome('unknown'), 'unknown');
-});
-
-// detectRateLimitInLog / classifyRunOutcome — PRD 1117: the reaper's
-// rate-limit detection must be the SAME single source of truth spawnJob
-// uses (detectRateLimitInLog, shared via lib/rateLimitDetect.cjs), and a
-// rate-limited death must classify as a NEW, distinct 'rate_limited'
-// outcome — never collapsed into 'failed', and never re-labelling
-// 'success'/'failed'/'no_result' (which keep their prior meanings, per the
-// mapOutcomeToGateOutcome tests above, unmodified).
-
-function writeTmpLog(contents) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reaper-rate-limit-test-'));
-  const p = path.join(dir, 'run.log');
-  fs.writeFileSync(p, contents);
-  return p;
-}
-
-test('detectRateLimitInLog: rateLimitType":"five_hour" variant', () => {
-  const p = writeTmpLog('{"type":"result","rate_limit_info":{"rateLimitType":"five_hour"}}\n');
-  assert.strictEqual(detectRateLimitInLog(p), true);
-});
-
-test('detectRateLimitInLog: rateLimitType":"seven_day" variant (missed pre-PRD-1117)', () => {
-  const p = writeTmpLog('{"type":"rate_limit_event","rate_limit_info":{"rateLimitType":"seven_day","unifiedWindows":{"five_hour":{"utilization":0}}}}\n');
-  assert.strictEqual(detectRateLimitInLog(p), true);
-});
-
-test('detectRateLimitInLog: api_error_status":429 variant', () => {
-  const p = writeTmpLog('{"type":"result","is_error":true,"api_error_status":429,"result":"nope"}\n');
-  assert.strictEqual(detectRateLimitInLog(p), true);
-});
-
-test('detectRateLimitInLog: "You\'ve reached your <model> limit" variant (missed pre-PRD-1117)', () => {
-  const p = writeTmpLog('{"type":"result","result":"You\'ve reached your Fable limit. Switch to another model."}\n');
-  assert.strictEqual(detectRateLimitInLog(p), true);
-});
-
-test('detectRateLimitInLog: real evidence log (2026-09-05 204-mercury-steam-horse 429)', () => {
-  const evidencePath = '/home/bilko/.claude/session-manager/scheduled-plans/runs/2026-09-05T16-32-18-381Z/204-mercury-steam-horse.log';
-  if (!fs.existsSync(evidencePath)) return; // machine-local fixture; skip elsewhere
-  assert.strictEqual(detectRateLimitInLog(evidencePath), true);
-});
-
-test('classifyRunOutcome: a 429 log tail classifies as the new distinct rate_limited outcome, not failed', () => {
-  const p = writeTmpLog('{"type":"result","subtype":"success","is_error":true,"api_error_status":429,"rateLimitType":"seven_day","result":"You\'ve reached your Fable limit."}\n');
-  assert.strictEqual(classifyRunOutcome(p), 'rate_limited');
-});
-
-test('classifyRunOutcome: a genuine error with no rate-limit signal still classifies as failed', () => {
-  const p = writeTmpLog('{"type":"result","subtype":"error","is_error":true,"result":"Error: expected 2 but got 3"}\n');
-  assert.strictEqual(classifyRunOutcome(p), 'failed');
-});
-
-// REGRESSION GUARD (2026-09-05). The rate-limit check originally ran as the
-// FIRST statement of classifyRunOutcome, before the result event was parsed.
-// Because the CLI emits an informational rate_limit_event with
-// status:"allowed_warning" on nearly every run once utilization is non-zero,
-// that misclassified genuinely successful runs as 'rate_limited' — which in
-// reapDeadRunningJobs re-queues finished work and spuriously pauses the whole
-// machine. The fixture below is the shape of a REAL successful run log, not a
-// synthetic one-liner: the allowed_warning event that every run carries, then
-// a clean result. If someone moves the check back to the top, this goes red.
-test('classifyRunOutcome: a SUCCESSFUL run whose tail carries an allowed_warning rate_limit_event is still success', () => {
-  const p = writeTmpLog([
-    '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed_warning","resetsAt":1788643800,"rateLimitType":"five_hour","utilization":0.42,"isUsingOverage":false}}',
-    '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed_warning","resetsAt":1789059600,"rateLimitType":"seven_day","utilization":0.59,"isUsingOverage":false}}',
-    '{"type":"result","subtype":"success","is_error":false,"num_turns":55,"result":"SCHEDULER_VERDICT: PASS"}',
-  ].join('\n') + '\n');
-  assert.strictEqual(classifyRunOutcome(p), 'success');
-  assert.strictEqual(mapOutcomeToGateOutcome(classifyRunOutcome(p)), 'passed');
-});
-
-// The same tail, but the run actually errored: NOW the rate-limit signal is
-// what it claims to be, and the outcome must be the retryable one.
-test('classifyRunOutcome: the same allowed_warning tail on an ERRORED run classifies as rate_limited', () => {
-  const p = writeTmpLog([
-    '{"type":"rate_limit_event","rate_limit_info":{"status":"allowed_warning","rateLimitType":"seven_day","utilization":0.59}}',
-    '{"type":"result","subtype":"success","is_error":true,"api_error_status":429,"result":"You\'ve reached your Fable limit."}',
-  ].join('\n') + '\n');
-  assert.strictEqual(classifyRunOutcome(p), 'rate_limited');
-});
-
-test('classifyRunOutcome: a clean success log still classifies as success', () => {
-  const p = writeTmpLog('{"type":"result","subtype":"success","is_error":false,"result":"done"}\n');
-  assert.strictEqual(classifyRunOutcome(p), 'success');
-});
-
-// findLiveProcessForJob — the /proc positive liveness scan behind the
-// 2026-09-06 stranded-branch incident (234-uranus-eight-tails-ox: marked
-// failed/never_ran while its process was alive and still writing to its
-// worktree). Linux-only, and a safe no-op everywhere else per its own header.
-
-test('findLiveProcessForJob: finds a live process via /proc/<pid>/cwd match', async () => {
-  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reaper-liveness-'));
-  const child = spawn('sleep', ['5'], { cwd: dir, stdio: 'ignore' });
-  try {
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    const pid = findLiveProcessForJob({ slug: 'irrelevant-slug' }, { worktreeDir: dir });
-    assert.strictEqual(pid, child.pid);
-  } finally {
-    child.kill('SIGKILL');
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('findLiveProcessForJob: no live process anywhere → null', () => {
-  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
-  const pid = findLiveProcessForJob(
-    { slug: 'definitely-not-a-real-running-slug-xyz123' },
-    { worktreeDir: '/nonexistent/worktree/dir/xyz123' },
-  );
-  assert.strictEqual(pid, null);
-});
-
-// findLiveProcessForJob: runCwd — the 2026-09-13 in-place/shared-tree fix.
-// A run with no dedicated worktree (no worktreeDir) and no slug in argv
-// (dispatch never puts it there) is invisible to both existing matches; the
-// runCwd+cmdline-claude combo match exists for exactly this shape. `sleep`
-// is used as the /proc-visible process here (not a real `claude` binary), so
-// this exercises the cwd-plus-cmdline-substring code path directly rather
-// than depending on a real claude binary being installed.
-test('findLiveProcessForJob: runCwd match requires BOTH cwd AND a claude-looking cmdline — bare cwd match is never sufficient', async () => {
-  if (process.platform !== 'linux' || !fs.existsSync('/proc')) return;
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reaper-runcwd-'));
-  // Runs in `dir` but its cmdline has no "claude" in it — must NOT match.
-  const child = spawn('sleep', ['5'], { cwd: dir, stdio: 'ignore' });
-  try {
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    const pid = findLiveProcessForJob({ slug: 'unrelated-slug' }, { runCwd: dir });
-    assert.strictEqual(pid, null, 'a bare cwd match without a claude-looking cmdline must never match — shared-tree cross-match hazard');
-  } finally {
-    child.kill('SIGKILL');
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// logHasOutput — the literal "did the run dir produce any log output" check
-// that gates whether a pidless reap may assert gateOutcome: 'never_ran'.
-
-test('logHasOutput: missing file → false', () => {
-  assert.strictEqual(logHasOutput('/nonexistent/path/does-not-exist.log'), false);
-});
-
-test('logHasOutput: empty file → false', () => {
-  const p = writeTmpLog('');
-  assert.strictEqual(logHasOutput(p), false);
-});
-
-test('logHasOutput: file with content → true', () => {
-  const p = writeTmpLog('some real log output\n');
-  assert.strictEqual(logHasOutput(p), true);
-});
-
-test('logHasOutput: null path → false', () => {
-  assert.strictEqual(logHasOutput(null), false);
-});
-
-// resolvePidlessGateOutcome — never_ran is asserted ONLY when the run dir has
-// no log output; a run dir WITH output must not claim never_ran even if no
-// clean result event was found in it.
-
-test('resolvePidlessGateOutcome: no output → never_ran, regardless of raw outcome (terminalizes as today)', () => {
-  assert.strictEqual(resolvePidlessGateOutcome('no_result', false), 'never_ran');
-  assert.strictEqual(resolvePidlessGateOutcome('success', false), 'never_ran');
-});
-
-test('resolvePidlessGateOutcome: output present + no_result → failed, never never_ran', () => {
-  assert.strictEqual(resolvePidlessGateOutcome('no_result', true), 'failed');
-});
-
-test('resolvePidlessGateOutcome: output present + success → passed', () => {
-  assert.strictEqual(resolvePidlessGateOutcome('success', true), 'passed');
-});
-
-test('resolvePidlessGateOutcome: output present + failed → failed', () => {
-  assert.strictEqual(resolvePidlessGateOutcome('failed', true), 'failed');
-});
-
-// isAlreadySatisfiedOnMain — PRD 1136. Pure decision layer: given the
-// already-git-queried list of satisfying commits, decide whether the
-// commit-guard's 'silent_no_op' verdict should be overridden to 'completed'.
-
-test('isAlreadySatisfiedOnMain: a satisfying commit → completed-shaped verdict naming the sha', () => {
-  const verdict = isAlreadySatisfiedOnMain(['5de4134abc123', 'a96de98def456']);
-  assert.strictEqual(verdict.sha, '5de4134abc123');
-  assert.strictEqual(verdict.verdict, 'already_satisfied_on_main');
-  assert.match(verdict.reason, /5de4134abc123/);
-});
-
-test('isAlreadySatisfiedOnMain: no satisfying commits → null — the gate must not be weakened into always-passing', () => {
-  assert.strictEqual(isAlreadySatisfiedOnMain([]), null);
-  assert.strictEqual(isAlreadySatisfiedOnMain(null), null);
-  assert.strictEqual(isAlreadySatisfiedOnMain(undefined), null);
-});
-
-// resolvePidlessFailureOverride — PRD 1173. A pidless reap must never stamp
-// 'failed' on a row that already carries proof (landedCommit) that its work
-// shipped, purely because reproting bookkeeping (runtime.pid) was lost.
-
-test('resolvePidlessFailureOverride: row with a landedCommit → override naming the recorded commit sha', () => {
-  const override = resolvePidlessFailureOverride({ slug: 'shipped-but-pidless', landedCommit: 'f3e35a7f9e49f13a9eb8c338b0d086160e32a87f' });
-  assert.ok(override, 'a row with landedCommit must produce a failure override');
-  assert.strictEqual(override.verdict, 'pidless_reap_with_landed_commit');
-  assert.strictEqual(override.landedCommit, 'f3e35a7f9e49f13a9eb8c338b0d086160e32a87f');
-  assert.match(override.reason, /f3e35a7f9e49f13a9eb8c338b0d086160e32a87f/, 'the reason string must name the recorded commit sha so a human can go straight to `git show <sha>`');
-});
-
-test('resolvePidlessFailureOverride: row with no landedCommit → null, existing failed transition untouched', () => {
-  assert.strictEqual(resolvePidlessFailureOverride({ slug: 'genuinely-never-ran' }), null);
-  assert.strictEqual(resolvePidlessFailureOverride({ slug: 'genuinely-never-ran', landedCommit: null }), null);
-  assert.strictEqual(resolvePidlessFailureOverride({ slug: 'genuinely-never-ran', landedCommit: '' }), null);
-});
-
-// readSpawnedPidFromLog — recovers the pid a pidless row's spawn actually
-// produced from the run's own log (2026-09-13 incident: runId
-// 2026-09-13T16-15-56-818Z spawned pid=3138458, logged it, but the
-// runtime.pid persistence mutate failed silently and the pidless-grace
-// reaper terminalized a live job it could have found here).
-
-test('readSpawnedPidFromLog: parses the scheduler\'s own spawned-pid line', () => {
-  const p = writeTmpLog('some preamble\n[scheduler] spawned pid=3138458 sessionId=345ca5b1-c7a7-4167-9b55-f4905e3afe01 (process group)\n\nmore output\n');
-  assert.strictEqual(readSpawnedPidFromLog(p), 3138458);
-});
-
-test('readSpawnedPidFromLog: missing file → null', () => {
-  assert.strictEqual(readSpawnedPidFromLog('/nonexistent/path/does-not-exist.log'), null);
-});
-
-test('readSpawnedPidFromLog: empty file → null', () => {
-  const p = writeTmpLog('');
-  assert.strictEqual(readSpawnedPidFromLog(p), null);
-});
-
-test('readSpawnedPidFromLog: log with no spawned-pid line → null', () => {
-  const p = writeTmpLog('{"type":"result","subtype":"success","is_error":false,"result":"done"}\n');
-  assert.strictEqual(readSpawnedPidFromLog(p), null);
-});
-
-test('readSpawnedPidFromLog: null path → null', () => {
-  assert.strictEqual(readSpawnedPidFromLog(null), null);
-});
-
-// isLogFresh — pure predicate: a log modified within the window is positive
-// proof of life, independent of runtime.pid bookkeeping.
-
-test('isLogFresh: mtime within window → true', () => {
-  assert.strictEqual(isLogFresh(NOW - 60_000, NOW, 20 * 60_000), true);
-});
-
-test('isLogFresh: mtime outside window → false', () => {
-  assert.strictEqual(isLogFresh(NOW - 30 * 60_000, NOW, 20 * 60_000), false);
-});
-
-test('isLogFresh: missing/invalid mtime or window → false', () => {
-  assert.strictEqual(isLogFresh(null, NOW, 20 * 60_000), false);
-  assert.strictEqual(isLogFresh(NaN, NOW, 20 * 60_000), false);
-  assert.strictEqual(isLogFresh(NOW - 60_000, NOW, null), false);
-});
-
-// selectReapableJobs — Part B wiring: a pidless row past grace now consults
-// the run log for a pid, and a fresh log skips the row entirely, BEFORE
-// falling back to findLiveProcess or the existing terminal reap.
-
-test('selectReapableJobs: pidless + past grace + log yields a LIVE pid → recovered, never reapable, row stays running', () => {
-  const jobs = [{ slug: 'zombie-log-alive', status: 'running', startedAt: agoMin(464) }];
-  const pidAlive = (pid) => pid === 3138458;
-  const getLogPid = () => 3138458;
-  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, {
-    pidAlive, grace: GRACE, getLogPid,
-  });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(warnings, []);
-  assert.strictEqual(recovered.length, 1);
-  assert.strictEqual(recovered[0].slug, 'zombie-log-alive');
-  assert.strictEqual(recovered[0].pid, 3138458);
-});
-
-test('selectReapableJobs: pidless + past grace + log yields a DEAD pid → still reaps (no regression)', () => {
-  const jobs = [{ slug: 'zombie-log-dead', status: 'running', startedAt: agoMin(464) }];
-  const getLogPid = () => 3138458;
-  const { reapable, recovered } = selectReapableJobs(jobs, NOW, {
-    pidAlive: alwaysDead, grace: GRACE, getLogPid,
-  });
-  assert.deepStrictEqual(recovered, []);
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].pidless, true);
-});
-
-test('selectReapableJobs: pidless + past grace + FRESH log mtime → skipped entirely (neither reapable nor recovered)', () => {
-  const jobs = [{ slug: 'chatty-pidless', status: 'running', startedAt: agoMin(464) }];
-  const getLogMtimeMs = () => NOW - 60_000; // modified 1 minute ago
-  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, {
-    pidAlive: alwaysAlive, grace: GRACE, getLogMtimeMs, logFreshWindowMs: 20 * 60_000,
-  });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(recovered, []);
-  assert.strictEqual(warnings.length, 1);
-  assert.strictEqual(warnings[0].slug, 'chatty-pidless');
-  assert.match(warnings[0].reason, /log evidence/);
-});
-
-test('selectReapableJobs: pidless + past grace + STALE log mtime + no recoverable pid → reaps with the existing reason string, byte-identical', () => {
-  const jobs = [{ slug: 'zombie', status: 'running', startedAt: agoMin(464) }];
-  const getLogMtimeMs = () => NOW - 25 * 60_000; // stale relative to a 20m window
-  const { reapable } = selectReapableJobs(jobs, NOW, {
-    pidAlive: alwaysAlive, grace: GRACE, getLogMtimeMs, logFreshWindowMs: 20 * 60_000,
-  });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].reason, 'reaped: no runtime.pid recorded after 10m — spawn never completed');
-});
-
-test('selectReapableJobs: a row WITH a live runtime.pid is untouched by every new code path', () => {
-  const jobs = [{ slug: 'live', status: 'running', runtime: { pid: 1 }, startedAt: agoMin(500) }];
-  const getLogPid = () => { throw new Error('must never be called for a live-pid row'); };
-  const getLogMtimeMs = () => { throw new Error('must never be called for a live-pid row'); };
-  const { reapable, recovered, warnings } = selectReapableJobs(jobs, NOW, {
-    pidAlive: alwaysAlive, grace: GRACE, getLogPid, getLogMtimeMs, logFreshWindowMs: 20 * 60_000,
-  });
-  assert.deepStrictEqual(reapable, []);
-  assert.deepStrictEqual(recovered, []);
-  assert.deepStrictEqual(warnings, []);
-});
-
-test('selectReapableJobs: pidless + past grace + landedCommit on the row → reapable entry carries a failureOverride', () => {
-  const jobs = [{
-    slug: 'shipped-but-pidless',
-    status: 'running',
-    startedAt: agoMin(464),
-    landedCommit: 'f3e35a7f9e49f13a9eb8c338b0d086160e32a87f',
-  }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].pidless, true);
-  assert.ok(reapable[0].failureOverride, 'the reapable entry must carry the evidence-based override');
-  assert.strictEqual(reapable[0].failureOverride.landedCommit, 'f3e35a7f9e49f13a9eb8c338b0d086160e32a87f');
-  // The existing byte-for-byte reason string is untouched by this PRD — the
-  // override is carried as a separate field, not folded into `reason`.
-  assert.strictEqual(
-    reapable[0].reason,
-    'reaped: no runtime.pid recorded after 10m — spawn never completed',
-  );
-});
-
-test('selectReapableJobs: pidless + past grace + NO landedCommit on the row → failureOverride is null, unchanged from today', () => {
-  const jobs = [{ slug: 'genuinely-never-ran', status: 'running', startedAt: agoMin(464) }];
-  const { reapable } = selectReapableJobs(jobs, NOW, { pidAlive: alwaysAlive, grace: GRACE });
-  assert.strictEqual(reapable.length, 1);
-  assert.strictEqual(reapable[0].failureOverride, null);
-});