claude-code-session-manager 0.84.0 → 0.86.0

package/src/main/__tests__/queue-starvation-per-project.test.cjs

@@ -0,0 +1,135 @@
+/**
+ * queue-starvation-per-project.test.cjs — classifyQueueStarvation's
+ * runningCount used to be fed the MACHINE-WIDE runningSet.size, so one
+ * long-lived job in ANY project disarmed the starvation watchdog for EVERY
+ * other project on the box. Observed live 2026-09-12: a job in
+ * starry-night-ships ran 80+ minutes while two other projects sat
+ * starved/blocked for hours — the watchdog never fired once because "work is
+ * flowing" was true somewhere else.
+ *
+ * classifyQueueStarvationByProject partitions jobs by cwd (the same grouping
+ * computeBlockedChains already uses) and evaluates each project on its OWN
+ * running/pending/idle evidence.
+ *
+ * Run: timeout 180 npx vitest run src/main/__tests__/queue-starvation-per-project.test.cjs
+ */
+
+'use strict';
+
+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');
+
+// HOME before require: every state path is baked from os.homedir() at load.
+process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-per-project-test-'));
+
+const {
+  classifyQueueStarvation,
+  classifyQueueStarvationByProject,
+  QUEUE_STARVATION_MS,
+} = require('../scheduler.cjs');
+
+const PROJECT_A = '/home/bilko/Projects/starry-night-ships';
+const PROJECT_B = '/home/bilko/Projects/session-manager';
+const NOW = Date.parse('2026-09-12T20:00:00.000Z');
+const LONG = QUEUE_STARVATION_MS + 60_000;
+const idleFor = (ms) => NOW - ms;
+
+test('one long-running job in project A no longer masks project B being starved', () => {
+  const jobs = [
+    { slug: '246-neptune', cwd: PROJECT_A, status: 'running', dependsOn: [] },
+    { slug: '1169-x', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
+    { slug: '1170-y', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
+  ];
+
+  // Pre-change shape: the machine-wide runningCount (1, from project A) hides
+  // project B's starvation entirely. This is the bug this PRD fixes — assert
+  // it still holds for the old, single-project entry point so a revert of
+  // the new driver is caught by this test going red.
+  const globalVerdict = classifyQueueStarvation({
+    jobs,
+    paused: false,
+    runningCount: 1,
+    lastRunAtMs: idleFor(LONG),
+    now: NOW,
+  });
+  assert.equal(globalVerdict, null);
+
+  // Per-project: project B has 0 of its OWN rows running and 2 dispatchable
+  // pending rows idle past the threshold — it must be reported as starved
+  // regardless of project A's running job.
+  const verdicts = classifyQueueStarvationByProject({
+    jobs,
+    paused: false,
+    runningSet: new Set(),
+    lastRunAtMs: idleFor(LONG),
+    now: NOW,
+  });
+  const forB = verdicts.find((v) => v.cwd === PROJECT_B);
+  assert.ok(forB, 'expected a verdict naming project B cwd');
+  assert.equal(forB.kind, 'starved');
+  assert.equal(forB.pending, 2);
+  assert.equal(forB.dispatchable, 2);
+
+  // Project A itself has a running row — never starved on its own account.
+  const forA = verdicts.find((v) => v.cwd === PROJECT_A);
+  assert.equal(forA, undefined);
+});
+
+test('a project fully blocked behind a terminal dependency is "blocked", not "starved", even while another project is starved in the same pass', () => {
+  const jobs = [
+    // Project A: every pending row sits behind a failed dependency — a tick
+    // cannot help this project, it needs a human/heal pass.
+    { slug: '206-lava-ape', cwd: PROJECT_A, status: 'failed', dependsOn: [] },
+    { slug: '207-body', cwd: PROJECT_A, status: 'pending', dependsOn: ['206-lava-ape'] },
+    // Project B: dispatchable right now — genuinely starved.
+    { slug: '1171-z', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
+  ];
+
+  const verdicts = classifyQueueStarvationByProject({
+    jobs,
+    paused: false,
+    runningSet: new Set(),
+    lastRunAtMs: idleFor(LONG),
+    now: NOW,
+  });
+
+  const forA = verdicts.find((v) => v.cwd === PROJECT_A);
+  assert.ok(forA, 'expected a verdict for the blocked project');
+  assert.equal(forA.kind, 'blocked');
+
+  const forB = verdicts.find((v) => v.cwd === PROJECT_B);
+  assert.ok(forB, 'expected a verdict for the starved project');
+  assert.equal(forB.kind, 'starved');
+});
+
+test('the whole-machine paused short-circuit is preserved for every project', () => {
+  const jobs = [
+    { slug: '1169-x', cwd: PROJECT_A, status: 'pending', dependsOn: [] },
+    { slug: '1170-y', cwd: PROJECT_B, status: 'pending', dependsOn: [] },
+  ];
+  const verdicts = classifyQueueStarvationByProject({
+    jobs,
+    paused: { reason: 'rate_limit', resumeAt: null },
+    runningSet: new Set(),
+    lastRunAtMs: idleFor(LONG),
+    now: NOW,
+  });
+  assert.deepEqual(verdicts, []);
+});
+
+test('a running-set membership (not just a status:"running" row) counts as that project having flowing work', () => {
+  const jobs = [
+    { slug: '9001-a', cwd: PROJECT_A, status: 'pending', dependsOn: [] },
+  ];
+  const verdicts = classifyQueueStarvationByProject({
+    jobs,
+    paused: false,
+    runningSet: new Set(['9001-a']),
+    lastRunAtMs: idleFor(LONG),
+    now: NOW,
+  });
+  assert.deepEqual(verdicts, []);
+});

package/src/main/__tests__/scheduler-failed-autoreset.test.cjs

@@ -0,0 +1,121 @@
+/**
+ * scheduler-failed-autoreset.test.cjs
+ *
+ * Covers selectFailedAutoResetTargets (the bounded failed -> pending
+ * auto-reset selector, PRD 1151) and failedAutoResetDisabled (its kill
+ * switch) in isolation. selectFailedAutoResetTargets is pure — no IO, no
+ * `require` inside the function — so unlike findStuckFailedJobs' own test
+ * file, there is no run-log fixture to set up here.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
+ * scheduler-reap-dead-running-jobs.test.cjs's comment for why.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-failed-autoreset.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'failed-autoreset-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectFailedAutoResetTargets,
+  FAILED_AUTORESET_CAP,
+  failedAutoResetDisabled,
+} = require('../scheduler.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 10 * MIN_MS;
+
+test('a fresh failed row (under threshold) is not selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'fresh-failure',
+    status: 'failed',
+    statusHistory: [{ to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('a row past threshold is selected, with its current attempt count', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'ripe-for-reset',
+    cwd: '/home/user/project',
+    status: 'failed',
+    failedAutoResetAttempts: 1,
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  const found = selectFailedAutoResetTargets([job], now, THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'ripe-for-reset');
+  assert.equal(found[0].cwd, '/home/user/project');
+  assert.equal(found[0].attempts, 1);
+  assert.ok(found[0].ageMs >= 15 * MIN_MS - 1000);
+});
+
+test('a row at the cap (failedAutoResetAttempts: 3) is not selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'cap-exhausted',
+    status: 'failed',
+    failedAutoResetAttempts: FAILED_AUTORESET_CAP,
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('a non-failed status is never selected', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'needs-review-row',
+    status: 'needs_review',
+    statusHistory: [{ to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString() }],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('the newest failed entry gates the threshold, not the first one', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'refailed-recently',
+    status: 'failed',
+    failedAutoResetAttempts: 1,
+    statusHistory: [
+      { to: 'failed', at: new Date(now - 2 * 24 * 60 * MIN_MS).toISOString() },
+      { to: 'pending', at: new Date(now - 23 * 60 * MIN_MS).toISOString() },
+      { to: 'failed', at: new Date(now - 2 * MIN_MS).toISOString() },
+    ],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0, 'the old failed entry must not be used to gate this row');
+});
+
+test('a row whose newest failed entry came from spawnJob:fail-dirty is never selected — that source is a deliberate do-not-auto-requeue decision', () => {
+  const now = Date.now();
+  const job = {
+    slug: 'dirty-worktree',
+    status: 'failed',
+    statusHistory: [
+      { to: 'failed', at: new Date(now - 15 * MIN_MS).toISOString(), source: 'spawnJob:fail-dirty' },
+    ],
+  };
+  assert.equal(selectFailedAutoResetTargets([job], now, THRESHOLD_MS).length, 0);
+});
+
+test('failedAutoResetDisabled reflects SM_FAILED_AUTORESET_DISABLE', () => {
+  const saved = process.env.SM_FAILED_AUTORESET_DISABLE;
+  try {
+    delete process.env.SM_FAILED_AUTORESET_DISABLE;
+    assert.equal(failedAutoResetDisabled(), false);
+    process.env.SM_FAILED_AUTORESET_DISABLE = '1';
+    assert.equal(failedAutoResetDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_FAILED_AUTORESET_DISABLE;
+    else process.env.SM_FAILED_AUTORESET_DISABLE = saved;
+  }
+});

package/src/main/__tests__/scheduler-needs-review-autoresolve.test.cjs

@@ -0,0 +1,189 @@
+/**
+ * scheduler-needs-review-autoresolve.test.cjs
+ *
+ * Covers the bounded automatic terminal decision for an EXHAUSTED
+ * needs_review row (isExhaustedAutoFix === true): selectExhaustedNeedsReviewTargets
+ * (the pure selector), applyNeedsReviewAutoResolve (the three-branch policy
+ * applier, extracted from the 10-minute interval body so it's testable
+ * without queue.json IO), needsReviewAutoResolveDisabled (its kill switch),
+ * and the dependsOn carve-out in schedulerBatch.cjs's findBlockingDep that
+ * lets a chain actually drain once this pass auto-skips a row.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
+ * under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-needs-review-autoresolve.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'needs-review-autoresolve-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectExhaustedNeedsReviewTargets,
+  applyNeedsReviewAutoResolve,
+  NEEDS_REVIEW_RESOLVE_CAP,
+  needsReviewAutoResolveDisabled,
+} = require('../scheduler.cjs');
+
+const { pickForProject } = require('../lib/schedulerBatch.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 30 * MIN_MS;
+
+function exhaustedJob(overrides = {}) {
+  return {
+    slug: 'exhausted-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    autoFixAttempted: true,
+    autoFixOutcome: 'no-plan',
+    autoFixRetries: 1, // spent, per isExhaustedAutoFix
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() }],
+    ...overrides,
+  };
+}
+
+// --- selectExhaustedNeedsReviewTargets ---
+
+test('a fresh exhausted needs_review row (under threshold) is not selected', () => {
+  const job = exhaustedJob({
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
+  });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-exhausted needs_review row (still eligible for a real auto-fix investigation) is left alone', () => {
+  // autoFixRetries: 0 — isExhaustedAutoFix is false here (an unspent retry
+  // remains); this pass must never steal a row selectAutoFixTargets still owns.
+  const job = exhaustedJob({ autoFixRetries: 0 });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-needs_review status is never selected', () => {
+  const job = exhaustedJob({ status: 'failed' });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('an exhausted row past threshold, under the cap, is selected', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'exhausted-row');
+  assert.equal(found[0].attempts, 0);
+});
+
+test('an exhausted row AT the cap is still selected — this is the pass that must terminally skip it', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+});
+
+test('a row already past the cap (defensive — should never occur once skipped) is excluded', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP + 1 });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('needsReviewAutoResolveDisabled reflects SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE', () => {
+  const saved = process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+  try {
+    delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+    assert.equal(needsReviewAutoResolveDisabled(), false);
+    process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = '1';
+    assert.equal(needsReviewAutoResolveDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE;
+    else process.env.SM_NEEDS_REVIEW_AUTORESOLVE_DISABLE = saved;
+  }
+});
+
+// --- applyNeedsReviewAutoResolve: the three policy branches ---
+
+test('branch 1: a looksDone annotation resolves the row to completed', () => {
+  const job = exhaustedJob({
+    exhaustedResolveAttempts: 1,
+    looksDone: { commits: ['abc1234'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
+  });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'completed');
+  assert.equal(job.status, 'completed');
+});
+
+test('branch 2: no looksDone, under the cap, requeues to pending and increments the attempt counter', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 0 });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 1);
+});
+
+test('branch 2 again: a second requeue at attempts=1 also succeeds (cap is 2)', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: 1 });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 2);
+});
+
+test('branch 3: once the cap is spent, the row is auto-skipped with the reason recorded in job.error', () => {
+  const job = exhaustedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+  assert.ok(typeof job.error === 'string' && job.error.length > 0, 'job.error must name the exhausted auto-fix path');
+  assert.match(job.error, /exhausted auto-fix/i);
+  assert.equal(job.needsReviewAutoResolvedSkip, true);
+});
+
+test('applyNeedsReviewAutoResolve race-guards against a row that moved off needs_review', () => {
+  const job = exhaustedJob({ status: 'completed', exhaustedResolveAttempts: 0 });
+  assert.equal(applyNeedsReviewAutoResolve(job), null);
+  assert.equal(job.status, 'completed'); // untouched
+});
+
+// --- chain drain: the actual point of this PRD ---
+
+test('a 3-row dependsOn chain drains: the exhausted middle row auto-skips and the third row becomes eligible', () => {
+  const now = Date.now();
+  const rowA = {
+    slug: 'a-first', cwd: '/home/user/project', status: 'completed',
+  };
+  const rowB = exhaustedJob({
+    slug: 'b-middle',
+    cwd: '/home/user/project',
+    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
+    dependsOn: ['a-first'],
+  });
+  const rowC = {
+    slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'],
+  };
+  const jobs = [rowA, rowB, rowC];
+
+  // Before resolution: C is blocked behind B's live needs_review row.
+  const before = pickForProject(jobs, new Set(), 5);
+  assert.equal(before.batch.length, 0, 'C must not be eligible while B still sits in needs_review');
+
+  const targets = selectExhaustedNeedsReviewTargets(jobs, now, THRESHOLD_MS);
+  assert.equal(targets.length, 1);
+  assert.equal(targets[0].slug, 'b-middle');
+  const outcome = applyNeedsReviewAutoResolve(rowB);
+  assert.equal(outcome, 'skipped');
+  assert.equal(rowB.status, 'skipped');
+
+  const after = pickForProject(jobs, new Set(), 5);
+  assert.ok(after.batch.some((j) => j.slug === 'c-last'), 'C must become eligible once B is auto-skipped');
+});
+
+test('a generic (non-auto-resolved) skipped dep still blocks forever — the carve-out is narrow', () => {
+  const rowB = { slug: 'b-middle', cwd: '/home/user/project', status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
+  const rowC = { slug: 'c-last', cwd: '/home/user/project', status: 'pending', dependsOn: ['b-middle'] };
+  const { batch } = pickForProject([rowB, rowC], new Set(), 5);
+  assert.equal(batch.length, 0, 'a PRD-source-vanished skip must remain a permanent block, unaffected by this carve-out');
+});

package/src/main/__tests__/scheduler-no-dead-end-status.test.cjs

@@ -0,0 +1,152 @@
+/**
+ * scheduler-no-dead-end-status.test.cjs
+ *
+ * Structural guard for the no-human-intervention guarantee (this PRD): every
+ * value in `JOB_STATUSES` (imported from scheduleJobSchema.cjs — the real
+ * array, never a hand-written copy) must either be genuinely final
+ * (completed/skipped) or have at least one AUTOMATED selector that can move
+ * a row parked in it, with no human action required.
+ *
+ * Each non-final status is asserted by CONSTRUCTING a representative parked
+ * row (a stale timestamp + a counter positioned so the row is still
+ * selectable) and showing the named selector actually returns it — not by
+ * asserting a hand-maintained status -> selector-name string map, which
+ * would pass even if the real wiring silently broke. If a future change adds
+ * a new status to JOB_STATUSES with no automated exit wired up here, this
+ * test fails loudly instead of the row becoming a new, silent dead end.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-failed-autoreset.test.cjs (appendAuditEvent writes
+ * under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-no-dead-end-status.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'no-dead-end-status-test-'));
+process.env.HOME = tmpHome;
+
+const { JOB_STATUSES } = require('../lib/scheduleJobSchema.cjs');
+const {
+  selectFailedAutoResetTargets,
+  FAILED_AUTORESET_CAP,
+  selectExhaustedNeedsReviewTargets,
+  NEEDS_REVIEW_RESOLVE_CAP,
+  selectQuarantineAutoResolveTargets,
+  QUARANTINE_RESOLVE_CAP,
+  findStrandedInvestigations,
+  INVESTIGATION_MAX_MS,
+} = require('../scheduler.cjs');
+const { selectReapableJobs } = require('../lib/reaperHelpers.cjs');
+const { pickForProject } = require('../lib/schedulerBatch.cjs');
+
+const MIN_MS = 60_000;
+
+// Every terminal status (no automated exit needed — nothing should ever
+// move a row out of these) and every non-terminal status's proof that a
+// row parked there is reachable by an automated selector, keyed only for
+// this test's own assertions (never treated as authoritative wiring below).
+const FINAL_STATUSES = new Set(['completed', 'skipped']);
+
+test('JOB_STATUSES contains exactly the statuses this test accounts for (fails loudly on drift)', () => {
+  // Not a hand-maintained selector map — just a manifest of what this file
+  // below actually exercises, so an entirely new, unhandled status trips
+  // this assertion instead of silently passing the loop below with zero
+  // coverage.
+  const accountedFor = new Set([
+    'pending', 'running', 'investigating', 'completed', 'skipped', 'failed', 'needs_review', 'quarantined',
+  ]);
+  const unaccounted = JOB_STATUSES.filter((s) => !accountedFor.has(s));
+  if (unaccounted.length > 0) {
+    throw new Error(
+      `HALT: JOB_STATUSES has status(es) with no automated-exit test coverage: ${unaccounted.join(', ')} — `
+      + 'add a case to scheduler-no-dead-end-status.test.cjs before shipping this status.',
+    );
+  }
+});
+
+test('every terminal status in JOB_STATUSES is genuinely final (completed/skipped only)', () => {
+  for (const status of JOB_STATUSES) {
+    if (status === 'completed' || status === 'skipped') continue;
+    assert.ok(!FINAL_STATUSES.has(status), `${status} must not be treated as final`);
+  }
+});
+
+test('pending: a fresh pending row with no blockers is picked for dispatch by pickForProject', () => {
+  assert.ok(JOB_STATUSES.includes('pending'));
+  const job = { slug: 'pending-row', cwd: '/home/user/project', status: 'pending' };
+  const { batch } = pickForProject([job], new Set(), 5);
+  assert.ok(batch.some((j) => j.slug === 'pending-row'), 'pending row must be dispatch-eligible with no blockers');
+});
+
+test('running: a running row whose pid is provably dead is reaped by selectReapableJobs', () => {
+  assert.ok(JOB_STATUSES.includes('running'));
+  const job = {
+    slug: 'dead-running-row',
+    cwd: '/home/user/project',
+    status: 'running',
+    runtime: { pid: 12345 },
+  };
+  const { reapable } = selectReapableJobs([job], Date.now(), { pidAlive: () => false, grace: 5 * MIN_MS });
+  assert.ok(reapable.some((r) => r.slug === 'dead-running-row'), 'a running row with a dead pid must be reapable');
+});
+
+test('investigating: a stranded investigation (stale, no live pid) is found by findStrandedInvestigations', () => {
+  assert.ok(JOB_STATUSES.includes('investigating'));
+  const job = {
+    slug: 'stranded-investigation',
+    cwd: '/home/user/project',
+    status: 'investigating',
+    statusHistory: [{ to: 'investigating', from: 'failed', at: new Date(Date.now() - (INVESTIGATION_MAX_MS + 5 * MIN_MS)).toISOString() }],
+  };
+  const found = findStrandedInvestigations([job], Date.now(), INVESTIGATION_MAX_MS, () => false);
+  assert.ok(found.some((f) => f.slug === 'stranded-investigation'), 'a stale investigating row with no live pid must be found');
+});
+
+test('failed: a stale failed row under its auto-reset cap is selected by selectFailedAutoResetTargets', () => {
+  assert.ok(JOB_STATUSES.includes('failed'));
+  const job = {
+    slug: 'stale-failed-row',
+    cwd: '/home/user/project',
+    status: 'failed',
+    failedAutoResetAttempts: FAILED_AUTORESET_CAP - 1,
+    statusHistory: [{ to: 'failed', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectFailedAutoResetTargets([job], Date.now(), 10 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'stale-failed-row'), 'a stale failed row under the cap must be auto-reset-selectable');
+});
+
+test('needs_review: an exhausted, stale needs_review row is selected by selectExhaustedNeedsReviewTargets', () => {
+  assert.ok(JOB_STATUSES.includes('needs_review'));
+  const job = {
+    slug: 'exhausted-needs-review-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    autoFixAttempted: true,
+    autoFixOutcome: 'no-plan',
+    autoFixRetries: 1,
+    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), 30 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'exhausted-needs-review-row'), 'an exhausted, stale needs_review row must be auto-resolve-selectable');
+});
+
+test('quarantined: a stale quarantined row under its resolve cap is selected by selectQuarantineAutoResolveTargets', () => {
+  assert.ok(JOB_STATUSES.includes('quarantined'));
+  const job = {
+    slug: 'stale-quarantined-row',
+    cwd: '/home/user/project',
+    status: 'quarantined',
+    quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP - 1,
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 60 * MIN_MS).toISOString() }],
+  };
+  const found = selectQuarantineAutoResolveTargets([job], Date.now(), 30 * MIN_MS);
+  assert.ok(found.some((f) => f.slug === 'stale-quarantined-row'), 'a stale quarantined row under the cap must be auto-resolve-selectable');
+});