claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-mechanical-recovery.test.cjs

@@ -1,245 +0,0 @@
-/**
- * scheduler-mechanical-recovery.test.cjs — PRD 1130: a fix-plan job parked
- * needs_review at investigationDepth >= 2 (isFixPlanBeyondDepthCap,
- * scheduler.cjs) gets no further investigation, and resume-first recovery
- * (selectResumeRecoveryTarget) is hard-gated on verdict 'uncommitted_changes'
- * — so a depth-capped job whose failure is fully mechanical (verdict
- * 'worktree_integration_failed') was previously stranded needs_review
- * forever (216-jupiter-sand-kazekage, 2026-09-06). This adds one bounded,
- * model-free recovery rung, evaluated independently of depth.
- *
- * selectMechanicalRecoveryTarget is the pure eligibility rule (no I/O, no
- * depth check); performMechanicalRecovery is the git plumbing + queue
- * transition, exercised against a real throwaway repo under os.tmpdir()
- * (same pattern as scheduler-leftover-quarantine.test.cjs and
- * scheduler-reap-dead-running-jobs.test.cjs).
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, since
- * queue.json I/O (mutate/readQueue/writeQueue) is baked into a top-level
- * ROOT const derived from os.homedir() at require time — this test must
- * never touch real state.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-mechanical-recovery.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-mechanical-recovery-test-'));
-process.env.HOME = tmpHome;
-
-const scheduler = require('../scheduler.cjs');
-const {
-  selectMechanicalRecoveryTarget, performMechanicalRecovery, MECHANICALLY_RESOLVABLE_VERDICTS,
-} = scheduler;
-const jobWorktree = require('../lib/jobWorktree.cjs');
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'a.txt'), 'original a\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-function writeProjectQueue(cwd, jobs) {
-  const stateDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
-  return path.join(stateDir, 'queue.json');
-}
-
-function registerActiveProject(cwd, slugDirName) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, slugDirName);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-let originalDisable;
-
-beforeEach(() => {
-  originalDisable = process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-  delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-});
-
-afterEach(() => {
-  if (originalDisable === undefined) delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-  else process.env.SM_MECHANICAL_RECOVERY_DISABLE = originalDisable;
-});
-
-// ──────────────────────────────────────────── selectMechanicalRecoveryTarget (pure)
-
-function eligibleJob(overrides = {}) {
-  return {
-    slug: 'depth-capped-fix-plan',
-    cwd: '/tmp/whatever-not-read-by-the-selector',
-    status: 'needs_review',
-    verifierVerdict: 'worktree_integration_failed',
-    investigationDepth: 2,
-    ...overrides,
-  };
-}
-
-test('selectMechanicalRecoveryTarget: eligible depth-2 worktree_integration_failed job returns a target, depth never disqualifies it', () => {
-  const target = selectMechanicalRecoveryTarget(eligibleJob({ investigationDepth: 5 }));
-  expect(target).not.toBeNull();
-  expect(target.slug).toBe('depth-capped-fix-plan');
-  expect(target.branch).toBe(jobWorktree.branchNameFor('depth-capped-fix-plan'));
-});
-
-test('selectMechanicalRecoveryTarget: already-attempted job is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ mechanicalRecoveryAttempted: true }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: a verdict outside the closed set is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ verifierVerdict: 'uncommitted_changes' }))).toBeNull();
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ verifierVerdict: 'transcript_errors' }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: wrong status is not eligible', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ status: 'failed' }))).toBeNull();
-  expect(selectMechanicalRecoveryTarget(eligibleJob({ status: 'completed' }))).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: kill-switch SM_MECHANICAL_RECOVERY_DISABLE=1 always returns null', () => {
-  process.env.SM_MECHANICAL_RECOVERY_DISABLE = '1';
-  expect(selectMechanicalRecoveryTarget(eligibleJob())).toBeNull();
-});
-
-const conflictJob = (o = {}) => eligibleJob({ integrationFailureKind: 'content_conflict', integrationBaseHeadSha: 'aaa111', ...o });
-
-test('selectMechanicalRecoveryTarget: content_conflict with unchanged HEAD is skipped', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), 'aaa111')).toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: content_conflict with a moved HEAD returns a target', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), 'bbb222')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: blocking_paths with unchanged HEAD still returns a target', () => {
-  const job = eligibleJob({ integrationFailureKind: 'blocking_paths', integrationBaseHeadSha: 'aaa111' });
-  expect(selectMechanicalRecoveryTarget(job, 'aaa111')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: a pre-mc-01 row with no integrationFailureKind still returns a target', () => {
-  expect(selectMechanicalRecoveryTarget(eligibleJob(), 'aaa111')).not.toBeNull();
-});
-
-test('selectMechanicalRecoveryTarget: null currentHeadSha never skips', () => {
-  expect(selectMechanicalRecoveryTarget(conflictJob(), null)).not.toBeNull();
-});
-
-test('MECHANICALLY_RESOLVABLE_VERDICTS: closed set contains exactly worktree_integration_failed', () => {
-  expect(Array.from(MECHANICALLY_RESOLVABLE_VERDICTS)).toEqual(['worktree_integration_failed']);
-});
-
-// ──────────────────────────────────────────── performMechanicalRecovery (real git + queue)
-
-test('performMechanicalRecovery: successful re-integration transitions needs_review -> completed, clears verifierVerdict, deletes the branch', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-success');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-success-slug');
-
-  const slug = 'fix-plan-depth2';
-  const branch = jobWorktree.branchNameFor(slug);
-  // Simulate a job whose worktree branch has one committed change, preserved
-  // (never deleted) because its earlier integration attempt failed.
-  git(['checkout', '-q', '-b', branch], projectCwd);
-  fs.writeFileSync(path.join(projectCwd, 'b.txt'), 'from the fix plan\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'fix plan work'], projectCwd);
-  git(['checkout', '-q', 'master'], projectCwd);
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug,
-      status: 'needs_review',
-      cwd: projectCwd,
-      verifierVerdict: 'worktree_integration_failed',
-      investigationDepth: 2,
-      error: 'worktree branch integration FAILED (merge failed) — branch preserved for manual recovery',
-    },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-  expect(target).not.toBeNull();
-
-  await performMechanicalRecovery({ slug, cwd: projectCwd }, target);
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs).toHaveLength(1);
-  expect(jobs[0].status).toBe('completed');
-  expect(jobs[0].verifierVerdict).toBeUndefined();
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].statusHistory.at(-1).source).toBe('scheduler:mechanicalRecovery');
-  expect(fs.readFileSync(path.join(projectCwd, 'b.txt'), 'utf8')).toBe('from the fix plan\n');
-  // The branch, now merged, is cleaned up.
-  const branchList = git(['branch', '--list', branch], projectCwd);
-  expect(branchList.trim()).toBe('');
-});
-
-test('performMechanicalRecovery: a real merge conflict keeps the job needs_review, stamps mechanicalRecoveryAttempted, appends the failure text', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-conflict');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-conflict-slug');
-
-  const slug = 'fix-plan-conflict';
-  const branch = jobWorktree.branchNameFor(slug);
-  git(['checkout', '-q', '-b', branch], projectCwd);
-  fs.writeFileSync(path.join(projectCwd, 'a.txt'), 'branch version\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'branch edits a.txt'], projectCwd);
-  git(['checkout', '-q', 'master'], projectCwd);
-  // Main tree diverges on the SAME line — a genuine, unresolvable conflict.
-  fs.writeFileSync(path.join(projectCwd, 'a.txt'), 'main version\n', 'utf8');
-  git(['add', '-A'], projectCwd);
-  git(['commit', '-q', '-m', 'main edits a.txt'], projectCwd);
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'needs_review', cwd: projectCwd, verifierVerdict: 'worktree_integration_failed', investigationDepth: 3, error: 'prior failure note' },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-  await performMechanicalRecovery({ slug, cwd: projectCwd }, target);
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs[0].status).toBe('needs_review');
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].error).toMatch(/prior failure note/);
-  expect(jobs[0].error).toMatch(/Mechanical recovery retry failed/);
-  // The branch is preserved for manual recovery, exactly like the original failure.
-  const branchList = git(['branch', '--list', branch], projectCwd);
-  expect(branchList.trim()).not.toBe('');
-});
-
-test('performMechanicalRecovery: a branch that no longer exists is handled without throwing, and stamps an explicit reason', async () => {
-  const projectCwd = path.join(tmpHome, 'proj-missing-branch');
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd, 'proj-missing-branch-slug');
-
-  const slug = 'fix-plan-already-merged';
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug, status: 'needs_review', cwd: projectCwd, verifierVerdict: 'worktree_integration_failed', investigationDepth: 2 },
-  ]);
-
-  const target = selectMechanicalRecoveryTarget({ slug, cwd: projectCwd, status: 'needs_review', verifierVerdict: 'worktree_integration_failed' });
-
-  await expect(performMechanicalRecovery({ slug, cwd: projectCwd }, target)).resolves.not.toThrow();
-
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  expect(jobs[0].status).toBe('needs_review');
-  expect(jobs[0].mechanicalRecoveryAttempted).toBe(true);
-  expect(jobs[0].error).toMatch(/not found/);
-});

package/src/main/__tests__/scheduler-meta-code-sha.test.cjs

@@ -1,46 +0,0 @@
-/**
- * scheduler-meta-code-sha.test.cjs — unit tests for the SCHEDULER_BOOTED_AT /
- * SCHEDULER_CODE_SHA constants stamped into every run's meta sidecar (PRD
- * 812-fix-commit-guard-retry-on-worktree-ref-visibility-delay): a stale
- * scheduler process is otherwise invisible in the run record, which cost a
- * full investigation to diagnose a false pass_no_commit.
- *
- * SCHEDULER_CODE_SHA now resolves through src/main/lib/buildIdentity.cjs
- * (build-identity-stamp PRD): a production npx install ships no .git, so a
- * runtime `git rev-parse` was structurally always null there — this file
- * used to accept that null unconditionally, which made the dead stamp green
- * forever. With src/main/build-info.json present (ensured below — the exact
- * artifact scripts/write-build-info.cjs bakes at publish time), the sha must
- * be real.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-meta-code-sha.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterAll } from 'vitest';
-const fs = require('node:fs');
-const path = require('node:path');
-
-const BUILD_INFO_PATH = path.join(__dirname, '..', 'build-info.json');
-const preexistingBuildInfo = fs.existsSync(BUILD_INFO_PATH) ? fs.readFileSync(BUILD_INFO_PATH, 'utf8') : null;
-if (preexistingBuildInfo === null) {
-  // eslint-disable-next-line global-require
-  require('../../../scripts/write-build-info.cjs').writeBuildInfo();
-}
-
-const { SCHEDULER_BOOTED_AT, SCHEDULER_CODE_SHA } = require('../scheduler.cjs');
-
-afterAll(() => {
-  if (preexistingBuildInfo === null) fs.rmSync(BUILD_INFO_PATH, { force: true });
-  else fs.writeFileSync(BUILD_INFO_PATH, preexistingBuildInfo);
-});
-
-test('SCHEDULER_BOOTED_AT is a valid ISO date string', () => {
-  expect(typeof SCHEDULER_BOOTED_AT).toBe('string');
-  expect(Number.isNaN(new Date(SCHEDULER_BOOTED_AT).getTime())).toBe(false);
-});
-
-test('SCHEDULER_CODE_SHA is a real short git hex SHA when build-info.json is present — never null', () => {
-  expect(SCHEDULER_CODE_SHA).toMatch(/^[0-9a-f]{7,40}$/);
-});

package/src/main/__tests__/scheduler-mutate-reentrancy.test.cjs

@@ -1,117 +0,0 @@
-/**
- * scheduler-mutate-reentrancy.test.cjs — regression cover for PRD 1443.
- *
- * mutate()'s chain (`mutateTail = mutateTail.then(...)`) is the single-writer
- * lock over queue.json. Calling mutate() again from INSIDE a still-running
- * mutate body (and awaiting it) used to queue the inner call behind
- * mutateTail — which the outer call itself is holding — so the inner
- * `await` never resolved and the whole scheduler froze (PRD 1442 was the one
- * known path: reconcile -> autoArchiveCompleted -> retireCompletedSlugs ->
- * mutate). The fix tracks "am I inside a live mutate body" via
- * AsyncLocalStorage and rejects immediately on re-entry instead of
- * deadlocking.
- *
- * HOME-isolated (mirrors scheduler-broadcast-reconcile.test.cjs): stub HOME to
- * a mkdtemp dir and mock queueStore's read/write so this never touches real
- * queue.json.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-mutate-reentrancy.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-mutate-reentrancy-home-'));
-  process.env.HOME = tmpHome;
-
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-
-  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function freshState() {
-  return { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
-}
-
-function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-test('nested awaited mutate rejects instead of hanging', async () => {
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-
-  let innerRejection = null;
-  const outerPromise = scheduler._mutateForTests(async () => {
-    try {
-      await scheduler._mutateForTests(async () => 'inner-should-never-resolve');
-    } catch (err) {
-      innerRejection = err;
-    }
-    return 'outer-done';
-  });
-
-  const result = await Promise.race([
-    outerPromise,
-    wait(2000).then(() => { throw new Error('outer mutate did not settle within 2s'); }),
-  ]);
-
-  expect(result).toBe('outer-done');
-  expect(innerRejection).toBeInstanceOf(Error);
-  expect(innerRejection.message).toMatch(/re-entered/i);
-});
-
-test('mutate scheduled via setTimeout from a finished body runs normally', async () => {
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-
-  let deferredResult = null;
-  let deferredError = null;
-
-  await scheduler._mutateForTests(async () => {
-    setTimeout(() => {
-      scheduler._mutateForTests(async () => 'deferred-ok')
-        .then((r) => { deferredResult = r; })
-        .catch((err) => { deferredError = err; });
-    }, 10);
-    return 'immediate';
-  });
-
-  await wait(300);
-
-  expect(deferredError).toBeNull();
-  expect(deferredResult).toBe('deferred-ok');
-});
-
-test('sequential mutates unaffected', async () => {
-  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
-  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
-
-  const r1 = await scheduler._mutateForTests(async () => 'first');
-  const r2 = await scheduler._mutateForTests(async () => 'second');
-
-  expect(r1).toBe('first');
-  expect(r2).toBe('second');
-});

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

@@ -1,197 +0,0 @@
-/**
- * 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;
-
-// Fixture cwd must be a REAL, writable dir: every transitionJob out of
-// needs_review fire-and-forgets a history append under <cwd>/session-manager-operations.
-// A fake path ('/home/user/project') made that append fail with EACCES *after*
-// the synchronous test returned, so its console.error landed while vitest was
-// closing the worker ("Closing rpc while onUserConsoleLog was pending" -> exit 1).
-const PROJECT_CWD = path.join(tmpHome, 'project');
-fs.mkdirSync(PROJECT_CWD, { recursive: true });
-
-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: PROJECT_CWD,
-    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: PROJECT_CWD, status: 'completed',
-  };
-  const rowB = exhaustedJob({
-    slug: 'b-middle',
-    cwd: PROJECT_CWD,
-    exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP,
-    dependsOn: ['a-first'],
-  });
-  const rowC = {
-    slug: 'c-last', cwd: PROJECT_CWD, 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: PROJECT_CWD, status: 'skipped' }; // no needsReviewAutoResolvedSkip marker
-  const rowC = { slug: 'c-last', cwd: PROJECT_CWD, 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');
-});