claude-code-session-manager 0.86.0 → 0.87.0

package/src/main/__tests__/scheduleJobTransitions.test.cjs

@@ -6,7 +6,7 @@
  */
 'use strict';
 
-import { test, expect } from 'vitest';
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
 const fs = require('node:fs');
 const crypto = require('node:crypto');
 const {
@@ -17,6 +17,7 @@ const {
   _resetRefusedTransitionCountForTests,
 } = require('../lib/scheduleJobTransitions.cjs');
 const auditLog = require('../lib/auditLog.cjs');
+const queueHistory = require('../lib/queueHistory.cjs');
 
 function uniqueSlug(label) {
   return `test-${label}-${crypto.randomUUID().slice(0, 8)}`;
@@ -175,3 +176,102 @@ test('_resetRefusedTransitionCountForTests resets the counter', () => {
   _resetRefusedTransitionCountForTests();
   expect(getRefusedTransitionCount()).toBe(0);
 });
+
+// ---------- needs_review ledger (PRD: needs_review durability) ----------
+//
+// transitionJob is the ONE place every needs_review entry/resolution is
+// decided (this file's own header comment) — these tests exercise that
+// hook directly rather than going through scheduler.cjs's many call sites.
+// queueHistory.appendHistory is mocked so these tests never touch disk or
+// race its own fire-and-forget promise; queueHistory.test.cjs already
+// covers appendHistory's real I/O.
+
+let appendHistorySpy;
+
+beforeEach(() => {
+  appendHistorySpy = vi.spyOn(queueHistory, 'appendHistory').mockResolvedValue({ appended: 1 });
+});
+
+afterEach(() => {
+  appendHistorySpy.mockRestore();
+});
+
+test('needs_review entry: transitioning INTO needs_review appends a kind:needs_review_entry ledger line', () => {
+  const slug = uniqueSlug('nr-entry');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-abc', verifierVerdict: 'uncommitted_changes' };
+
+  transitionJob(job, 'needs_review', { reason: 'finish protocol incomplete', source: 'spawnJob:finalize' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(1);
+  const [lines] = appendHistorySpy.mock.calls[0];
+  expect(lines).toHaveLength(1);
+  expect(lines[0]).toMatchObject({
+    kind: 'needs_review_entry',
+    slug,
+    cwd: '/tmp/proj',
+    runId: 'run-abc',
+    reason: 'uncommitted_changes',
+    source: 'spawnJob:finalize',
+  });
+  expect(typeof lines[0].at).toBe('string');
+  // Episode bookkeeping stamped on the job so a later resolution can
+  // reference this SAME runId even if job.runId is reassigned meanwhile.
+  expect(job.needsReviewEntryRunId).toBe('run-abc');
+  expect(job.needsReviewEnteredAt).toBe(lines[0].at);
+});
+
+test('needs_review resolution: transitioning OUT of needs_review appends a paired line referencing the ENTRY runId, with dwellMs', () => {
+  const slug = uniqueSlug('nr-resolve');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-1' };
+
+  transitionJob(job, 'needs_review', { reason: 'park', source: 'spawnJob:finalize' });
+  const enteredAt = job.needsReviewEnteredAt;
+
+  // A resume-recovery re-dispatch (or any later attempt) mints a FRESH runId
+  // before this episode resolves — the resolution must still reference the
+  // ENTRY's runId, not whatever the job carries now.
+  job.runId = 'run-2';
+  transitionJob(job, 'completed', { reason: 'boot reverify: stale needs_review healed', source: 'reverifyNeedsReview:heal' });
+
+  expect(appendHistorySpy).toHaveBeenCalledTimes(2);
+  const [resolutionLines] = appendHistorySpy.mock.calls[1];
+  expect(resolutionLines).toHaveLength(1);
+  const resolution = resolutionLines[0];
+  expect(resolution.kind).toBe('needs_review_resolution');
+  expect(resolution.runId).toBe('run-1'); // the ENTRY's runId
+  expect(resolution.resolvedTo).toBe('completed');
+  expect(resolution.ladderRung).toBe('reverify');
+  expect(typeof resolution.dwellMs).toBe('number');
+  expect(resolution.dwellMs).toBeGreaterThanOrEqual(0);
+  expect(Date.parse(enteredAt) + resolution.dwellMs).toBe(Date.parse(resolution.at));
+
+  // Episode bookkeeping cleared once resolved.
+  expect(job.needsReviewEntryRunId).toBeUndefined();
+  expect(job.needsReviewEnteredAt).toBeUndefined();
+});
+
+test('a slug that parks twice produces two independent entry/resolution pairs, not one merged episode', () => {
+  const { reduceNeedsReviewLedger } = require('../lib/needsReviewLedger.cjs');
+  const slug = uniqueSlug('nr-twice');
+  const job = { slug, cwd: '/tmp/proj', status: 'running', runId: 'run-A' };
+
+  transitionJob(job, 'needs_review', { reason: 'park 1', source: 'spawnJob:finalize' });
+  transitionJob(job, 'pending', { reason: 'manual reset', source: 'ipc:schedule:reset-job' });
+  transitionJob(job, 'running', { reason: 'redispatched', source: 'spawnJob:dispatch' });
+  job.runId = 'run-B';
+  transitionJob(job, 'needs_review', { reason: 'park 2', source: 'spawnJob:finalize' });
+  transitionJob(job, 'completed', { reason: 'healed', source: 'reverifyNeedsReview:heal' });
+
+  const ledgerLines = appendHistorySpy.mock.calls.map((call) => call[0][0]);
+  const entries = ledgerLines.filter((l) => l.kind === 'needs_review_entry');
+  const resolutions = ledgerLines.filter((l) => l.kind === 'needs_review_resolution');
+  expect(entries).toHaveLength(2);
+  expect(resolutions).toHaveLength(2);
+  expect(entries.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+  expect(resolutions.map((l) => l.runId).sort()).toEqual(['run-A', 'run-B']);
+
+  const rollup = reduceNeedsReviewLedger(ledgerLines);
+  expect(rollup.unresolvedCount).toBe(0);
+  expect(rollup.byLadderRung['manual-reset']).toBe(1);
+  expect(rollup.byLadderRung['reverify']).toBe(1);
+});

package/src/main/__tests__/scheduler-boot-orphans.test.cjs

@@ -2,7 +2,7 @@
  * scheduler-boot-orphans.test.cjs — boot-time reconciliation of 'running' jobs
  * left behind by an app crash/restart (PRD 686: consolidated in from the
  * external watchdog's reconcileQueueOffline(), which is now deleted from
- * scripts/lib/watchdogHelpers.cjs).
+ * src/main/lib/watchdogHelpers.cjs).
  *
  * Covers the two behaviors most likely to drift in the move:
  *   - a still-alive orphaned pid must be DEFERRED, never classified from its
@@ -101,7 +101,7 @@ test('feedbackSweepDue gates on the tick interval, not every tick', () => {
 });
 
 test('scheduler.cjs reuses watchdogHelpers.sweep verbatim (no forked copy)', () => {
-  const { sweep } = require('../../../scripts/lib/watchdogHelpers.cjs');
+  const { sweep } = require('../lib/watchdogHelpers.cjs');
   assert.equal(sweepFeedback, sweep, 'scheduler.cjs must import the same sweep function, not reimplement it');
 });
 

package/src/main/__tests__/scheduler-broadcast-reconcile.test.cjs

@@ -0,0 +1,121 @@
+/**
+ * scheduler-broadcast-reconcile.test.cjs — broadcast() used to do its own bare
+ * `readQueue() -> reconcile(state) -> writeQueue(state)` BEFORE ever touching
+ * the broadcastCoalescer, so a burst of N broadcast() calls inside one
+ * BROADCAST_COALESCE_MS window cost N full reconcile passes + N queue writes
+ * to produce ONE coalesced payload — and did so outside mutate()'s lock, so a
+ * concurrent mutation's update could be lost. The fix moves the
+ * reconcile+write pair inside the coalescer's `getPayload`, run through
+ * `mutate()`, so N broadcast() calls in one window cost exactly one reconcile
+ * and one write.
+ *
+ * `reconcile` is a bare local call inside getPayload's mutate() callback, so
+ * — matching this file's existing testable-seam convention (module.exports.
+ * stashList / evaluateSharedTreeGuard / committedInWindow) — it is invoked as
+ * `module.exports.reconcile(state)` specifically so tests can spy on it here.
+ * `queueStore.readMerged`/`writeSplit` are genuine cross-module property
+ * calls already, so they're spied on directly with no source change needed.
+ *
+ * HOME-isolated (mirrors reconcileFlatPrdSweep.test.cjs): stub HOME to a
+ * mkdtemp dir before requiring scheduler.cjs so `ensureDirs()` (called by the
+ * real `writeQueue()` wrapper before the now-mocked `queueStore.writeSplit`)
+ * never touches the real machine.
+ *
+ * Run: timeout 60 npx vitest run src/main/__tests__/scheduler-broadcast-reconcile.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeAll, afterAll, beforeEach, 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-broadcast-reconcile-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 fakeWindow() {
+  return {
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, isCrashed: () => false, send: vi.fn() },
+  };
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  scheduler.attachWindow(null);
+});
+
+test('10 broadcast() calls inside one coalesce window trigger exactly one reconcile and one queue write', async () => {
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
+
+  for (let i = 0; i < 10; i += 1) scheduler.broadcast();
+
+  // BROADCAST_COALESCE_MS is 200ms; give the trailing-edge timer room to fire.
+  await wait(400);
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(1);
+  expect(writeSpy).toHaveBeenCalledTimes(1);
+});
+
+test('a window-less (flush) broadcast() still reconciles, even with no window attached', async () => {
+  scheduler.attachWindow(null);
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  const writeSpy = vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile').mockResolvedValue(undefined);
+
+  await scheduler.broadcast({ flush: true });
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(1);
+  expect(writeSpy).toHaveBeenCalledTimes(1);
+});
+
+test('a reconcile() that throws does not wedge the coalescer — the next broadcast() still sends', async () => {
+  const win = fakeWindow();
+  scheduler.attachWindow(win);
+  vi.spyOn(queueStore, 'readMerged').mockImplementation(async () => freshState());
+  vi.spyOn(queueStore, 'writeSplit').mockResolvedValue(undefined);
+  const reconcileSpy = vi.spyOn(scheduler, 'reconcile')
+    .mockRejectedValueOnce(new Error('boom'))
+    .mockResolvedValue(undefined);
+
+  scheduler.broadcast();
+  await wait(400);
+  expect(win.webContents.send).not.toHaveBeenCalled();
+
+  scheduler.broadcast();
+  await wait(400);
+
+  expect(reconcileSpy).toHaveBeenCalledTimes(2);
+  expect(win.webContents.send).toHaveBeenCalledTimes(1);
+  expect(win.webContents.send).toHaveBeenCalledWith('schedule:state', expect.any(Object));
+});

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

@@ -0,0 +1,43 @@
+'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-guard-verdict-autoresolve.test.cjs

@@ -0,0 +1,344 @@
+/**
+ * scheduler-guard-verdict-autoresolve.test.cjs — needs_review ladder gap
+ * (2026-09-12, PRD 1181 shape).
+ *
+ * Auto-fix investigations only ever launch for FAILING runs — a job that
+ * exits 0 and gets parked by a post-run GUARD verdict (commit-guard
+ * 'silent_no_op', shared-tree-guard 'shared_tree_reverted') never has
+ * job.autoFixAttempted set, so isExhaustedAutoFix(job) is false forever and
+ * the row is invisible to the existing needs_review auto-resolve ladder —
+ * it sits in needs_review permanently, blocking every dependsOn row behind
+ * it, until a human clears it by hand. PRD 1181 proved it: exit 0, commit
+ * aff5607 landed, parked on a guard verdict, needed a human.
+ *
+ * This file covers the widened entry gate (isGuardParkedWithoutAutoFix /
+ * isEligibleForNeedsReviewAutoResolve) that admits these rows to the SAME
+ * ladder (selectExhaustedNeedsReviewTargets / applyNeedsReviewAutoResolve)
+ * the exhausted-auto-fix path already uses, keyed on landedCommit +
+ * looksDone evidence instead of a spent auto-fix attempt — and the closed
+ * set of verdicts eligible for this (GUARD_VERDICT_EVIDENCE_ELIGIBLE)
+ * excludes 'worktree_integration_failed', whose damage IS a commit (one
+ * stranded on an unmerged branch), so a landedCommit there is not evidence
+ * against the verdict.
+ *
+ * scheduler-needs-review-autoresolve.test.cjs's own suite covers the
+ * pre-existing exhausted-auto-fix ladder and must keep passing UNCHANGED —
+ * this file only adds new coverage for the second door into the same ladder.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-needs-review-autoresolve.test.cjs (appendAuditEvent
+ * writes under $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-guard-verdict-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(), 'guard-verdict-autoresolve-test-'));
+process.env.HOME = tmpHome;
+
+const { execFileSync } = require('node:child_process');
+
+const {
+  selectExhaustedNeedsReviewTargets,
+  applyNeedsReviewAutoResolve,
+  NEEDS_REVIEW_RESOLVE_CAP,
+  GUARD_VERDICT_EVIDENCE_ELIGIBLE,
+  isGuardParkedWithoutAutoFix,
+  isEligibleForNeedsReviewAutoResolve,
+  isExhaustedAutoFix,
+  reverifyNeedsReview,
+} = require('../scheduler.cjs');
+
+const { pickForProject } = require('../lib/schedulerBatch.cjs');
+const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
+const { bustCwdCache } = require('../lib/queueStore.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 30 * MIN_MS;
+
+function guardParkedJob(overrides = {}) {
+  return {
+    slug: '1181-guard-parked-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    exitCode: 0,
+    verifierVerdict: 'silent_no_op',
+    landedCommit: 'aff5607abc123',
+    statusHistory: [{ to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() }],
+    ...overrides,
+  };
+}
+
+// --- enumeration: which guard verdicts are eligible ---
+
+test('GUARD_VERDICT_EVIDENCE_ELIGIBLE contains exactly the benign guard verdicts, never worktree_integration_failed', () => {
+  assert.ok(GUARD_VERDICT_EVIDENCE_ELIGIBLE.has('silent_no_op'));
+  assert.ok(GUARD_VERDICT_EVIDENCE_ELIGIBLE.has('shared_tree_reverted'));
+  assert.equal(GUARD_VERDICT_EVIDENCE_ELIGIBLE.has('worktree_integration_failed'), false);
+});
+
+// --- isGuardParkedWithoutAutoFix / isEligibleForNeedsReviewAutoResolve ---
+
+test('a guard-verdict park with no auto-fix history is guard-parked-without-autofix', () => {
+  const job = guardParkedJob();
+  assert.equal(isGuardParkedWithoutAutoFix(job), true);
+  assert.equal(isExhaustedAutoFix(job), false, 'never went through auto-fix — must not double-count as exhausted');
+  assert.equal(isEligibleForNeedsReviewAutoResolve(job), true);
+});
+
+test('a row that DID get an auto-fix investigation is left to the exhausted-auto-fix door, not this one', () => {
+  const job = guardParkedJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan', autoFixRetries: 1 });
+  assert.equal(isGuardParkedWithoutAutoFix(job), false);
+  assert.equal(isExhaustedAutoFix(job), true);
+  assert.equal(isEligibleForNeedsReviewAutoResolve(job), true, 'still eligible overall, via the OTHER door');
+});
+
+test('(c) worktree_integration_failed is never guard-parked-without-autofix, whatever evidence it carries', () => {
+  const job = guardParkedJob({ verifierVerdict: 'worktree_integration_failed' });
+  assert.equal(isGuardParkedWithoutAutoFix(job), false);
+  assert.equal(isEligibleForNeedsReviewAutoResolve(job), false);
+});
+
+test('a needs_review row with an unrecognized verifierVerdict and no auto-fix history is not eligible', () => {
+  const job = guardParkedJob({ verifierVerdict: 'transcript_errors' });
+  assert.equal(isGuardParkedWithoutAutoFix(job), false);
+  assert.equal(isEligibleForNeedsReviewAutoResolve(job), false);
+});
+
+// --- selectExhaustedNeedsReviewTargets: the widened selector ---
+
+test('a fresh guard-parked row (under threshold) is not selected', () => {
+  const job = guardParkedJob({
+    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 guard-parked row past threshold, under the cap, is selected', () => {
+  const job = guardParkedJob();
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, '1181-guard-parked-row');
+});
+
+test('(c) worktree_integration_failed is never selected, even past threshold with a landedCommit', () => {
+  const job = guardParkedJob({ verifierVerdict: 'worktree_integration_failed' });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+// --- applyNeedsReviewAutoResolve: the three-branch policy, entered via the guard door ---
+
+test('(a) the 1181 shape — exit 0 + guard verdict + landedCommit + looksDone — auto-completes', () => {
+  const job = guardParkedJob({
+    looksDone: { commits: ['aff5607'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
+  });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'completed');
+  assert.equal(job.status, 'completed');
+  assert.match(job.statusHistory.at(-1).reason, /silent_no_op/, 'the reason must name the evidence, not just "auto-resolved"');
+});
+
+test('(b) the same shape WITHOUT looksDone does not auto-complete on the first pass — bounded requeue instead', () => {
+  const job = guardParkedJob({ exhaustedResolveAttempts: 0 });
+  assert.equal(job.looksDone, undefined);
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 1);
+  assert.match(job.statusHistory.at(-1).reason, /silent_no_op/);
+});
+
+test('a guard-parked row with no evidence, cap spent, auto-skips with the guard verdict named in job.error', () => {
+  const job = guardParkedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+  assert.equal(job.needsReviewAutoResolvedSkip, true);
+  assert.match(job.error, /silent_no_op/, 'a human reading the queue must see WHY, not a generic auto-resolved label');
+  assert.doesNotMatch(job.error, /exhausted auto-fix path/, 'this row never went through auto-fix — must not claim it did');
+});
+
+test('(c) worktree_integration_failed never auto-completes on landed-commit + looksDone evidence', () => {
+  const job = guardParkedJob({
+    verifierVerdict: 'worktree_integration_failed',
+    looksDone: { commits: ['aff5607'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
+  });
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, null, 'this verdict has no door into this ladder at all');
+  assert.equal(job.status, 'needs_review', 'must stay parked — its own mechanical-recovery path owns this verdict, not this ladder');
+});
+
+test('the pre-existing exhausted-auto-fix ladder is unaffected: same branch, same cap, same audit shape', () => {
+  const job = {
+    slug: 'exhausted-row',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    autoFixAttempted: true,
+    autoFixOutcome: 'no-plan',
+    autoFixRetries: 1,
+    exhaustedResolveAttempts: 1,
+    looksDone: { commits: ['abc1234'], paths: ['src/main/scheduler.cjs'], detectedAt: new Date().toISOString() },
+  };
+  const outcome = applyNeedsReviewAutoResolve(job);
+  assert.equal(outcome, 'completed');
+  assert.match(job.statusHistory.at(-1).reason, /verifier annotation shows work landed/);
+});
+
+// --- (d) chain drain: a downstream dependsOn row becomes eligible once the guard-parked blocker resolves ---
+
+test('(d) a dependsOn chain drains once a guard-parked blocker (no auto-fix, no evidence, cap spent) auto-skips', () => {
+  const now = Date.now();
+  const rowA = { slug: 'a-first', cwd: '/home/user/project', status: 'completed' };
+  const rowB = guardParkedJob({
+    slug: 'b-middle',
+    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];
+
+  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');
+
+  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');
+});
+
+// --- end-to-end: reverifyNeedsReview computes looksDone for a guard-parked row ---
+
+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, 'README.md'), 'hello\n', 'utf8');
+  git(['add', '-A'], dir);
+  git(['commit', '-q', '-m', 'initial'], dir);
+}
+
+function commitFile(dir, relPath, content, message) {
+  const abs = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content);
+  git(['add', relPath], dir);
+  git(['commit', '-q', '-m', message], dir);
+}
+
+function registerActiveProject(cwd, slug) {
+  const slugDir = path.join(tmpHome, '.claude', 'projects', slug);
+  fs.mkdirSync(slugDir, { recursive: true });
+  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+  bustCwdCache();
+}
+
+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 writePrd(cwd, slug, body) {
+  const dir = resolvePrdWriteDir(cwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const text = `---\ntitle: Test PRD\ncwd: ${cwd}\nestimateMinutes: 30\n---\n${body}\n`;
+  fs.writeFileSync(path.join(dir, `${slug}.md`), text);
+}
+
+async function wait(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+test('reverifyNeedsReview computes looksDone for a guard-parked (silent_no_op) row with no auto-fix history', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-guard-parked');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-guard-parked-slug');
+  writePrd(projectCwd, '1181-guard-parked', [
+    '# Implementation notes',
+    'Edit `src/thing.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '1181-guard-parked',
+      status: 'needs_review',
+      cwd: projectCwd,
+      runId: 'run-1181',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      exitCode: 0,
+      verifierVerdict: 'silent_no_op',
+      landedCommit: 'deadbeef',
+      error: 'commit-guard: made no commit on an already-clean tree',
+    },
+  ]);
+
+  await wait(1100); // git --since has 1s resolution
+  // Must be attributable to THIS job (see attributeLandedCommits) — path
+  // overlap alone is no longer evidence. The row's own `landedCommit`
+  // ('deadbeef') is a stale/unresolvable placeholder, so this falls to the
+  // 'slug trailer' rule by naming the job's own slug in the commit message.
+  commitFile(projectCwd, 'src/thing.js', 'hello', 'the actual fix for 1181-guard-parked landed');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].status, 'needs_review', 'looksDone alone never auto-completes — only applyNeedsReviewAutoResolve does');
+  assert.ok(jobs[0].looksDone, 'expected a looksDone annotation computed for this guard-parked row');
+  assert.equal(jobs[0].looksDone.commits.length, 1);
+  assert.equal(jobs[0].looksDone.rule, 'slug trailer');
+});
+
+test('reverifyNeedsReview never computes looksDone for a worktree_integration_failed row', async () => {
+  const projectCwd = path.join(tmpHome, 'proj-stranded-branch');
+  initRepo(projectCwd);
+  registerActiveProject(projectCwd, 'proj-stranded-branch-slug');
+  writePrd(projectCwd, '1181-stranded', [
+    '# Implementation notes',
+    'Edit `src/thing.js`.',
+  ].join('\n'));
+
+  const startedAt = new Date().toISOString();
+  const queuePath = writeProjectQueue(projectCwd, [
+    {
+      slug: '1181-stranded',
+      status: 'needs_review',
+      cwd: projectCwd,
+      runId: 'run-stranded',
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      exitCode: 0,
+      verifierVerdict: 'worktree_integration_failed',
+      landedCommit: 'deadbeef',
+      error: 'worktree branch integration failed',
+    },
+  ]);
+
+  await wait(1100);
+  commitFile(projectCwd, 'src/thing.js', 'hello', 'unrelated later commit');
+
+  await reverifyNeedsReview();
+
+  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
+  assert.equal(jobs.length, 1);
+  assert.equal(jobs[0].looksDone, undefined, 'a stranded-branch verdict must never be treated as evidence-gatherable');
+  assert.equal(jobs[0].status, 'needs_review');
+});