claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-commit-guard-noop.test.cjs

@@ -1,244 +0,0 @@
-/**
- * scheduler-commit-guard-noop.test.cjs — commitGuardVerdict must not flag a
- * legitimate no-op job (a truthful SCHEDULER_VERDICT: PASS, no commit, whose
- * own verifier verdict already independently proved the no-op is correct)
- * for dirt a CONCURRENT actor (e.g. an interactive /process-feedback session
- * writing new PRD .md files into the same repo) left in the working tree.
- *
- * Reproduces the confirmed 2026-07-31 incidents: job
- * 655-needs-review-rca-feedback-hook (verdict pass_no_commit_already_shipped)
- * was flagged uncommitted_changes for a file an interactive session wrote,
- * and job 672-fix-feedback-session-manager similarly. Before this fix, the
- * commit-guard had no exemption for a job whose verifier verdict was already
- * a proven no-op (COMPLETED_EQUIVALENT_VERDICTS) — only for jobSelfCommitted
- * or siblingRunning.
- *
- * Also guards the inverse: a REAL leftover-work case (no legitimate no-op
- * verdict, no sibling, no self-commit) must still be flagged — this fix must
- * not weaken the guard for genuine finish-protocol violations.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-commit-guard-noop.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { commitGuardVerdict } = require('../scheduler.cjs');
-const { resolveIsFixPlan } = require('../lib/fixPlanSlug.cjs');
-
-test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_already_shipped) + concurrent dirt → no flag (655 incident)', () => {
-  const verifyResult = {
-    verdict: 'pass_no_commit_already_shipped',
-    reason: 'SCHEDULER_VERDICT: PASS with no commit, but every PRD-named deliverable path is already tracked',
-    downgradeTo: null,
-  };
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['session-manager-operations/scheduler/prds/816-vitest-register-runverify-test.md'],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: true,
-    verifyResult,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_prior_run_verified) + concurrent dirt across multiple files → no flag (672 incident)', () => {
-  const verifyResult = {
-    verdict: 'pass_no_commit_prior_run_verified',
-    reason: 'SCHEDULER_VERDICT: PASS with no commit, but a prior run of this slug landed a commit already',
-    downgradeTo: null,
-  };
-  const verdict = commitGuardVerdict({
-    newlyDirty: [
-      'session-manager-operations/feedback/processed/a.md',
-      'session-manager-operations/feedback/processed/b.md',
-      'session-manager-operations/scheduler/prds/816-vitest-register-runverify-test.md',
-    ],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: true,
-    verifyResult,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: REAL leftover work (no legitimate no-op, no sibling, no self-commit) still flags uncommitted_changes', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['src/main/someFeature.cjs'],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    verifyResult: null,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.verdict).toBe('uncommitted_changes');
-  expect(verdict.downgradeTo).toBe('needs_review');
-  expect(verdict.reason).toMatch(/finish protocol incomplete/);
-});
-
-test('commitGuardVerdict: PRD 972 shape — exitCode 0, no commit, clean tree, non-exempt original slug → needs_review (must fail against pre-fix main)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.verdict).toBe('silent_no_op');
-  expect(verdict.downgradeTo).toBe('needs_review');
-  expect(verdict.reason).toMatch(/finish protocol incomplete/);
-});
-
-test('commitGuardVerdict: fix-plan job (523-fix-bounded-fix-plan-retry incident) — no commit, clean tree, isFixPlanJob → no flag', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: true,
-    verifyResult: { verdict: 'clean', reason: null, downgradeTo: null },
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: a zero-edit run of a human-authored PRD whose slug merely starts with "fix-" still yields silent_no_op (PRD 1131 — not exempted by name alone)', () => {
-  // Mirrors PRD 1126: authored via scheduler_create_prd (isFixPlan stamped
-  // false at reconcile time), slug happens to read "fix-...". Feeding the
-  // job's own persisted isFixPlan through resolveIsFixPlan (the same call
-  // spawnJob makes) must NOT exempt this zero-edit run from the guard.
-  const job = { slug: '126-fix-plan-death-reopens-parent', isFixPlan: false };
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: resolveIsFixPlan(job.slug, job.isFixPlan),
-    verifyResult: null,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.verdict).toBe('silent_no_op');
-  expect(verdict.downgradeTo).toBe('needs_review');
-});
-
-test('commitGuardVerdict: fix-plan job that DID leave real dirt behind is still flagged (isFixPlanJob only exempts the zero-edit case)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['src/main/someFeature.cjs'],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: true,
-    verifyResult: null,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.verdict).toBe('uncommitted_changes');
-});
-
-test('commitGuardVerdict: COMPLETED_EQUIVALENT verdict, no commit, clean tree → no flag (legitimateNoOp covers the zero-edit case too)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: true,
-    isFixPlanJob: false,
-    verifyResult: {
-      verdict: 'pass_no_commit_already_shipped',
-      reason: 'SCHEDULER_VERDICT: PASS with no commit, but every PRD-named deliverable path is already tracked',
-      downgradeTo: null,
-    },
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: sibling running + zero-edit → no flag (concurrent job makes working-tree evidence unreliable in both directions)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: true,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: sibling running skip still works (regression check)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['some/file.md'],
-    siblingRunning: true,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    verifyResult: null,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: self-commit skip still works (regression check)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['some/file.md'],
-    siblingRunning: false,
-    jobSelfCommitted: true,
-    legitimateNoOp: false,
-    verifyResult: null,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: ranInWorktree=true defeats siblingRunning — clean tree, no self-commit → silent_no_op (PRD 109 shape)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: true,
-    ranInWorktree: true,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.verdict).toBe('silent_no_op');
-  expect(verdict.downgradeTo).toBe('needs_review');
-});
-
-test('commitGuardVerdict: identical inputs with ranInWorktree=false → no flag (legacy shared-tree behaviour unchanged)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: true,
-    ranInWorktree: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: ranInWorktree=true + siblingRunning=true but jobSelfCommitted=true → no flag (self-commit carve-out still applies)', () => {
-  const verdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: true,
-    ranInWorktree: true,
-    jobSelfCommitted: true,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(verdict).toBeNull();
-});
-
-test('commitGuardVerdict: carries forward a non-clean prior verdict as an annotation', () => {
-  const verifyResult = {
-    verdict: 'transcript_errors',
-    reason: 'grep hit an Error string',
-    downgradeTo: 'needs_review',
-  };
-  const verdict = commitGuardVerdict({
-    newlyDirty: ['some/file.md'],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    verifyResult,
-  });
-  expect(verdict).not.toBeNull();
-  expect(verdict.annotations).toEqual([{ verdict: 'transcript_errors', reason: 'grep hit an Error string' }]);
-});

package/src/main/__tests__/scheduler-committed-in-window.test.cjs

@@ -1,182 +0,0 @@
-/**
- * scheduler-committed-in-window.test.cjs — unit tests for committedInWindow
- * and computeCommittedDuringRun's bounded retry.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-committed-in-window.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
-const scheduler = require('../scheduler.cjs');
-const { committedInWindow, computeCommittedDuringRun } = scheduler;
-
-function git(cwd, args) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' }).trim();
-}
-
-function makeRepo() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-'));
-  git(dir, ['init', '-q']);
-  git(dir, ['config', 'user.email', 'test@example.com']);
-  git(dir, ['config', 'user.name', 'Test']);
-  fs.writeFileSync(path.join(dir, 'base.txt'), 'base\n');
-  git(dir, ['add', '.']);
-  git(dir, ['commit', '-q', '-m', 'base']);
-  return dir;
-}
-
-test('committedInWindow returns true for a commit landed on a non-checked-out branch', async () => {
-  const dir = makeRepo();
-  try {
-    git(dir, ['checkout', '-q', '-b', 'work']);
-
-    const startedAt = new Date().toISOString();
-    fs.writeFileSync(path.join(dir, 'feature.txt'), 'feature\n');
-    git(dir, ['add', '.']);
-    git(dir, ['commit', '-q', '-m', 'feature commit']);
-    const finishedAt = new Date(Date.now() + 1000).toISOString();
-
-    // Simulate the run leaving a different branch checked out at exit.
-    git(dir, ['checkout', '-q', '-b', 'other-branch-at-exit']);
-
-    const result = await committedInWindow(dir, startedAt, finishedAt);
-    expect(result).toBe(true);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('committedInWindow returns false when the window covers no commit', async () => {
-  const dir = makeRepo();
-  try {
-    const farFutureStart = new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString();
-    const farFutureEnd = new Date(Date.now() + 366 * 24 * 60 * 60 * 1000).toISOString();
-
-    const result = await committedInWindow(dir, farFutureStart, farFutureEnd);
-    expect(result).toBe(false);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// Reproduces the sigma PRD 713 incident: a commit made+pushed from an
-// isolated worktree checkout that shares the run's remote but not job.cwd's
-// local refs — e.g. `git worktree add /tmp/foo` followed by `git worktree
-// remove` clears the worktree's local branch, leaving the commit reachable
-// in job.cwd only via a remote-tracking ref that hasn't been fetched yet.
-// Modeled here as a second, independent clone of the shared remote (rather
-// than a literal `git worktree add`, which shares job.cwd's .git store and
-// so opportunistically updates job.cwd's remote-tracking ref on push,
-// masking the staleness this test needs to exercise) — the observable
-// symptom is identical: job.cwd's remote-tracking ref is stale until fetched.
-test('committedInWindow sees a commit pushed from an isolated checkout, only reachable via a stale remote-tracking ref', async () => {
-  const bareDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-bare-'));
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-cwd-'));
-  const worktreeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-committed-in-window-wt-'));
-  try {
-    git(bareDir, ['init', '-q', '--bare']);
-
-    const seedDir = makeRepo();
-    try {
-      git(seedDir, ['push', bareDir, 'HEAD:refs/heads/main']);
-      // Without an explicit default branch, the bare repo's symbolic HEAD can
-      // point at a nonexistent ref (e.g. 'master'), which makes the clone
-      // below check out no local branch at all — set it explicitly.
-      git(bareDir, ['symbolic-ref', 'HEAD', 'refs/heads/main']);
-    } finally {
-      fs.rmSync(seedDir, { recursive: true, force: true });
-    }
-
-    git(cwd, ['clone', '-q', bareDir, '.']);
-    git(cwd, ['config', 'user.email', 'test@example.com']);
-    git(cwd, ['config', 'user.name', 'Test']);
-
-    const startedAt = new Date().toISOString();
-
-    // Simulate the PRD's own isolated-checkout workflow: a separate clone of
-    // the same shared remote, a commit there, a push back to that remote —
-    // job.cwd never touches this checkout and never fetches after the push.
-    git(worktreeDir, ['clone', '-q', bareDir, '.']);
-    git(worktreeDir, ['config', 'user.email', 'test@example.com']);
-    git(worktreeDir, ['config', 'user.name', 'Test']);
-    git(worktreeDir, ['checkout', '-q', '-b', 'temp-merge-branch']);
-    fs.writeFileSync(path.join(worktreeDir, 'feature.txt'), 'feature\n');
-    git(worktreeDir, ['add', '.']);
-    git(worktreeDir, ['commit', '-q', '-m', 'feature commit from isolated worktree']);
-    git(worktreeDir, ['push', 'origin', 'temp-merge-branch']);
-
-    const finishedAt = new Date(Date.now() + 1000).toISOString();
-
-    // Precondition: without a fetch, job.cwd genuinely cannot see the commit —
-    // this is what made committedInWindow's old bare `git log --all` blind to it.
-    expect(() => git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']))
-      .not.toThrow();
-    const beforeFetch = git(cwd, ['log', '--all', '--format=%H', '--grep=feature commit from isolated worktree']);
-    expect(beforeFetch).toBe('');
-
-    const result = await committedInWindow(cwd, startedAt, finishedAt);
-    expect(result).toBe(true);
-  } finally {
-    fs.rmSync(bareDir, { recursive: true, force: true });
-    fs.rmSync(cwd, { recursive: true, force: true });
-    fs.rmSync(worktreeDir, { recursive: true, force: true });
-  }
-});
-
-// Reproduces the pass-no-commit-worktree / RCA 770-pr269 incidents: the live
-// commit-guard's committedInWindow() call can race against ref/object
-// visibility at the exact moment of process exit and return false even
-// though the commit is real. computeCommittedDuringRun() should retry once
-// after a bounded delay before giving up.
-test('computeCommittedDuringRun retries committedInWindow once and returns true when the retry succeeds', async () => {
-  vi.useFakeTimers();
-  try {
-    const spy = vi.spyOn(scheduler, 'committedInWindow')
-      .mockResolvedValueOnce(false)
-      .mockResolvedValueOnce(true);
-
-    const resultPromise = computeCommittedDuringRun('/tmp/fake', 'abc', 'abc', 'start', 'until');
-    await vi.runAllTimersAsync();
-    const result = await resultPromise;
-
-    expect(result).toBe(true);
-    expect(spy).toHaveBeenCalledTimes(2);
-  } finally {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  }
-});
-
-test('computeCommittedDuringRun returns false when both committedInWindow calls return false', async () => {
-  vi.useFakeTimers();
-  try {
-    const spy = vi.spyOn(scheduler, 'committedInWindow').mockResolvedValue(false);
-
-    const resultPromise = computeCommittedDuringRun('/tmp/fake', 'abc', 'abc', 'start', 'until');
-    await vi.runAllTimersAsync();
-    const result = await resultPromise;
-
-    expect(result).toBe(false);
-    expect(spy).toHaveBeenCalledTimes(2);
-  } finally {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  }
-});
-
-test('computeCommittedDuringRun skips the retry (and the delay) when the HEAD-diff fast path already resolves true', async () => {
-  const spy = vi.spyOn(scheduler, 'committedInWindow');
-  try {
-    const result = await computeCommittedDuringRun('/tmp/fake', 'headBefore', 'headAfter', 'start', 'until');
-
-    expect(result).toBe(true);
-    expect(spy).not.toHaveBeenCalled();
-  } finally {
-    vi.restoreAllMocks();
-  }
-});

package/src/main/__tests__/scheduler-cross-project-batch.test.cjs

@@ -1,43 +0,0 @@
-'use strict';
-
-// Ported from the retired top-level test-root directory (a node:test suite,
-// never runnable by this repo's vitest-only setup — see CLAUDE.md's Commands
-// section). Pins the two basic cross-project pickNextBatch contracts that
-// were asserted there but not literally exercised elsewhere: N independent
-// projects each with a single pending job all fire together when the global
-// slot pool is generous, and a global cap BELOW the total pending count
-// across projects admits exactly that many, not more.
-//
-// Run: timeout 120 npx vitest run src/main/__tests__/scheduler-cross-project-batch.test.cjs
-
-const assert = require('node:assert/strict');
-const { pickNextBatch } = require('../lib/schedulerBatch.cjs');
-
-function job(slug, status, cwd, parallelGroup) {
-  return { slug, status, cwd, parallelGroup, dependsOn: [] };
-}
-
-test('3 independent projects, 1 pending each, generous cap (6) → all 3 fire', () => {
-  const jobs = [
-    job('a-job', 'pending', '/a', 5),
-    job('b-job', 'pending', '/b', 5),
-    job('c-job', 'pending', '/c', 5),
-  ];
-  const { batch, reason } = pickNextBatch(jobs, new Set(), 6);
-  assert.equal(batch.length, 3);
-  assert.equal(reason, null);
-  const slugs = new Set(batch.map((j) => j.slug));
-  assert.ok(slugs.has('a-job'));
-  assert.ok(slugs.has('b-job'));
-  assert.ok(slugs.has('c-job'));
-});
-
-test('3 independent projects, 1 pending each, cap 2 (below total pending) → exactly 2 fire', () => {
-  const jobs = [
-    job('a-job', 'pending', '/a', 5),
-    job('b-job', 'pending', '/b', 5),
-    job('c-job', 'pending', '/c', 5),
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 2);
-  assert.equal(batch.length, 2);
-});

package/src/main/__tests__/scheduler-default-eligible-heal.test.cjs

@@ -1,168 +0,0 @@
-/**
- * scheduler-default-eligible-heal.test.cjs — the periodic heal ladder is
- * default-ELIGIBLE (2026-09-18, 1229-fo-03 parked shared_tree_reverted and
- * blocked 19 of 20 pending rows because that verdict was on no allow-list).
- *
- * Covers: any needs_review verdict is a candidate unless named in
- * RESCAN_EXCLUDED_VERDICTS; the evidence rung is bounded; a row that cannot
- * heal terminates under the bounded ladder; health names a silent blocker.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-default-eligible-heal.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');
-
-process.env.HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'default-eligible-heal-test-'));
-
-// Fixture cwd must be a REAL, writable dir: transitionJob out of needs_review
-// fire-and-forgets a history append under <cwd>/session-manager-operations. A fake
-// path made it fail EACCES AFTER the sync test returned, so its console.error hit
-// vitest mid worker-close ("Closing rpc while onUserConsoleLog was pending").
-const PROJECT_CWD = path.join(process.env.HOME, 'project');
-fs.mkdirSync(PROJECT_CWD, { recursive: true });
-
-const {
-  isRescanCandidate,
-  isTranscriptRescannable,
-  isStrandedAutoFixPark,
-  isEligibleForNeedsReviewAutoResolve,
-  shouldRunPeriodicReverify,
-  selectEvidenceScanTargets,
-  selectAutoFixTargets,
-  selectMechanicalRecoveryTarget,
-  selectResumeRecoveryTarget,
-  applyNeedsReviewAutoResolve,
-  RESCAN_EXCLUDED_VERDICTS,
-  RESCANNABLE_VERDICTS,
-  EVIDENCE_SCAN_MAX_PER_PASS,
-  EVIDENCE_SCAN_MIN_INTERVAL_MS,
-  REVERIFY_INTERVAL_MS,
-  NEEDS_REVIEW_RESOLVE_CAP,
-} = require('../scheduler.cjs');
-const { evaluateBlockingParkHealth } = require('../health.cjs');
-
-const row = (o = {}) => ({ slug: '10-x', status: 'needs_review', runId: 'r1', cwd: PROJECT_CWD, ...o });
-
-test('shared_tree_reverted is a rescan candidate without being on any list', () => {
-  assert.equal(RESCANNABLE_VERDICTS.has('shared_tree_reverted'), false);
-  assert.equal(isRescanCandidate(row({ verifierVerdict: 'shared_tree_reverted' })), true);
-});
-
-test('an invented verdict name the code has never seen is a rescan candidate', () => {
-  const j = row({ verifierVerdict: 'some_future_guard_verdict' });
-  assert.equal(isRescanCandidate(j), true);
-  assert.equal(shouldRunPeriodicReverify([j]), true);
-  // Not transcript-rescannable: it gets the evidence rung, never a verifyRun heal.
-  assert.equal(isTranscriptRescannable(j), false);
-  assert.deepEqual(selectEvidenceScanTargets([j]).map((x) => x.slug), ['10-x']);
-});
-
-test('a needs_review row with no runId and no verdict is still a candidate', () => {
-  assert.equal(isRescanCandidate({ slug: 's', status: 'needs_review' }), true);
-});
-
-test('only the named exclusions are refused, each verdict in the set', () => {
-  for (const v of RESCAN_EXCLUDED_VERDICTS) assert.equal(isRescanCandidate(row({ verifierVerdict: v })), false, v);
-  assert.deepEqual([...RESCAN_EXCLUDED_VERDICTS].sort(), ['budget_exceeded', 'uncommitted_changes', 'worktree_integration_failed']);
-});
-
-test('rescannable verdict keeps the transcript rung as a hint', () => {
-  assert.equal(isTranscriptRescannable(row({ verifierVerdict: 'transcript_errors' })), true);
-  assert.deepEqual(selectEvidenceScanTargets([row({ verifierVerdict: 'transcript_errors' })]), []);
-});
-
-test('1229-fo-03 shape: stranded auto-fix park is an auto-resolve door AND an evidence-scan target', () => {
-  const j = row({ verifierVerdict: 'shared_tree_reverted', autoFixAttempted: true });
-  assert.equal(isStrandedAutoFixPark(j, [j]), true);
-  assert.equal(isEligibleForNeedsReviewAutoResolve(j, [j]), true);
-  assert.equal(selectEvidenceScanTargets([j]).length, 1, 'looksDone evidence is now computed for it, so the door can fire');
-});
-
-test('a live auto-fix history that is not an auto-resolve door gets no evidence scan (PRD 1136)', () => {
-  const j = row({ verifierVerdict: 'some_future_guard_verdict', autoFixAttempted: true, autoFixOutcome: 'plan' });
-  assert.equal(selectEvidenceScanTargets([j]).length, 0);
-});
-
-test('cost bound: per-pass cap, looksDone skip, and per-row re-scan throttle', () => {
-  const now = Date.now();
-  const many = Array.from({ length: 100 }, (_, i) => row({ slug: `${i}-p`, verifierVerdict: 'v_new' }));
-  assert.equal(selectEvidenceScanTargets(many, now).length, EVIDENCE_SCAN_MAX_PER_PASS);
-  const done = many.map((j) => ({ ...j, looksDone: { commits: ['a'] } }));
-  assert.equal(selectEvidenceScanTargets(done, now).length, 0);
-  const fresh = many.map((j) => ({ ...j, evidenceScannedAt: new Date(now - EVIDENCE_SCAN_MIN_INTERVAL_MS + 1000).toISOString() }));
-  assert.equal(selectEvidenceScanTargets(fresh, now).length, 0);
-  // never-scanned rows go before stale-scanned ones
-  const mixed = [
-    row({ slug: 'old', verifierVerdict: 'v', evidenceScannedAt: new Date(now - 10 * EVIDENCE_SCAN_MIN_INTERVAL_MS).toISOString() }),
-    row({ slug: 'never', verifierVerdict: 'v' }),
-  ];
-  assert.equal(selectEvidenceScanTargets(mixed, now)[0].slug, 'never');
-});
-
-test('unhealable row terminates: N passes yield a bounded number of recovery attempts, reason intact', () => {
-  let now = Date.now();
-  const job = row({ slug: '20-stuck', verifierVerdict: 'some_future_guard_verdict' });
-  const jobs = [job];
-  let evidenceScans = 0;
-  let autoFixDispatches = 0;
-  let resumeOrMechanical = 0;
-  const PASSES = 500;
-  for (let n = 0; n < PASSES; n++) {
-    now += REVERIFY_INTERVAL_MS;
-    for (const t of selectEvidenceScanTargets(jobs, now)) { evidenceScans++; t.evidenceScannedAt = new Date(now).toISOString(); }
-    resumeOrMechanical += jobs.filter((j) => selectMechanicalRecoveryTarget(j) || selectResumeRecoveryTarget(j)).length;
-    for (const t of selectAutoFixTargets(jobs, { fixSlugExists: () => false, resolveJobRunId: () => 'r1' })) {
-      autoFixDispatches++;
-      // what reverifyNeedsReview stamps before spawning
-      t.autoFixRetries = t.autoFixAttempted === true ? (t.autoFixRetries ?? 0) + 1 : t.autoFixRetries;
-      t.autoFixAttempted = true;
-    }
-  }
-  assert.ok(autoFixDispatches <= 2, `auto-fix dispatched ${autoFixDispatches}x`);
-  assert.equal(resumeOrMechanical, 0);
-  // one scan per throttle window, not one per pass
-  assert.ok(evidenceScans <= Math.ceil(PASSES * REVERIFY_INTERVAL_MS / EVIDENCE_SCAN_MIN_INTERVAL_MS), `evidence scans ${evidenceScans}`);
-  assert.ok(evidenceScans < PASSES / 2);
-  assert.equal(job.status, 'needs_review');
-  assert.equal(job.verifierVerdict, 'some_future_guard_verdict');
-});
-
-test('auto-resolve ladder is capped: requeue attempts stop at NEEDS_REVIEW_RESOLVE_CAP then skip', () => {
-  const j = row({ slug: '30-cap', verifierVerdict: 'x', autoFixAttempted: true });
-  const outcomes = [];
-  for (let i = 0; i < NEEDS_REVIEW_RESOLVE_CAP + 3; i++) {
-    const o = applyNeedsReviewAutoResolve(j, [j]);
-    if (!o) break;
-    outcomes.push(o);
-    if (o === 'requeued') j.status = 'needs_review';
-    if (o === 'skipped') break;
-  }
-  assert.equal(outcomes.filter((o) => o === 'requeued').length, NEEDS_REVIEW_RESOLVE_CAP);
-  assert.equal(outcomes.at(-1), 'skipped');
-});
-
-describe('evaluateBlockingParkHealth', () => {
-  const now = Date.parse('2026-09-18T20:00:00Z');
-  const parkedAgo = (ms) => [{ to: 'needs_review', at: new Date(now - ms).toISOString() }];
-  const park = (ms, o = {}) => ({ slug: '5-park', status: 'needs_review', cwd: PROJECT_CWD, verifierVerdict: 'shared_tree_reverted', statusHistory: parkedAgo(ms), ...o });
-  const dep = (slug, dependsOn) => ({ slug, status: 'pending', cwd: PROJECT_CWD, dependsOn });
-
-  test('parked past one interval with pending dependents (transitive) is non-green, naming row + count', () => {
-    const r = evaluateBlockingParkHealth([park(REVERIFY_INTERVAL_MS + 1000), dep('6-a', ['5-park']), dep('7-b', ['6-a']), dep('8-c', [])], now);
-    assert.equal(r.ok, false);
-    assert.equal(r.parks[0].slug, '5-park');
-    assert.equal(r.parks[0].dependents, 2);
-    assert.match(r.message, /5-park/);
-    assert.match(r.message, /blocking 2 pending dependent/);
-  });
-
-  test('young park, or park with no dependents, is healthy', () => {
-    assert.equal(evaluateBlockingParkHealth([park(1000), dep('6-a', ['5-park'])], now).ok, true);
-    assert.equal(evaluateBlockingParkHealth([park(REVERIFY_INTERVAL_MS * 5), dep('6-a', [])], now).ok, true);
-  });
-});