claude-code-session-manager 0.85.0 → 0.86.0

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');
+});

package/src/main/__tests__/scheduler-quarantine-autoresolve.test.cjs

@@ -0,0 +1,165 @@
+/**
+ * scheduler-quarantine-autoresolve.test.cjs
+ *
+ * Covers the bounded automatic exit for a quarantined row that never
+ * received a `createdVia` provenance stamp (this PRD): the pure selector
+ * `selectQuarantineAutoResolveTargets`, the async applier
+ * `autoResolveQuarantine` (which re-reads the PRD file's frontmatter fresh
+ * from disk immediately before transitioning, so it can never race
+ * reconcile()'s own adopt path), and the kill switch
+ * `quarantineAutoResolveDisabled`.
+ *
+ * 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-quarantine-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(), 'quarantine-autoresolve-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  selectQuarantineAutoResolveTargets,
+  autoResolveQuarantine,
+  QUARANTINE_RESOLVE_CAP,
+  quarantineAutoResolveDisabled,
+} = require('../scheduler.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 60 * MIN_MS;
+
+function quarantinedJob(overrides = {}) {
+  return {
+    slug: 'quarantined-row',
+    cwd: '/home/user/project',
+    status: 'quarantined',
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 90 * MIN_MS).toISOString() }],
+    ...overrides,
+  };
+}
+
+function registerActiveProject(cwd) {
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+}
+
+function makeFixtureProject(prefix) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  registerActiveProject(cwd);
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-epic-1', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  return { cwd, prdsDir };
+}
+
+// --- selectQuarantineAutoResolveTargets ---
+
+test('a fresh quarantined row (under threshold) is not selected', () => {
+  const job = quarantinedJob({
+    statusHistory: [{ to: 'quarantined', at: new Date(Date.now() - 2 * MIN_MS).toISOString() }],
+  });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a non-quarantined status is never selected', () => {
+  const job = quarantinedJob({ status: 'failed' });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a quarantined row with no statusHistory entry cannot have its age proven, and is skipped', () => {
+  const job = quarantinedJob({ statusHistory: [] });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a quarantined row past threshold, under the cap, is selected', () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: 0 });
+  const found = selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, 'quarantined-row');
+  assert.ok(found[0].ageMs >= 90 * MIN_MS - 1000);
+});
+
+test('a quarantined row that already spent its resolve cap is excluded', () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
+  assert.equal(selectQuarantineAutoResolveTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('quarantineAutoResolveDisabled reflects SM_QUARANTINE_AUTORESOLVE_DISABLE', () => {
+  const saved = process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+  try {
+    delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+    assert.equal(quarantineAutoResolveDisabled(), false);
+    process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = '1';
+    assert.equal(quarantineAutoResolveDisabled(), true);
+  } finally {
+    if (saved === undefined) delete process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE;
+    else process.env.SM_QUARANTINE_AUTORESOLVE_DISABLE = saved;
+  }
+});
+
+// --- autoResolveQuarantine: the applier ---
+
+test('a quarantined row whose PRD file still has no createdVia is auto-resolved to skipped', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-noprovenance-');
+  try {
+    fs.writeFileSync(
+      path.join(prdsDir, 'quarantined-row.md'),
+      `---\ntitle: Unstamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nDo the thing.\n`,
+      'utf8',
+    );
+    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
+    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+    assert.equal(outcome, 'skipped');
+    assert.equal(job.status, 'skipped');
+    assert.equal(job.quarantineResolveAttempts, 1);
+    assert.ok(typeof job.error === 'string' && /createdVia/.test(job.error));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('a quarantined row whose PRD file HAS been stamped with createdVia is left alone — reconcile owns it now', async () => {
+  const { cwd, prdsDir } = makeFixtureProject('sm-quarantine-autoresolve-stamped-');
+  try {
+    fs.writeFileSync(
+      path.join(prdsDir, 'quarantined-row.md'),
+      `---\ntitle: Stamped PRD\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
+      'utf8',
+    );
+    const job = quarantinedJob({ cwd, quarantineResolveAttempts: 0 });
+    const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+    assert.equal(outcome, null);
+    assert.equal(job.status, 'quarantined'); // untouched — the adopt path owns the next pass
+    assert.equal(job.quarantineResolveAttempts, 0);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('autoResolveQuarantine race-guards against a row that moved off quarantined', async () => {
+  const job = quarantinedJob({ status: 'pending', quarantineResolveAttempts: 0 });
+  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
+  assert.equal(job.status, 'pending'); // untouched
+});
+
+test('autoResolveQuarantine race-guards against a row whose resolve cap is already spent', async () => {
+  const job = quarantinedJob({ quarantineResolveAttempts: QUARANTINE_RESOLVE_CAP });
+  assert.equal(await autoResolveQuarantine(job, 90 * MIN_MS), null);
+  assert.equal(job.status, 'quarantined'); // untouched
+});
+
+test('a quarantined row whose PRD file is missing entirely is treated as still lacking provenance and auto-resolved', async () => {
+  const job = quarantinedJob({ cwd: '/nonexistent/project/path', quarantineResolveAttempts: 0 });
+  const outcome = await autoResolveQuarantine(job, 90 * MIN_MS);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+});