claude-code-session-manager 0.98.0 → 0.100.0

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

@@ -1,247 +0,0 @@
-/**
- * scheduler-reconcile-quarantine.test.cjs — PRD-authoring-lockdown provenance
- * gate: reconcile() must never turn a discovered PRD with no `createdVia`
- * frontmatter into a runnable 'pending' queue row. It quarantines it instead
- * (a distinct, non-runnable status), logs a warning naming the file, and
- * audits the event — then, once the file is stamped (the Scheduler tab's
- * "adopt PRD" action / scheduler_update_prd, both routed through
- * remote.updatePrd), promotes the row to 'pending' on the very next pass.
- *
- * Mirrors scheduler-reconcile-invalid-repair.test.cjs's HOME-isolation setup.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reconcile-quarantine.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-reconcile-quarantine-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 });
-});
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-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 makeFixtureProject(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  registerActiveProject(cwd);
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  // Epic-scoped, not the retired flat dir: a flat PRD with no live queue row
-  // gets swept into prds-archived/ by reconcile()'s own consolidation pass
-  // (see consolidateAllFlatPrds) BEFORE it's ever scanned as a discoverable
-  // PRD — exactly the scenario every test below needs to observe, so the
-  // flat layout would race the very thing under test.
-  const prdsDir = path.join(opsRoot, 'scheduler', 'epics', 'test-epic-1', 'prds');
-  const stateDir = path.join(opsRoot, 'scheduler', 'state');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.mkdirSync(stateDir, { recursive: true });
-  return { cwd, prdsDir, stateDir };
-}
-
-test('reconcile() quarantines a newly-discovered PRD with no createdVia provenance', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-new-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, '9001-hand-written.md'),
-      `---\ntitle: Hand-written PRD\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const { auditLogPath } = require('../lib/auditLog.cjs');
-
-    queueStore.bustCwdCache();
-    const state = { jobs: [], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9001-hand-written');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('quarantined');
-
-    const warned = warnSpy.mock.calls.some((args) =>
-      String(args[0]).includes('quarantining unstamped PRD') && String(args[0]).includes('9001-hand-written'),
-    );
-    expect(warned).toBe(true);
-
-    const auditLines = fs.readFileSync(auditLogPath(), 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-    expect(auditLines.some((rec) => rec.kind === 'prd_quarantined' && rec.slug === '9001-hand-written')).toBe(true);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() queues a newly-discovered PRD stamped with createdVia as pending, not quarantined', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-stamped-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, '9002-api-written.md'),
-      `---\ntitle: API-written PRD\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-
-    queueStore.bustCwdCache();
-    const state = { jobs: [], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9002-api-written');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('pending');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() exempts a fix-plan PRD (NN-fix-*) from quarantine even with no createdVia', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-fixplan-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, '9003-fix-something.md'),
-      `---\ntitle: Fix something\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nHeal it.\n`,
-      'utf8',
-    );
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-
-    queueStore.bustCwdCache();
-    const state = { jobs: [], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9003-fix-something');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('pending');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() does NOT stamp investigationDepth for a createdVia-stamped PRD whose slug merely starts with "fix-" (PRD 1126/1131 regression)', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-fake-fixplan-');
-  try {
-    // Mirrors PRD 1126: authored via scheduler_create_prd (createdVia stamped),
-    // slug happens to kebab-case into "fix-..." — must NOT be treated as a
-    // genuine scheduler-authored fix plan just because the name matches.
-    fs.writeFileSync(
-      path.join(prdsDir, '9005-fix-plan-death-reopens-parent.md'),
-      `---\ntitle: Fix plan death reopens parent\ncwd: ${cwd}\nestimateMinutes: 15\ncreatedVia: scheduler-api\nissuedAt: 2026-08-07T00:00:00.000Z\n---\n\n# Goal\nDo the thing.\n`,
-      'utf8',
-    );
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-
-    queueStore.bustCwdCache();
-    const state = { jobs: [], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9005-fix-plan-death-reopens-parent');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('pending');
-    expect(row.isFixPlan).toBe(false);
-    expect(row.investigationDepth).toBeUndefined();
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() stamps isFixPlan + investigationDepth for a genuine spawnInvestigation-authored fix plan (explicit isFixPlan:true, no createdVia)', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-genuine-fixplan-');
-  try {
-    fs.writeFileSync(
-      path.join(prdsDir, '9006-fix-something.md'),
-      `---\ntitle: Fix something\ncwd: ${cwd}\nestimateMinutes: 15\nisFixPlan: true\n---\n\n# Goal\nHeal it.\n`,
-      'utf8',
-    );
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-
-    queueStore.bustCwdCache();
-    const state = { jobs: [], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9006-fix-something');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('pending');
-    expect(row.isFixPlan).toBe(true);
-    expect(row.investigationDepth).toBe(2);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('reconcile() adopts a quarantined row to pending once its PRD file is stamped', async () => {
-  const { cwd, prdsDir, stateDir } = makeFixtureProject('sm-quarantine-adopt-');
-  try {
-    const prdPath = path.join(prdsDir, '9004-adopt-me.md');
-    fs.writeFileSync(
-      prdPath,
-      `---\ntitle: Adopt me\ncwd: ${cwd}\nestimateMinutes: 15\n---\n\n# Goal\nAdopt.\n`,
-      'utf8',
-    );
-    const quarantinedRow = {
-      slug: '9004-adopt-me',
-      title: 'Adopt me',
-      cwd,
-      status: 'quarantined',
-      runId: null,
-      startedAt: null,
-      finishedAt: null,
-      exitCode: null,
-      error: null,
-    };
-    fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [quarantinedRow] }, null, 2), 'utf8');
-
-    // Simulate the adopt action: stamp the file via the same update-prd
-    // logic the IPC handler/admin route call (parsePrdFile/serializePrdFile
-    // round-trip), rather than hand-writing raw text, to exercise the real
-    // round-trip path this feature depends on.
-    const { parsePrdFile, serializePrdFile } = require('../lib/prdFrontmatter.cjs');
-    const raw = fs.readFileSync(prdPath, 'utf8');
-    const { frontmatter: fm, body } = parsePrdFile(raw);
-    fm.createdVia = 'legacy-adopted';
-    fm.issuedAt = '2026-08-07T01:00:00.000Z';
-    fs.writeFileSync(prdPath, serializePrdFile(fm, body), 'utf8');
-
-    const { auditLogPath } = require('../lib/auditLog.cjs');
-    queueStore.bustCwdCache();
-    const state = { jobs: [quarantinedRow], invalidJobs: [], paused: null };
-    await scheduler.reconcile(state);
-
-    const row = state.jobs.find((j) => j.slug === '9004-adopt-me');
-    expect(row).toBeDefined();
-    expect(row.status).toBe('pending');
-
-    const auditLines = fs.readFileSync(auditLogPath(), 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-    expect(auditLines.some((rec) => rec.kind === 'scheduler_prd_adopted' && rec.slug === '9004-adopt-me')).toBe(true);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-reset-job-fields-guard.test.cjs

@@ -1,77 +0,0 @@
-/**
- * scheduler-reset-job-fields-guard.test.cjs — unit tests for resetJobFields'
- * terminal-status guard.
- *
- * A 'completed' job already landed its deliverable — resetting it back to
- * 'pending' re-fires the PRD and re-executes already-shipped work (the
- * incident: PRD 812-workbench-review-nits-cleanup was reset and re-run this
- * way, burning a full claude -p job + Opus investigation over a correct
- * no-op). resetJobFields must refuse (no-op) on a 'completed' job unless
- * opts.force is true, and must still reset normally for every non-terminal
- * status (pending/running/failed/needs_review).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-reset-job-fields-guard.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { resetJobFields } = require('../scheduler.cjs');
-
-function makeJob(status, overrides = {}) {
-  return {
-    slug: 'test-slug',
-    status,
-    runId: 'run-123',
-    startedAt: '2026-07-31T00:00:00.000Z',
-    finishedAt: '2026-07-31T00:05:00.000Z',
-    exitCode: 0,
-    error: null,
-    runtime: { pid: 999 },
-    verifierVerdict: 'pass',
-    landedCommit: 'abc1234',
-    ...overrides,
-  };
-}
-
-test('resetJobFields: refuses and does not mutate a completed job', () => {
-  const job = makeJob('completed');
-  const snapshot = { ...job };
-  const result = resetJobFields(job, 'some error');
-  expect(result).toBe(false);
-  expect(job).toEqual(snapshot);
-});
-
-test('resetJobFields: force:true overrides the guard on a completed job', () => {
-  const job = makeJob('completed');
-  const result = resetJobFields(job, 'forced reset', { force: true });
-  expect(result).toBe(true);
-  expect(job.status).toBe('pending');
-  expect(job.runId).toBeNull();
-  expect(job.startedAt).toBeNull();
-  expect(job.finishedAt).toBeNull();
-  expect(job.exitCode).toBeNull();
-  expect(job.error).toBe('forced reset');
-  expect(job.runtime).toBeUndefined();
-  expect(job.verifierVerdict).toBeUndefined();
-  // landedCommit must survive even a forced reset — it feeds the
-  // pass_no_commit_prior_run_verified exemption on a later re-run.
-  expect(job.landedCommit).toBe('abc1234');
-});
-
-for (const status of ['pending', 'running', 'failed', 'needs_review']) {
-  test(`resetJobFields: resets normally for non-terminal status '${status}'`, () => {
-    const job = makeJob(status);
-    const result = resetJobFields(job, 'retry reason');
-    expect(result).toBe(true);
-    expect(job.status).toBe('pending');
-    expect(job.runId).toBeNull();
-    expect(job.startedAt).toBeNull();
-    expect(job.finishedAt).toBeNull();
-    expect(job.exitCode).toBeNull();
-    expect(job.error).toBe('retry reason');
-    expect(job.runtime).toBeUndefined();
-    expect(job.verifierVerdict).toBeUndefined();
-    expect(job.landedCommit).toBe('abc1234');
-  });
-}

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

@@ -1,254 +0,0 @@
-/**
- * scheduler-resume-recovery.test.cjs — PRD 1111: resume-first recovery for a
- * job parked in needs_review with verdict 'uncommitted_changes'. Before this
- * feature, every such job went straight to spawnInvestigation (a cold-read
- * fix-plan PRD authored by a FRESH session with no memory of the run it's
- * diagnosing). This suite covers selectResumeRecoveryTarget's eligibility
- * table, the --resume vs --session-id argv split (buildClaudeSpawnArgs), the
- * preamble builder, the one-attempt bound, the SM_RESUME_RECOVERY_DISABLE
- * kill-switch, and the two skip-gates (spawnInvestigation, selectAutoFixTargets).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-resume-recovery.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const {
-  selectResumeRecoveryTarget,
-  buildResumeRecoveryPreamble,
-  buildClaudeSpawnArgs,
-  selectAutoFixTargets,
-  spawnInvestigation,
-} = require('../scheduler.cjs');
-
-const savedDisable = process.env.SM_RESUME_RECOVERY_DISABLE;
-afterEach(() => {
-  if (savedDisable === undefined) delete process.env.SM_RESUME_RECOVERY_DISABLE;
-  else process.env.SM_RESUME_RECOVERY_DISABLE = savedDisable;
-});
-
-function baseJob(overrides = {}) {
-  return {
-    slug: '900-example',
-    status: 'needs_review',
-    verifierVerdict: 'uncommitted_changes',
-    sessionId: 'sess-abc-123',
-    uncommittedPaths: ['src/foo.js', 'src/bar.js'],
-    ...overrides,
-  };
-}
-
-// ---------- selectResumeRecoveryTarget eligibility table ----------
-
-test('selectResumeRecoveryTarget: eligible shape returns a resume decision', () => {
-  const target = selectResumeRecoveryTarget(baseJob());
-  expect(target).toEqual({
-    slug: '900-example',
-    sessionId: 'sess-abc-123',
-    dirtyPaths: ['src/foo.js', 'src/bar.js'],
-    salvagePatch: null,
-  });
-});
-
-test('selectResumeRecoveryTarget: carries salvagePatch through when present on the row', () => {
-  const target = selectResumeRecoveryTarget(baseJob({ salvagePatch: '/tmp/runs/x/900-example.uncommitted.patch' }));
-  expect(target.salvagePatch).toBe('/tmp/runs/x/900-example.uncommitted.patch');
-});
-
-const notNeedsReviewStatuses = ['pending', 'running', 'investigating', 'completed', 'failed', 'skipped'];
-for (const status of notNeedsReviewStatuses) {
-  test(`selectResumeRecoveryTarget: status=${status} → null`, () => {
-    expect(selectResumeRecoveryTarget(baseJob({ status }))).toBeNull();
-  });
-}
-
-const nonRecoverableVerdicts = [
-  'silent_no_op',
-  'pass_no_commit_already_shipped',
-  'pass_no_commit_prior_run_verified',
-  'transcript_errors',
-  'deps_unmet',
-  'halt',
-  'verify_unavailable',
-  'worktree_integration_failed',
-  'shared_tree_reverted',
-  undefined,
-];
-for (const verdict of nonRecoverableVerdicts) {
-  test(`selectResumeRecoveryTarget: verdict=${JSON.stringify(verdict)} → null`, () => {
-    expect(selectResumeRecoveryTarget(baseJob({ verifierVerdict: verdict }))).toBeNull();
-  });
-}
-
-test('selectResumeRecoveryTarget: missing sessionId → null', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ sessionId: undefined }))).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: empty-string sessionId → null', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ sessionId: '' }))).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: non-string sessionId → null', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ sessionId: 12345 }))).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: resumeRecoveryAttempted === true → null (bounded to one attempt)', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ resumeRecoveryAttempted: true }))).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: resumeRecoveryAttempted absent/false → still eligible', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ resumeRecoveryAttempted: false }))).not.toBeNull();
-  expect(selectResumeRecoveryTarget(baseJob())).not.toBeNull();
-});
-
-test('selectResumeRecoveryTarget: no recorded dirty paths → null', () => {
-  expect(selectResumeRecoveryTarget(baseJob({ uncommittedPaths: [] }))).toBeNull();
-  expect(selectResumeRecoveryTarget(baseJob({ uncommittedPaths: undefined }))).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: null/undefined job → null', () => {
-  expect(selectResumeRecoveryTarget(null)).toBeNull();
-  expect(selectResumeRecoveryTarget(undefined)).toBeNull();
-});
-
-test('selectResumeRecoveryTarget: SM_RESUME_RECOVERY_DISABLE=1 → null even for an otherwise-eligible job', () => {
-  process.env.SM_RESUME_RECOVERY_DISABLE = '1';
-  expect(selectResumeRecoveryTarget(baseJob())).toBeNull();
-});
-
-// ---------- --resume vs --session-id argv (buildClaudeSpawnArgs) ----------
-
-test('buildClaudeSpawnArgs: resume=true passes --resume <sessionId>, never --session-id', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'preamble text', model: 'sonnet', sessionId: 'sess-abc-123', resume: true });
-  expect(args).toContain('--resume');
-  expect(args[args.indexOf('--resume') + 1]).toBe('sess-abc-123');
-  expect(args).not.toContain('--session-id');
-});
-
-test('buildClaudeSpawnArgs: resume=false passes --session-id <sessionId>, never --resume', () => {
-  const args = buildClaudeSpawnArgs({ prompt: 'prd body', model: 'sonnet', sessionId: 'sess-fresh-456', resume: false });
-  expect(args).toContain('--session-id');
-  expect(args[args.indexOf('--session-id') + 1]).toBe('sess-fresh-456');
-  expect(args).not.toContain('--resume');
-});
-
-test('buildClaudeSpawnArgs: --model is always explicitly pinned, both modes', () => {
-  for (const resume of [true, false]) {
-    const args = buildClaudeSpawnArgs({ prompt: 'x', model: 'sonnet', sessionId: 'sid', resume });
-    const modelIdx = args.indexOf('--model');
-    expect(modelIdx).toBeGreaterThanOrEqual(0);
-    expect(args[modelIdx + 1]).toBe('sonnet');
-  }
-});
-
-// ---------- preamble content (buildResumeRecoveryPreamble) ----------
-
-test('buildResumeRecoveryPreamble: contains every recorded dirty path', () => {
-  const dirtyPaths = ['src/main/scheduler.cjs', 'session-manager-operations/scheduler/prds/900-example.md'];
-  const preamble = buildResumeRecoveryPreamble({ dirtyPaths, salvagePatch: null });
-  for (const p of dirtyPaths) {
-    expect(preamble).toContain(p);
-  }
-});
-
-test('buildResumeRecoveryPreamble: does NOT re-embed a PRD body passed in as an unrelated string', () => {
-  const prdBody = '# Goal\nSome long PRD body that must never appear in a resume preamble.\n## Acceptance criteria\n- [ ] thing';
-  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: null });
-  expect(preamble).not.toContain(prdBody);
-  expect(preamble).not.toContain('Acceptance criteria');
-});
-
-test('buildResumeRecoveryPreamble: instructs verifying paths on disk, foreground gate, and commit', () => {
-  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: null });
-  expect(preamble).toMatch(/verify/i);
-  expect(preamble).toMatch(/FOREGROUND/);
-  expect(preamble).toMatch(/commit/i);
-});
-
-test('buildResumeRecoveryPreamble: mentions the salvage patch path when present', () => {
-  const preamble = buildResumeRecoveryPreamble({ dirtyPaths: ['a.js'], salvagePatch: '/tmp/runs/x/900-example.uncommitted.patch' });
-  expect(preamble).toContain('/tmp/runs/x/900-example.uncommitted.patch');
-});
-
-// ---------- selectAutoFixTargets skips resume-eligible jobs ----------
-
-test('selectAutoFixTargets: excludes a job selectResumeRecoveryTarget accepts', () => {
-  const job = baseJob({ runId: 'run-1' });
-  const targets = selectAutoFixTargets([job], {
-    fixSlugExists: () => false,
-    resolveJobRunId: () => job.runId,
-  });
-  expect(targets).toEqual([]);
-});
-
-test('selectAutoFixTargets: still selects a needs_review job that is NOT resume-eligible (different verdict)', () => {
-  const job = baseJob({ runId: 'run-1', verifierVerdict: 'transcript_errors' });
-  const targets = selectAutoFixTargets([job], {
-    fixSlugExists: () => false,
-    resolveJobRunId: () => job.runId,
-  });
-  expect(targets.map((t) => t.slug)).toEqual([job.slug]);
-});
-
-test('selectAutoFixTargets: a resume-recovery-exhausted job (resumeRecoveryAttempted=true) falls through to normal auto-fix eligibility', () => {
-  const job = baseJob({ runId: 'run-1', resumeRecoveryAttempted: true });
-  const targets = selectAutoFixTargets([job], {
-    fixSlugExists: () => false,
-    resolveJobRunId: () => job.runId,
-  });
-  expect(targets.map((t) => t.slug)).toEqual([job.slug]);
-});
-
-// ---------- resume-then-fail: never a dead end ----------
-
-test('resume-then-fail: a job whose one resume attempt is spent falls through to the normal fix-plan path, not a dead end', () => {
-  // spawnResumeRecovery reuses spawnJob wholesale, so a resume run that
-  // itself re-parks in needs_review runs through the SAME finalize mutate as
-  // any other run — the only difference is resumeRecoveryAttempted is now
-  // true on the row (stamped atomically with the 'running' transition
-  // before the resume child ever spawned).
-  const jobAfterFailedResume = baseJob({ runId: 'run-2', resumeRecoveryAttempted: true });
-  // A second resume is refused...
-  expect(selectResumeRecoveryTarget(jobAfterFailedResume)).toBeNull();
-  // ...but the job is NOT stranded: it is offered for a fix-plan exactly
-  // like any other needs_review job, via the same gate spawnInvestigation's
-  // periodic caller (reverifyNeedsReview) consults.
-  const targets = selectAutoFixTargets([jobAfterFailedResume], {
-    fixSlugExists: () => false,
-    resolveJobRunId: () => jobAfterFailedResume.runId,
-  });
-  expect(targets.map((t) => t.slug)).toEqual([jobAfterFailedResume.slug]);
-});
-
-// ---------- spawnInvestigation's own resume-first guard ----------
-
-test('spawnInvestigation: a resume-eligible job is skipped before any fix-plan work (returns deferred:false immediately)', async () => {
-  const job = baseJob();
-  // A resume-eligible job trips the guard before spawnInvestigation ever
-  // touches the filesystem for runDir/investigationDepth lookups, so a
-  // nonexistent runDir is safe to pass here — proves the guard runs first.
-  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
-  expect(result).toEqual({ deferred: false });
-});
-
-test('spawnInvestigation: resume-recovery-exhausted job (resumeRecoveryAttempted=true) is NOT skipped by the resume guard', async () => {
-  // slug matches the fix-plan pattern + investigationDepth beyond the cap so
-  // the NEXT gate (isFixPlanBeyondDepthCap) trips deterministically and
-  // returns before any fs/spawn work — proving the resume guard was passed
-  // through, not that this particular job happens to be safe to fully run.
-  const job = baseJob({ slug: '01-fix-example', resumeRecoveryAttempted: true, investigationDepth: 99 });
-  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
-  expect(result).toEqual({ deferred: false });
-});
-
-test('SM_RESUME_RECOVERY_DISABLE=1: spawnInvestigation is NOT skipped by the resume guard for an otherwise-eligible job', async () => {
-  process.env.SM_RESUME_RECOVERY_DISABLE = '1';
-  const job = baseJob({ slug: '01-fix-example', investigationDepth: 99 });
-  // With the kill-switch on, selectResumeRecoveryTarget returns null, so the
-  // resume guard never fires; the job falls through to the NEXT gate
-  // (isFixPlanBeyondDepthCap, tripped here via investigationDepth: 99) —
-  // proving today's pre-feature behaviour is restored exactly.
-  const result = await spawnInvestigation(job, '/nonexistent/run/dir/for/this/test');
-  expect(result).toEqual({ deferred: false });
-});