claude-code-session-manager 0.86.0 → 0.88.0

package/src/main/__tests__/scheduler-shared-tree-guard.test.cjs

@@ -16,6 +16,7 @@
 'use strict';
 
 import { test, expect, vi, afterEach } from 'vitest';
+const fs = require('node:fs');
 const scheduler = require('../scheduler.cjs');
 const { evaluateSharedTreeGuard, checkSharedTreeGuard } = scheduler;
 
@@ -210,3 +211,170 @@ test('checkSharedTreeGuard never throws when the underlying git calls reject', a
   });
   expect(result).toBeNull();
 });
+
+// --- 2026-09-12 false-positive: an untracked path that merely became
+// IGNORED during the run (a .gitignore edit) is not a revert. See the
+// evaluateSharedTreeGuard doc comment for the full incident writeup. Each
+// test below is written to FAIL against the pre-fix implementation (which
+// computed `reverted = dirtyBefore - dirtyAfter - committed` with no
+// existence/tracked-status distinction at all) and PASS after it.
+
+test('evaluateSharedTreeGuard: an untracked path that disappears from git status but STILL EXISTS on disk is nowIgnored, not reverted', () => {
+  // Pre-fix behavior: this path would land in `reverted` (dirtyBefore minus
+  // dirtyAfter minus committed, no existence check at all) — FAILS pre-fix.
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore: [{ code: '??', path: 'session-manager-operations/logs/errors-2026-09-12.jsonl' }],
+    dirtyAfter: [],
+    pathsCommittedDuringRun: ['.gitignore'],
+    existsAfter: ['session-manager-operations/logs/errors-2026-09-12.jsonl'],
+  });
+  expect(result.reverted).toEqual([]);
+  expect(result.nowIgnored).toEqual(['session-manager-operations/logs/errors-2026-09-12.jsonl']);
+});
+
+test('evaluateSharedTreeGuard: an untracked path that disappears from git status AND no longer exists on disk is still reverted', () => {
+  // Proves the fix is not a blanket "stop reporting reverted": a genuinely
+  // deleted untracked file (the guard's real purpose — catching a job that
+  // discarded uncommitted work) must still surface. If the fix had simply
+  // stopped reporting any untracked-and-missing path as reverted, this test
+  // would fail (reverted would come back empty instead of containing the
+  // path).
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore: [{ code: '??', path: 'data/scratch.txt' }],
+    dirtyAfter: [],
+    pathsCommittedDuringRun: [],
+    existsAfter: [], // file no longer exists on disk
+  });
+  expect(result.reverted).toEqual(['data/scratch.txt']);
+  expect(result.nowIgnored).toEqual([]);
+});
+
+test('evaluateSharedTreeGuard: a TRACKED path clean after the run is still reverted even though it exists on disk', () => {
+  // A tracked file leaving the dirty set means its content was restored to
+  // HEAD — exactly the discard this guard exists to catch — regardless of
+  // whether the file is still present. Pre-fix this already worked by
+  // accident (no existence check existed at all); this test pins the
+  // behavior now that existence checks exist for the untracked branch, so a
+  // future change can't accidentally start trusting `existsAfter` for
+  // tracked paths too.
+  const result = evaluateSharedTreeGuard({
+    stashBefore: [],
+    stashAfter: [],
+    dirtyBefore: [{ code: ' M', path: 'src/config.js' }],
+    dirtyAfter: [],
+    pathsCommittedDuringRun: [],
+    existsAfter: ['src/config.js'], // file exists, but content was reset to HEAD
+  });
+  expect(result.reverted).toEqual(['src/config.js']);
+  expect(result.nowIgnored).toEqual([]);
+});
+
+test('checkSharedTreeGuard end-to-end: the real 2026-09-12 incident shape — untracked logs path ignored by a committed .gitignore change, file still on disk — must NOT verdict shared_tree_reverted', async () => {
+  // PRD 1181's exact shape: a bare `logs/` pattern lands in .gitignore during
+  // the run (committed), eleven untracked log paths vanish from `git status`,
+  // and the files are untouched on disk. Pre-fix, checkSharedTreeGuard's
+  // `reverted` would contain this path (no existsAfter computation existed),
+  // driving the caller's `verdict: 'shared_tree_reverted'` downgrade — FAILS
+  // pre-fix.
+  const logPath = 'session-manager-operations/logs/errors-2026-09-12.jsonl';
+  vi.spyOn(scheduler, 'stashList').mockResolvedValue([]);
+  vi.spyOn(scheduler, 'gitHead').mockResolvedValue('sha-after');
+  vi.spyOn(scheduler, 'pathsChangedSince').mockResolvedValue(['.gitignore']);
+  vi.spyOn(scheduler, 'uncommittedChanges').mockResolvedValue([]); // the log path no longer shows up at all
+  // checkSharedTreeGuard's existence check runs concurrently via
+  // fs.promises.access (fsp === fs.promises — same object) rather than
+  // fs.existsSync, so a large untracked baseline doesn't block the event
+  // loop with hundreds of synchronous stats back-to-back.
+  vi.spyOn(fs.promises, 'access').mockImplementation((p) => (
+    String(p).includes('errors-2026-09-12.jsonl') ? Promise.resolve() : Promise.reject(new Error('ENOENT'))
+  ));
+
+  const result = await checkSharedTreeGuard({
+    cwd: '/repo',
+    stashBaseline: [],
+    dirtyBaseline: [{ code: '??', path: logPath }],
+    headBefore: 'sha-before',
+    slug: 'job-1181',
+  });
+
+  expect(result.reverted).toBeUndefined();
+  expect(result.nowIgnored).toEqual([logPath]);
+});
+
+// --- landedCommit ground truth (2026-09-18, 1229-fo-03 false positive) ---
+// Real temp git fixture, never the live repo. Baseline-dirty path `cfg.txt`
+// goes clean with no commit covering it (the shape that makes the baseline
+// diff say "reverted"); only the landedCommit ancestry decides the verdict.
+const { execFileSync } = require('node:child_process');
+const os = require('node:os');
+const nodePath = require('node:path');
+
+function gitIn(dir, ...args) {
+  return execFileSync('git', args, { cwd: dir, encoding: 'utf8' }).trim();
+}
+
+function fixtureRepo() {
+  const dir = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'shared-tree-landed-'));
+  gitIn(dir, 'init', '-q');
+  gitIn(dir, 'config', 'user.email', 't@example.com');
+  gitIn(dir, 'config', 'user.name', 'T');
+  fs.writeFileSync(nodePath.join(dir, 'cfg.txt'), 'base\n');
+  gitIn(dir, 'add', '-A');
+  gitIn(dir, 'commit', '-q', '-m', 'base');
+  const base = gitIn(dir, 'rev-parse', 'HEAD');
+  fs.writeFileSync(nodePath.join(dir, 'cfg.txt'), 'human wip\n'); // baseline-dirty
+  return { dir, base };
+}
+
+function commitPath(dir, rel, msg) {
+  fs.writeFileSync(nodePath.join(dir, rel), `${msg}\n`);
+  gitIn(dir, 'add', rel);
+  gitIn(dir, 'commit', '-q', '-m', msg);
+  return gitIn(dir, 'rev-parse', 'HEAD');
+}
+
+test('checkSharedTreeGuard: landedCommit still an ancestor of HEAD plus an unrelated later commit is NOT reverted', async () => {
+  const { dir, base } = fixtureRepo();
+  const landed = commitPath(dir, 'job.txt', 'job work');
+  gitIn(dir, 'checkout', '--', 'cfg.txt'); // baseline-dirty path goes clean, no commit covers it
+  commitPath(dir, 'later.txt', 'unrelated human commit');
+
+  const result = await checkSharedTreeGuard({
+    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
+    headBefore: base, slug: 'job-a', landedCommit: landed,
+  });
+  expect(result).toBeNull();
+});
+
+test('checkSharedTreeGuard: landedCommit absent from history still parks as reverted', async () => {
+  const { dir, base } = fixtureRepo();
+  const landed = commitPath(dir, 'job.txt', 'job work');
+  gitIn(dir, 'reset', '-q', '--hard', base); // job commit discarded
+  commitPath(dir, 'later.txt', 'unrelated human commit');
+
+  const result = await checkSharedTreeGuard({
+    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
+    headBefore: base, slug: 'job-b', landedCommit: landed,
+  });
+  expect(result).toEqual({ reverted: ['cfg.txt'] });
+});
+
+test('checkSharedTreeGuard: no landedCommit at all still parks as reverted', async () => {
+  const { dir, base } = fixtureRepo();
+  gitIn(dir, 'checkout', '--', 'cfg.txt');
+  const result = await checkSharedTreeGuard({
+    cwd: dir, stashBaseline: [], dirtyBaseline: [{ code: ' M', path: 'cfg.txt' }],
+    headBefore: base, slug: 'job-c', landedCommit: null,
+  });
+  expect(result).toEqual({ reverted: ['cfg.txt'] });
+});
+
+test('landedCommitIsAncestorOfHead: empty/unknown sha is false, never throws', async () => {
+  const { dir } = fixtureRepo();
+  expect(await scheduler.landedCommitIsAncestorOfHead(dir, '')).toBe(false);
+  expect(await scheduler.landedCommitIsAncestorOfHead(dir, 'deadbeefdeadbeef')).toBe(false);
+});

package/src/main/__tests__/scheduler-starve-escalation.test.cjs

@@ -12,21 +12,26 @@
  * Exercises selectStarveEscalations() (pure) directly, and
  * runStarveEscalationSweep() (the side-effecting wrapper) against a real,
  * scratch audit-log.jsonl and a fake attached window — matching
- * queue-starvation-per-project.test.cjs's pattern of setting HOME before
- * require() since every state path is baked from os.homedir() at load.
+ * pollLoop-dispatch-on-failure.test.cjs's pattern of setting HOME before
+ * require() (beforeAll runs AFTER module evaluation) since every state path
+ * is baked from os.homedir() at load, and restoring it in afterAll.
  *
  * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-starve-escalation.test.cjs
  */
 
 'use strict';
 
-import { test, beforeEach } from 'vitest';
+import { test, beforeEach, afterAll } from 'vitest';
 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(), 'starve-escalation-test-'));
+const originalHome = process.env.HOME;
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'starve-escalation-test-'));
+process.env.HOME = tmpHome;
+fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
+fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
 
 const {
   selectStarveEscalations,
@@ -34,7 +39,12 @@ const {
   STARVE_ESCALATION_MS,
   attachWindow,
 } = require('../scheduler.cjs');
-const { AUDIT_LOG_PATH } = require('../lib/auditLog.cjs');
+const { auditLogPath } = require('../lib/auditLog.cjs');
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
 
 const CWD_A = '/home/bilko/Projects/Bilko';
 const CWD_B = '/home/bilko/Projects/session-manager';
@@ -42,7 +52,7 @@ const CWD_B = '/home/bilko/Projects/session-manager';
 function readAuditKind(kind) {
   let lines;
   try {
-    lines = fs.readFileSync(AUDIT_LOG_PATH, 'utf8').split('\n').filter(Boolean);
+    lines = fs.readFileSync(auditLogPath(), 'utf8').split('\n').filter(Boolean);
   } catch {
     return [];
   }
@@ -65,8 +75,8 @@ function fakeWindow() {
 beforeEach(() => {
   // Fresh scratch audit log per test so escalation counts never bleed across
   // tests in this file.
-  fs.mkdirSync(path.dirname(AUDIT_LOG_PATH), { recursive: true });
-  fs.writeFileSync(AUDIT_LOG_PATH, '');
+  fs.mkdirSync(path.dirname(auditLogPath()), { recursive: true });
+  fs.writeFileSync(auditLogPath(), '');
   attachWindow(null);
 });
 

package/src/main/__tests__/scheduler-stranded-autofix-park.test.cjs

@@ -0,0 +1,245 @@
+/**
+ * scheduler-stranded-autofix-park.test.cjs — PRD "1218-fo-01 stranded
+ * auto-fix park" (2026-09-13, findings filed at session-manager-operations/
+ * reviews/2026-09-13-scheduler-stability-investigation.md, "post-run
+ * adjudication" section).
+ *
+ * spawnInvestigation restores a job's status from 'investigating' back to
+ * needs_review in ONE mutate() call (scheduler.cjs, source
+ * 'spawnInvestigation:onExit') and stamps autoFixOutcome in a SEPARATE,
+ * later mutate() call. A crash/restart between the two leaves a row with
+ * autoFixAttempted: true and autoFixOutcome permanently undefined —
+ * isExhaustedAutoFix wants autoFixRetries >= 1 (never incremented here) and
+ * isGuardParkedWithoutAutoFix wants autoFixAttempted === false, so the row
+ * falls through every resolving door and the periodic reverify pass just
+ * re-scans the same frozen transcript forever. Job 1218-fo-01 sat exactly
+ * like this with a landed commit while every dependent PRD waited.
+ *
+ * This file covers the new isStrandedAutoFixPark predicate and its wiring
+ * into isEligibleForNeedsReviewAutoResolve / selectExhaustedNeedsReviewTargets
+ * / applyNeedsReviewAutoResolve — the SAME bounded ladder the exhausted-
+ * auto-fix and guard-parked doors already use, unchanged.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — same
+ * reason as scheduler-looks-done.test.cjs (appendAuditEvent writes under
+ * $HOME/.claude/session-manager/audit-log.jsonl).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-stranded-autofix-park.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 { execFileSync } = require('node:child_process');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'stranded-autofix-park-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  isStrandedAutoFixPark,
+  isExhaustedAutoFix,
+  isGuardParkedWithoutAutoFix,
+  isEligibleForNeedsReviewAutoResolve,
+  selectExhaustedNeedsReviewTargets,
+  applyNeedsReviewAutoResolve,
+  computeLooksDone,
+  fixSlugFor,
+  NEEDS_REVIEW_RESOLVE_CAP,
+} = require('../scheduler.cjs');
+const { resolvePrdWriteDir } = require('../lib/prdLocations.cjs');
+const { bustCwdCache } = require('../lib/queueStore.cjs');
+
+const MIN_MS = 60_000;
+const THRESHOLD_MS = 30 * MIN_MS;
+
+// findPrdDir (via resolvePrdsDirs -> allProjectCwds) only discovers a PRD
+// dir under a cwd it already knows about — same registration computeLooksDone
+// needs in scheduler-looks-done.test.cjs / scheduler-guard-verdict-autoresolve.test.cjs.
+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();
+}
+
+// Replays the live 1218-fo-01 tuple: needs_review, verifierVerdict
+// transcript_errors, exitCode 0, a landed commit, autoFixAttempted true,
+// autoFixOutcome undefined, statusHistory ending in the exact
+// spawnInvestigation:onExit restore reason.
+function strandedJob(overrides = {}) {
+  return {
+    slug: '1218-fo-01-move-scripts-lib-into-src-main-lib',
+    cwd: '/home/user/project',
+    status: 'needs_review',
+    exitCode: 0,
+    verifierVerdict: 'transcript_errors',
+    landedCommit: 'd1edf15babc1234',
+    autoFixAttempted: true,
+    statusHistory: [
+      { to: 'needs_review', at: new Date(Date.now() - 45 * MIN_MS).toISOString() },
+      { to: 'investigating', at: new Date(Date.now() - 40 * MIN_MS).toISOString(), reason: 'spawning investigation probe' },
+      {
+        to: 'needs_review',
+        at: new Date(Date.now() - 35 * MIN_MS).toISOString(),
+        reason: 'investigation probe exited — restoring prior status',
+      },
+    ],
+    ...overrides,
+  };
+}
+
+// --- isStrandedAutoFixPark ---
+
+test('the 1218 tuple (autoFixAttempted true, autoFixOutcome undefined, no child row) is a stranded auto-fix park', () => {
+  const job = strandedJob();
+  assert.equal(isStrandedAutoFixPark(job, [job]), true);
+  assert.equal(isExhaustedAutoFix(job), false, 'never accumulated a retry — must not double-count as exhausted');
+  assert.equal(isGuardParkedWithoutAutoFix(job), false, 'autoFixAttempted is true — the guard-parked door requires false');
+});
+
+test('autoFixOutcome "error" or "no-plan" with an unspent retry is NOT stranded — selectAutoFixTargets still owns it', () => {
+  // Durably stamped (unlike the 1218 tuple's permanently-unset outcome), so
+  // its one bounded retry (autoFixRetries < 1) is still selectAutoFixTargets's
+  // to spend — pulling it into this ladder instead would race it away from
+  // that retry (see scheduler-needs-review-autoresolve.test.cjs's "a
+  // non-exhausted needs_review row … is left alone").
+  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'error' }), []), false);
+  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'no-plan' }), []), false);
+});
+
+test('autoFixOutcome "plan" is never a stranded park — that is isPlanUnqueued/isFixPlanDead territory', () => {
+  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixOutcome: 'plan' }), []), false);
+});
+
+test('a row that never attempted auto-fix at all is not a stranded park', () => {
+  assert.equal(isStrandedAutoFixPark(strandedJob({ autoFixAttempted: undefined }), []), false);
+});
+
+test('a row not in needs_review is never a stranded park, whatever its autoFix* fields say', () => {
+  assert.equal(isStrandedAutoFixPark(strandedJob({ status: 'failed' }), []), false);
+});
+
+test('a live fix-plan child (running) means there IS something in flight — not stranded', () => {
+  const job = strandedJob();
+  const child = { slug: fixSlugFor(job), status: 'running' };
+  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
+});
+
+test('a row with a live investigating status (the fix-plan child mid-probe) is NOT selected', () => {
+  const job = strandedJob();
+  const child = { slug: fixSlugFor(job), status: 'investigating' };
+  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
+  assert.equal(selectExhaustedNeedsReviewTargets([job, child], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a queued (pending) fix-plan child also blocks the stranded-park door', () => {
+  const job = strandedJob();
+  const child = { slug: fixSlugFor(job), status: 'pending' };
+  assert.equal(isStrandedAutoFixPark(job, [job, child]), false);
+});
+
+test('a DEAD fix-plan child (needs_review/failed/quarantined/skipped) does not block it — nothing left to wait on', () => {
+  const job = strandedJob();
+  for (const deadStatus of ['needs_review', 'failed', 'quarantined', 'skipped']) {
+    const child = { slug: fixSlugFor(job), status: deadStatus };
+    assert.equal(isStrandedAutoFixPark(job, [job, child]), true, `child status ${deadStatus} must not block`);
+  }
+});
+
+test('a COMPLETED fix-plan child does not block it either', () => {
+  const job = strandedJob();
+  const child = { slug: fixSlugFor(job), status: 'completed' };
+  assert.equal(isStrandedAutoFixPark(job, [job, child]), true);
+});
+
+test('isEligibleForNeedsReviewAutoResolve admits the stranded-park door alongside the other two', () => {
+  const job = strandedJob();
+  assert.equal(isEligibleForNeedsReviewAutoResolve(job, [job]), true);
+});
+
+// --- selectExhaustedNeedsReviewTargets: age-gated selection ---
+
+test('a fresh stranded park (under threshold) is not selected', () => {
+  const job = strandedJob({
+    statusHistory: [
+      { to: 'needs_review', at: new Date(Date.now() - 2 * MIN_MS).toISOString(), reason: 'investigation probe exited — restoring prior status' },
+    ],
+  });
+  assert.equal(selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS).length, 0);
+});
+
+test('a stranded park past NEEDS_REVIEW_RESOLVE_MS, under the cap, IS selected', () => {
+  const job = strandedJob();
+  const found = selectExhaustedNeedsReviewTargets([job], Date.now(), THRESHOLD_MS);
+  assert.equal(found.length, 1);
+  assert.equal(found[0].slug, job.slug);
+});
+
+// --- applyNeedsReviewAutoResolve: same bounded ladder, entered via the new door ---
+
+test('computeLooksDone evidence completes the stranded row via the existing looksDone branch', async () => {
+  const projectCwd = fs.mkdtempSync(path.join(tmpHome, 'proj-stranded-'));
+  fs.mkdirSync(projectCwd, { recursive: true });
+  const git = (args) => execFileSync('git', args, { cwd: projectCwd, encoding: 'utf8' });
+  git(['init', '-q']);
+  git(['config', 'user.email', 'test@example.com']);
+  git(['config', 'user.name', 'Test']);
+  fs.writeFileSync(path.join(projectCwd, 'README.md'), 'hello\n');
+  git(['add', '-A']);
+  git(['commit', '-q', '-m', 'initial']);
+  registerActiveProject(projectCwd, path.basename(projectCwd));
+
+  const dir = resolvePrdWriteDir(projectCwd);
+  fs.mkdirSync(dir, { recursive: true });
+  const slug = '1218-fo-01-move-scripts-lib-into-src-main-lib';
+  fs.writeFileSync(
+    path.join(dir, `${slug}.md`),
+    `---\ntitle: Test PRD\ncwd: ${projectCwd}\nestimateMinutes: 30\n---\n# Implementation notes\nEdit \`src/thing.js\`.\n`,
+  );
+
+  const startedAt = new Date(Date.now() - 60 * MIN_MS).toISOString();
+  await new Promise((r) => setTimeout(r, 1100)); // git --since has 1s resolution
+  fs.mkdirSync(path.join(projectCwd, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(projectCwd, 'src', 'thing.js'), 'module.exports = {};\n');
+  git(['add', '-A']);
+  git(['commit', '-q', '-m', `the actual fix for ${slug} landed`]);
+
+  const job = strandedJob({ slug, cwd: projectCwd, startedAt });
+  assert.equal(isStrandedAutoFixPark(job, [job]), true);
+
+  const looksDone = await computeLooksDone(job);
+  assert.ok(looksDone, 'expected computeLooksDone to find the attributable commit');
+  job.looksDone = looksDone;
+
+  const outcome = applyNeedsReviewAutoResolve(job, [job]);
+  assert.equal(outcome, 'completed');
+  assert.equal(job.status, 'completed');
+});
+
+test('with no completion evidence yet, the stranded row gets one bounded requeue, same cap/logic as the other doors', () => {
+  const job = strandedJob({ exhaustedResolveAttempts: 0 });
+  assert.equal(job.looksDone, undefined);
+  const outcome = applyNeedsReviewAutoResolve(job, [job]);
+  assert.equal(outcome, 'requeued');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.exhaustedResolveAttempts, 1);
+});
+
+test('once the cap is spent, the stranded row auto-skips like every other door', () => {
+  const job = strandedJob({ exhaustedResolveAttempts: NEEDS_REVIEW_RESOLVE_CAP });
+  const outcome = applyNeedsReviewAutoResolve(job, [job]);
+  assert.equal(outcome, 'skipped');
+  assert.equal(job.status, 'skipped');
+  assert.equal(job.needsReviewAutoResolvedSkip, true);
+});
+
+test('a live fix-plan child also blocks applyNeedsReviewAutoResolve, not just selection', () => {
+  const job = strandedJob();
+  const child = { slug: fixSlugFor(job), status: 'running' };
+  const outcome = applyNeedsReviewAutoResolve(job, [job, child]);
+  assert.equal(outcome, null, 'nothing to resolve while the fix-plan child is still live');
+  assert.equal(job.status, 'needs_review', 'must stay parked while the child is in flight');
+});

package/src/main/__tests__/scheduler-supervisor-record.test.cjs

@@ -0,0 +1,81 @@
+/**
+ * scheduler-supervisor-record.test.cjs — executeJob writes
+ * <runDir>/<slug>.supervisor.json synchronously at the `spawned pid=` point,
+ * i.e. before the child's first output and before onPid's mutate runs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-supervisor-record.test.cjs
+ */
+'use strict';
+
+import { test, expect, beforeAll, afterAll, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let executeJob;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-supervisor-rec-'));
+  process.env.HOME = tmpHome;
+  ({ executeJob } = require('../scheduler.cjs'));
+});
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+afterEach(() => { delete process.env.SM_CLAUDE_BIN; });
+
+function writeSlowStub() {
+  const stubPath = path.join(os.tmpdir(), `sm-sup-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  const body = `
+    setTimeout(() => {
+      process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
+      process.exit(0);
+    }, 500);
+  `;
+  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
+  return stubPath;
+}
+
+test('the supervisor record exists by the time onPid fires, before the child prints anything', async () => {
+  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-sup-main-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-sup-wt-'));
+  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
+  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-sup-run-'));
+  try {
+    const slug = `sup-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+    const prdsDir = path.join(mainCwd, 'session-manager-operations', 'scheduler', 'prds');
+    fs.mkdirSync(prdsDir, { recursive: true });
+    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'body', 'utf8');
+    process.env.SM_CLAUDE_BIN = writeSlowStub();
+
+    const seen = {};
+    const result = await executeJob({ slug, cwd: mainCwd }, runDir, mainCwd, (pid) => {
+      const file = path.join(runDir, `${slug}.supervisor.json`);
+      seen.exists = fs.existsSync(file);
+      seen.record = seen.exists ? JSON.parse(fs.readFileSync(file, 'utf8')) : null;
+      seen.pid = pid;
+      seen.logHasOutput = fs.readFileSync(path.join(runDir, `${slug}.log`), 'utf8').includes('"type":"result"');
+      seen.metaExists = fs.existsSync(path.join(runDir, `${slug}.meta.json`));
+      return Promise.resolve();
+    }, worktreeCwd);
+
+    expect(result.exitCode).toBe(0);
+    expect(seen.exists).toBe(true);
+    expect(seen.logHasOutput).toBe(false);
+    expect(seen.metaExists).toBe(false);
+    expect(seen.record).toMatchObject({
+      kind: 'job', slug, cwd: mainCwd, runId: path.basename(runDir), pid: seen.pid, pgid: seen.pid,
+      execCwd: worktreeCwd, worktreeDir: worktreeCwd, worktreeBranch: `sm-job/${slug}`, schedulerPid: process.pid,
+    });
+    expect(typeof seen.record.startedAt).toBe('number');
+    expect(seen.record.idleKillMs).toBeGreaterThan(0);
+  } finally {
+    fs.rmSync(mainCwd, { recursive: true, force: true });
+    fs.rmSync(worktreeCwd, { recursive: true, force: true });
+    fs.rmSync(runDir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/scheduler-tick-cancel-token.test.cjs

@@ -8,12 +8,12 @@
  * subsequent tickQueue() call short-circuited on the stale flag forever,
  * even though queue.json's `paused` field was correctly null.
  *
- * Run: timeout 120 node --test src/main/__tests__/scheduler-tick-cancel-token.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-tick-cancel-token.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const { applyPauseCleared, pickNextBatch } = require('../scheduler.cjs');