claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-periodic-reverify-guard.test.cjs

@@ -1,217 +0,0 @@
-/**
- * scheduler-periodic-reverify-guard.test.cjs
- *
- * The 10-minute periodic tick cheap-guards reverifyNeedsReview() so the log
- * scan only runs when the queue actually holds something rescannable. That
- * guard was hand-written as `jobs.some(j => j.status === 'needs_review')`
- * while PRD 1102 widened isRescanCandidate to also accept an unverified-
- * shaped `failed` row — so reverifyNeedsReview's failed → needs_review
- * looksDone branch was unreachable from the periodic path on any queue with
- * zero needs_review rows. A failed row with no run log stayed wedged for five
- * days (reported 2026-09-10 from social-signals-trader); only an app restart,
- * via the unguarded boot call, could reach it.
- *
- * These tests pin the guard to isRescanCandidate so the two cannot drift again.
- *
- * Reopened 2026-09-12 through a different door (starry-night-ships
- * 231-saturn-record-and-docs / 243-neptune-kurama-mode): the guard also gates
- * reverifyNeedsReview's auto-fix loop, not just its re-verification arm, but
- * only checked isRescanCandidate — so a needs_review row whose mechanical
- * recovery already ran and failed (verdict 'worktree_integration_failed',
- * mechanicalRecoveryAttempted: true — not itself a RESCANNABLE_VERDICTS
- * member) never got a chance at the next rung (a fix-plan investigation via
- * selectAutoFixTargets). The guard is now widened to OR in every live target
- * of the recovery ladder the periodic pass actually drives
- * (selectMechanicalRecoveryTarget / selectResumeRecoveryTarget /
- * selectAutoFixTargets).
- *
- * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs — see
- * scheduler-reap-dead-running-jobs.test.cjs's comment for why.
- *
- * Run: timeout 180 npx vitest run src/main/__tests__/scheduler-periodic-reverify-guard.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(), 'reverify-guard-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  shouldRunPeriodicReverify,
-  isRescanCandidate,
-  selectAutoFixTargets,
-  selectMechanicalRecoveryTarget,
-} = require('../scheduler.cjs');
-
-function writeRunLog(runId, slug, lines) {
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(path.join(runDir, `${slug}.log`), lines.join('\n') + '\n');
-}
-
-test('a lone unverified-shaped failed row (no needs_review sibling) fires the periodic pass', () => {
-  writeRunLog('run-guard-1', '4056-outcome-stats', ['[scheduler] starting 4056-outcome-stats']); // no result event
-  const jobs = [
-    { slug: '4059-chores-status', status: 'running', runId: 'run-guard-running' },
-    {
-      slug: '4056-outcome-stats',
-      status: 'failed',
-      runId: 'run-guard-1',
-      error: 'reaped: no runtime.pid recorded after 10m — spawn never completed (outcome=no_result)',
-    },
-  ];
-  assert.equal(isRescanCandidate(jobs[1]), true, 'fixture must be a genuine rescan candidate');
-  assert.equal(shouldRunPeriodicReverify(jobs), true);
-});
-
-test('a failed row with a real result event (genuine red gate) does NOT fire the pass', () => {
-  writeRunLog('run-guard-2', '200-red', [
-    '[scheduler] starting 200-red',
-    JSON.stringify({ type: 'result', subtype: 'success', is_error: true }),
-  ]);
-  const jobs = [{ slug: '200-red', status: 'failed', runId: 'run-guard-2' }];
-  assert.equal(isRescanCandidate(jobs[0]), false);
-  assert.equal(shouldRunPeriodicReverify(jobs), false);
-});
-
-test('needs_review with a rescannable verdict still fires; a non-rescannable verdict does not', () => {
-  writeRunLog('run-guard-3', '300-nr', ['[scheduler] starting 300-nr']);
-  assert.equal(
-    shouldRunPeriodicReverify([
-      { slug: '300-nr', status: 'needs_review', runId: 'run-guard-3', verifierVerdict: 'verify_unavailable' },
-    ]),
-    true,
-  );
-  // A verdict outside RESCANNABLE_VERDICTS is not itself enough to suppress
-  // the pass: with no sessionId, this row also fails selectResumeRecoveryTarget's
-  // eligibility check, so it falls through as a genuine selectAutoFixTargets
-  // candidate (a fix-plan investigation, not a rescan) — and the widened guard
-  // must fire for that too.
-  assert.equal(
-    shouldRunPeriodicReverify([
-      { slug: '300-nr', status: 'needs_review', runId: 'run-guard-3', verifierVerdict: 'uncommitted_changes' },
-    ]),
-    true,
-  );
-});
-
-test('a needs_review row with no rescan/recovery/autofix eligibility at all does not fire the pass', () => {
-  // Genuinely nothing to do: already has a fix-plan outcome recorded as
-  // 'plan' (never retried by selectAutoFixTargets — see its autoFixOutcome
-  // exclusion), so selectAutoFixTargets excludes it regardless of
-  // fixSlugExists; not a rescan candidate (RESCANNABLE_VERDICTS); not
-  // resume/mechanical eligible either.
-  writeRunLog('run-guard-3b', '301-nr', ['[scheduler] starting 301-nr']);
-  const jobs = [
-    {
-      slug: '301-nr',
-      status: 'needs_review',
-      runId: 'run-guard-3b',
-      verifierVerdict: 'uncommitted_changes',
-      autoFixAttempted: true,
-      autoFixOutcome: 'plan',
-    },
-  ];
-  assert.equal(isRescanCandidate(jobs[0]), false);
-  assert.equal(selectMechanicalRecoveryTarget(jobs[0]), null);
-  assert.equal(
-    selectAutoFixTargets(jobs, { fixSlugExists: () => false }).length,
-    0,
-    'sanity: selectAutoFixTargets itself must exclude this row (cheap-guard stub matches production: fixSlugExists always false)',
-  );
-  assert.equal(shouldRunPeriodicReverify(jobs), false);
-});
-
-test('a queue with nothing rescannable, or a non-array, does not fire the pass', () => {
-  assert.equal(shouldRunPeriodicReverify([{ slug: 'a', status: 'pending' }, { slug: 'b', status: 'completed' }]), false);
-  assert.equal(shouldRunPeriodicReverify([]), false);
-  assert.equal(shouldRunPeriodicReverify(undefined), false);
-});
-
-// Live reproduction fixture (verbatim, verdict from the machine 2026-09-12):
-// starry-night-ships 231-saturn-record-and-docs, needs_review,
-// worktree_integration_failed, mechanical recovery already spent.
-function liveFixtureRow(overrides = {}) {
-  return {
-    slug: '231-saturn-record-and-docs',
-    cwd: '/home/bilko/Projects/starry-night-ships',
-    status: 'needs_review',
-    verifierVerdict: 'worktree_integration_failed',
-    mechanicalRecoveryAttempted: true,
-    autoFixAttempted: undefined,
-    runId: '2026-09-11T23-58-26-007Z',
-    ...overrides,
-  };
-}
-
-test('live fixture: mechanical recovery spent, autofix never attempted — guard now fires (was false)', () => {
-  writeRunLog(liveFixtureRow().runId, liveFixtureRow().slug, ['[scheduler] starting 231-saturn-record-and-docs']);
-  const jobs = [liveFixtureRow()];
-  assert.equal(isRescanCandidate(jobs[0]), false, 'worktree_integration_failed is deliberately NOT in RESCANNABLE_VERDICTS');
-  assert.equal(selectMechanicalRecoveryTarget(jobs[0]), null, 'mechanical recovery is spent (mechanicalRecoveryAttempted: true)');
-  assert.equal(shouldRunPeriodicReverify(jobs), true);
-});
-
-test('live fixture is authored as a selectAutoFixTargets candidate once mechanical recovery is spent', () => {
-  const jobs = [liveFixtureRow()];
-  const targets = selectAutoFixTargets(jobs, { fixSlugExists: () => false });
-  assert.deepEqual(targets.map((t) => t.slug), ['231-saturn-record-and-docs']);
-});
-
-test('a row whose mechanical recovery is still PENDING is excluded from selectAutoFixTargets (both rungs never fire together)', () => {
-  const jobs = [liveFixtureRow({ mechanicalRecoveryAttempted: undefined })];
-  assert.notEqual(selectMechanicalRecoveryTarget(jobs[0]), null, 'still eligible for its one mechanical retry');
-  const targets = selectAutoFixTargets(jobs, { fixSlugExists: () => false });
-  assert.deepEqual(targets, [], 'a mechanical-recovery-pending row must not also become a fix-plan target');
-  // The guard still fires for this row — via the mechanical-recovery rung, not autofix.
-  assert.equal(shouldRunPeriodicReverify(jobs), true);
-});
-
-test('one-attempt caps are unchanged by the widened guard', () => {
-  // mechanicalRecoveryAttempted still permits exactly one retry: once true, selectMechanicalRecoveryTarget is spent forever.
-  assert.equal(selectMechanicalRecoveryTarget(liveFixtureRow({ mechanicalRecoveryAttempted: true })), null);
-  assert.notEqual(selectMechanicalRecoveryTarget(liveFixtureRow({ mechanicalRecoveryAttempted: undefined })), null);
-  // autoFixRetries < 1 still bounds the fix-plan retry inside selectAutoFixTargets.
-  const exhausted = [liveFixtureRow({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 1 })];
-  assert.deepEqual(selectAutoFixTargets(exhausted, { fixSlugExists: () => false }), [], 'exhausted retry budget must stay excluded');
-  const withBudget = [liveFixtureRow({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 0 })];
-  assert.equal(selectAutoFixTargets(withBudget, { fixSlugExists: () => false }).length, 1, 'one bounded retry is still available');
-});
-
-test('kill-switches still fully disable their respective paths', () => {
-  const jobs = [liveFixtureRow()];
-  const prevAutofix = process.env.SM_AUTOFIX_DISABLE;
-  const prevMechanical = process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-  try {
-    // SM_REVERIFY_PERIODIC_DISABLE is enforced by the interval callback around
-    // shouldRunPeriodicReverify (scheduler.cjs's rescheduleInterval body), not
-    // inside the guard itself — the guard stays a pure predicate over jobs.
-    assert.equal(process.env.SM_REVERIFY_PERIODIC_DISABLE, undefined, 'sanity: not set in this test process');
-
-    // SM_MECHANICAL_RECOVERY_DISABLE=1 makes selectMechanicalRecoveryTarget
-    // always return null, which is exactly what the widened guard consults.
-    process.env.SM_MECHANICAL_RECOVERY_DISABLE = '1';
-    const pendingMechanicalJob = [liveFixtureRow({ mechanicalRecoveryAttempted: undefined })];
-    assert.equal(selectMechanicalRecoveryTarget(pendingMechanicalJob[0]), null);
-    delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-
-    // SM_AUTOFIX_DISABLE gates reverifyNeedsReview's own auto-fix dispatch
-    // loop (scheduler.cjs ~8207), not selectAutoFixTargets/the guard — the
-    // guard's job is only to decide whether the pass should run at all, and
-    // it must still fire so the disabled loop's own no-op is reached (rather
-    // than the periodic pass never running and other reverify semantics,
-    // e.g. rescan candidates elsewhere in the same tick, being starved too).
-    process.env.SM_AUTOFIX_DISABLE = '1';
-    assert.equal(shouldRunPeriodicReverify(jobs), true);
-  } finally {
-    if (prevAutofix === undefined) delete process.env.SM_AUTOFIX_DISABLE;
-    else process.env.SM_AUTOFIX_DISABLE = prevAutofix;
-    if (prevMechanical === undefined) delete process.env.SM_MECHANICAL_RECOVERY_DISABLE;
-    else process.env.SM_MECHANICAL_RECOVERY_DISABLE = prevMechanical;
-  }
-});

package/src/main/__tests__/scheduler-porcelain-rename.test.cjs

@@ -1,164 +0,0 @@
-/**
- * scheduler-porcelain-rename.test.cjs — PRD 1187/1186-follow-on: a staged
- * rename ("R  old -> new") was parsed by `parsePorcelainEntries` as ONE fused
- * path string `"old -> new"`. That string can never match a real path in
- * `dirtyAfter`, `pathsCommittedDuringRun`, or an `fs.existsSync` check, so
- * every staged rename in a shared-tree-guard baseline was structurally
- * guaranteed to be reported reverted — even when it was cleanly committed
- * during the run. On 2026-09-12 this flagged 45 paths and parked a clean,
- * committed run (job `1187-autoresolve-guard-verdict-parks`):
- *
- *   "job discarded pre-existing state in the shared tree: 45 path(s)
- *   reverted with no commit to explain it
- *   (scripts/__tests__/manual-chapter-links.test.cjs ->
- *   web/manual/__tests__/chapter-links.test.cjs, ...)" — exit 0, landedCommit
- *   recorded, nothing actually lost.
- *
- * Every test below is written to FAIL against the pre-fix implementation
- * (`path: l.slice(3)`, no rename/quote parsing at all).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-porcelain-rename.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const scheduler = require('../scheduler.cjs');
-const { parsePorcelainEntries, evaluateSharedTreeGuard } = scheduler;
-
-// --- parsePorcelainEntries: rename/copy lines split into real components ---
-
-test('parsePorcelainEntries: a plain staged rename splits into new path + oldPath, not one fused string', () => {
-  const entries = parsePorcelainEntries('R  old.txt -> new.txt\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a rename-with-worktree-modification (RM) line still splits correctly', () => {
-  const entries = parsePorcelainEntries('RM old.txt -> new.txt\n');
-  expect(entries).toEqual([{ code: 'RM', path: 'new.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a copy line (C) splits the same way as a rename', () => {
-  const entries = parsePorcelainEntries('C  old.txt -> copy.txt\n');
-  expect(entries).toEqual([{ code: 'C ', path: 'copy.txt', oldPath: 'old.txt' }]);
-});
-
-test('parsePorcelainEntries: a NEW path containing a space is quoted by git and must be unquoted', () => {
-  // Real `git status --porcelain` output for `git mv new.txt "renamed with space.txt"`.
-  const entries = parsePorcelainEntries('R  new.txt -> "renamed with space.txt"\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'renamed with space.txt', oldPath: 'new.txt' }]);
-});
-
-test('parsePorcelainEntries: an OLD path containing a space is quoted independently of the new path', () => {
-  const entries = parsePorcelainEntries('R  "old with space.txt" -> new.txt\n');
-  expect(entries).toEqual([{ code: 'R ', path: 'new.txt', oldPath: 'old with space.txt' }]);
-});
-
-test('parsePorcelainEntries: a non-ASCII path is quoted with per-byte octal escapes and must decode back to UTF-8', () => {
-  // Real recorded `git status --porcelain` output for a rename onto
-  // "résumé file.txt" — git's default core.quotepath escapes each raw UTF-8
-  // byte >= 0x80 as \NNN octal: 'é' is UTF-8 bytes 0xC3 0xA9 -> \303\251.
-  const line = 'R  new.txt -> "r\\303\\251sum\\303\\251 file.txt"\n';
-  const entries = parsePorcelainEntries(line);
-  expect(entries).toEqual([{ code: 'R ', path: 'résumé file.txt', oldPath: 'new.txt' }]);
-});
-
-test('parsePorcelainEntries: non-rename entries are unaffected (no oldPath, path as before)', () => {
-  const entries = parsePorcelainEntries(' M src/foo.js\n?? untracked.txt\n');
-  expect(entries).toEqual([
-    { code: ' M', path: 'src/foo.js' },
-    { code: '??', path: 'untracked.txt' },
-  ]);
-});
-
-test('parsePorcelainEntries: a quoted plain (non-rename) path is also unquoted, not left with literal quotes', () => {
-  const entries = parsePorcelainEntries('?? "plain space.txt"\n');
-  expect(entries).toEqual([{ code: '??', path: 'plain space.txt' }]);
-});
-
-// --- The exact 1187 shape: committed rename must not be flagged reverted ---
-
-test('evaluateSharedTreeGuard: a staged rename that is committed during the run is NOT reported reverted (real 1187 case)', () => {
-  const oldPath = 'scripts/__tests__/manual-chapter-links.test.cjs';
-  const newPath = 'web/manual/__tests__/chapter-links.test.cjs';
-  const dirtyBefore = parsePorcelainEntries(`R  ${oldPath} -> ${newPath}\n`);
-  // git diff --name-only <headBefore>..<headAfter> reports only the NEW path
-  // for a committed rename (verified against real git 2.43 behavior).
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [], // fully committed, nothing left dirty
-    pathsCommittedDuringRun: [newPath],
-  });
-  expect(result.reverted).toEqual([]);
-});
-
-test('evaluateSharedTreeGuard: a batch of committed renames (the real 45-path shape) are all cleared, none reverted', () => {
-  const pairs = [
-    ['scripts/__tests__/manual-chapter-links.test.cjs', 'web/manual/__tests__/chapter-links.test.cjs'],
-    ['scripts/foo-old.js', 'src/foo-new.js'],
-    ['docs/old-name.md', 'docs/new-name.md'],
-  ];
-  const porcelain = pairs.map(([o, n]) => `R  ${o} -> ${n}`).join('\n') + '\n';
-  const dirtyBefore = parsePorcelainEntries(porcelain);
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [],
-    pathsCommittedDuringRun: pairs.map(([, n]) => n),
-  });
-  expect(result.reverted).toEqual([]);
-});
-
-// --- The guard's real purpose survives: an UNDONE rename still parks ---
-
-test('evaluateSharedTreeGuard: a staged rename that is UNDONE (old path restored, new path gone, nothing committed) IS still reported reverted', () => {
-  // This test must FAIL if the fix is implemented as "blanket skip rename
-  // entries" (dropping every rename-coded entry from consideration would
-  // make `reverted` come back empty here, exactly like the committed case
-  // above — but here nothing was committed to explain the disappearance).
-  const dirtyBefore = parsePorcelainEntries('R  old.txt -> new.txt\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [], // clean again — reverted to HEAD, old.txt restored, new.txt gone
-    pathsCommittedDuringRun: [], // nothing committed
-  });
-  expect(result.reverted).toEqual(['new.txt']);
-});
-
-// --- The two already-fixed false-positive classes stay fixed (pinned here
-// too, using parsePorcelainEntries as the real entry point rather than
-// hand-built fixtures, so a future change to the parser can't silently
-// regress them without failing a test right next to the rename fix). ---
-
-test('evaluateSharedTreeGuard: nowIgnored still works for a real parsePorcelainEntries untracked baseline entry', () => {
-  const dirtyBefore = parsePorcelainEntries('?? session-manager-operations/logs/errors-2026-09-12.jsonl\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    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: a genuine deletion of an untracked path (from a real parsePorcelainEntries entry) is still reverted', () => {
-  const dirtyBefore = parsePorcelainEntries('?? data/scratch.txt\n');
-  const result = evaluateSharedTreeGuard({
-    stashBefore: [],
-    stashAfter: [],
-    dirtyBefore,
-    dirtyAfter: [],
-    pathsCommittedDuringRun: [],
-    existsAfter: [],
-  });
-  expect(result.reverted).toEqual(['data/scratch.txt']);
-  expect(result.nowIgnored).toEqual([]);
-});

package/src/main/__tests__/scheduler-prd-missing-skip.test.cjs

@@ -1,161 +0,0 @@
-/**
- * scheduler-prd-missing-skip.test.cjs — regression test for PRD 812's
- * failure-classification fix: a queued job whose PRD source has disappeared
- * between enqueue and dispatch (e.g. a test fixture that leaked into the
- * live queue and was cleaned up before the job ran) must be retired as a
- * stale row (exitCode: 0, skipped: 'prd-missing'), not treated as a hard
- * job failure (exitCode: -1). A genuinely unreadable/unparseable PRD (a
- * real, non-ENOENT error) must still fail with exitCode: -1.
- *
- * HOME-isolated per the same incident: stub HOME to a mkdtemp dir before
- * requiring scheduler.cjs, and never write into the real scheduler root.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-prd-missing-skip.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let executeJob;
-let spawnJob;
-let PRDS_DIR;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-skip-'));
-  process.env.HOME = tmpHome;
-
-  ({ executeJob, spawnJob, PRDS_DIR } = require('../scheduler.cjs'));
-
-  if (!PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('a job whose PRD source is gone everywhere is retired, not failed', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-project-'));
-  // config.cjs's writeJsonSync (used for the job's meta.json) restricts
-  // writes to WRITE_PREFIXES, which includes `<home>/.claude` — so runDir
-  // must live under the stubbed tmpHome's .claude/, not the system tmpdir.
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-missing-run-'));
-  try {
-    const slug = `812-test-missing-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const job = { slug, cwd: projectCwd };
-
-    const result = await executeJob(job, runDir, projectCwd, () => {});
-
-    expect(result.exitCode).toBe(0);
-    expect(result.skipped).toBe('prd-missing');
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-test('a job whose PRD source exists but is unreadable for a non-ENOENT reason still fails', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-toobig-project-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-toobig-run-'));
-  try {
-    const slug = `812-test-toobig-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
-    fs.mkdirSync(prdsDir, { recursive: true });
-    // parsePrd rejects any PRD over 1MB with a plain Error (no .code) — this
-    // is the "found but unparseable" case, distinct from ENOENT, and must
-    // stay a real failure.
-    const oversized = '---\ntitle: too big\n---\n\n' + 'x'.repeat(1024 * 1024 + 1);
-    fs.writeFileSync(path.join(prdsDir, `${slug}.md`), oversized, 'utf8');
-
-    const job = { slug, cwd: projectCwd };
-    const result = await executeJob(job, runDir, projectCwd, () => {});
-
-    expect(result.exitCode).toBe(-1);
-    expect(result.skipped).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});
-
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-function 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');
-}
-
-// This test's whole premise is a PRD source missing EVERYWHERE — so the row
-// this produces is exactly what reconcile()'s auto-archive-drop path treats
-// as "archived on purpose": backfilled to history.jsonl and dropped from
-// queue.json in the very same reconcile pass that spawnJob's own
-// broadcast({flush:true}) triggers on completion (see
-// scheduler-reconcile-history-backfill.test.cjs). Look in both places.
-function readTerminalRow(queuePath, projectCwd, slug) {
-  const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-  const row = jobs.find((j) => j.slug === slug);
-  if (row) return row;
-  const historyPath = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'state', 'history.jsonl');
-  if (!fs.existsSync(historyPath)) return undefined;
-  const lines = fs.readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
-  return lines.map((l) => JSON.parse(l)).reverse().find((j) => j.slug === slug);
-}
-
-// This is the actual regression case: PRD 812's fix only covered executeJob's
-// own return value. The bug lived one layer up, in spawnJob's post-run
-// handler, which only short-circuited on skipped === 'prd-archived' and let
-// 'prd-missing' fall through into the verify path meant for real runs —
-// downgrading a stale-queue-entry retire into a needs_review with a bogus RCA
-// feedback item. Drive spawnJob itself (not just executeJob) so this covers
-// the actual defect, not just the classification it depends on.
-test("spawnJob's post-run handler retires a prd-missing skip as a plain completion, without running verify", async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-missing-spawnjob-project-'));
-  registerActiveProject(projectCwd);
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-missing-spawnjob-run-'));
-  try {
-    const slug = `812-test-spawnjob-missing-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-    const queuePath = writeProjectQueue(projectCwd, [
-      { slug, status: 'pending', cwd: projectCwd },
-    ]);
-
-    const job = { slug, cwd: projectCwd };
-    await spawnJob(job, 'run-spawnjob-missing', runDir, projectCwd);
-
-    const row = readTerminalRow(queuePath, projectCwd, slug);
-    expect(row).toBeDefined();
-    // A 'prd-missing' skip means no executor ever ran — it must land on the
-    // distinct 'skipped' status, never 'completed' (the status a genuine
-    // successful run produces), so unrun work can never masquerade as done.
-    expect(row.status).toBe('skipped');
-    expect(row.status).not.toBe('completed');
-    expect(row.exitCode).toBe(0);
-    expect(row.error).toBeNull();
-    // No verify pass ran and no RCA feedback fired: a verified run always
-    // stamps a verify-derived status ('needs_review') or a landedCommit/verify
-    // field onto the row. Neither is present here — the row was completed by
-    // the early-return skip branch, not the verification block further down.
-    expect(row.status).not.toBe('needs_review');
-    expect(row.landedCommit).toBeUndefined();
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});