claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -1,343 +0,0 @@
-/**
- * scheduler-notify-originating-tab.test.cjs — unit tests for
- * notifyOriginatingTab (PRD 761): on a job's terminal completed/failed
- * transition, push a short status prompt into the chat tab that originated
- * it via enqueueExternalPrompt (PRD 753).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { notifyOriginatingTab, isNotifiableTerminalStatus } = require('../scheduler.cjs');
-
-test('isNotifiableTerminalStatus: completed and failed are notifiable', () => {
-  expect(isNotifiableTerminalStatus('completed')).toBe(true);
-  expect(isNotifiableTerminalStatus('failed')).toBe(true);
-});
-
-test('isNotifiableTerminalStatus: needs_review is not notifiable (may still auto-fix)', () => {
-  expect(isNotifiableTerminalStatus('needs_review')).toBe(false);
-});
-
-test('isNotifiableTerminalStatus: a rateLimited exit never reaches an effectiveStatus (undefined) and is not notifiable', () => {
-  // spawnJob's treatAsPending branch (rateLimited || paused for rate_limit)
-  // resets the job to pending and returns before effectiveStatus is ever
-  // computed — so this hook is only ever evaluated with undefined/pending,
-  // never with a real status, on that path.
-  expect(isNotifiableTerminalStatus(undefined)).toBe(false);
-  expect(isNotifiableTerminalStatus('pending')).toBe(false);
-});
-
-test('resolves via sourceTabId when present on the PRD frontmatter', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: 'tab-from-frontmatter' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt },
-  );
-
-  expect(loadSessions).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledTimes(1);
-  expect(sendPrompt).toHaveBeenCalledWith(
-    'tab-from-frontmatter',
-    expect.stringContaining('761-notify'),
-  );
-});
-
-test('falls back to the first open tab whose cwd matches the job cwd', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({
-    tabs: [
-      { id: 'tab-other', cwd: '/other/cwd' },
-      { id: 'tab-match', cwd: '/some/cwd' },
-      { id: 'tab-second-match', cwd: '/some/cwd' },
-    ],
-  }));
-
-  await notifyOriginatingTab(
-    { slug: '761-notify', status: 'failed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt },
-  );
-
-  expect(sendPrompt).toHaveBeenCalledTimes(1);
-  expect(sendPrompt).toHaveBeenCalledWith('tab-match', expect.stringContaining('761-notify'));
-});
-
-test('no-ops without throwing when neither sourceTabId nor a cwd-matching tab resolves', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({ tabs: [{ id: 'tab-other', cwd: '/unrelated' }] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('no-ops when parsing the PRD frontmatter throws', async () => {
-  const sendPrompt = vi.fn();
-  const parsePrdRaw = vi.fn(async () => { throw new Error('ENOENT'); });
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '761-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-// PRD 814: a dev-work ticket's completion notification routes into its own
-// PromptSession's event chain instead of an unrelated tab, when the PRD's
-// sourcePromptId resolves to a known, still-active PromptSession.
-test('routes into the known PromptSession event chain and never falls back to a tab prompt', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    '/some/cwd',
-    'psess-1',
-    expect.stringContaining('814-notify'),
-    { prdSlug: '814-notify', outcome: 'completed', validation: 'unvalidated' },
-  );
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('falls back to the tab-external-ticket path when sourcePromptId does not resolve to a known PromptSession', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => false);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-unknown', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-test('falls back to the tab-external-ticket path when the PRD has no sourcePromptId at all (pre-813 PRD)', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: null, sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-// PRD 854: a PRD dispatched straight from an Epic's own composer
-// (dispatchPromptSessionToPrd) never sets sourceTabId — only sourcePromptId.
-// If the Epic has since gone completed (appendResponseEvent returns false),
-// the fallback must still target sourcePromptId itself as the chat:external-
-// send id, since the renderer now resolves that id against known Epics too.
-test('falls back to sourcePromptId as the external-send target when sourceTabId is absent', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => false);
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'epic-1', sourceTabId: null }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '854-notify', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalled();
-  expect(loadSessions).not.toHaveBeenCalled();
-  expect(sendPrompt).toHaveBeenCalledWith('epic-1', expect.stringContaining('854-notify'));
-});
-
-test('falls back to the tab-external-ticket path when appendResponseEvent itself throws', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => { throw new Error('disk error'); });
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1', sourceTabId: 'tab-x' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await expect(
-    notifyOriginatingTab(
-      { slug: '814-notify', status: 'completed', cwd: '/some/cwd' },
-      { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
-    ),
-  ).resolves.not.toThrow();
-
-  expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
-});
-
-// ─── PRD 985: real path resolution ───────────────────────────────────────────
-// Every test above injects a stubbed `parsePrdRaw`, which is exactly why the
-// bug PRD 985 fixes shipped green: notifyOriginatingTab resolved its PRD via
-// prdPathForJob → the RETIRED flat `scheduler/prds/` dir (today only
-// `.reserved-NNN` stubs, no PRDs), and archiveCompletedPrd renames the file
-// into `prds-archived/` immediately BEFORE notify runs anyway. `prd` was
-// therefore always null on the completed path and no response event was ever
-// appended. These two tests use the REAL parsePrdRaw against a temp tree so
-// the resolution logic itself is covered, not mocked away.
-
-const fs = require('node:fs');
-const os = require('node:os');
-const nodePath = require('node:path');
-
-function makeEpicTree({ epicId, slug, archived }) {
-  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-'));
-  const dir = nodePath.join(
-    cwd, 'session-manager-operations', 'scheduler', 'epics', epicId,
-    archived ? 'prds-archived' : 'prds',
-  );
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(
-    nodePath.join(dir, `${slug}.md`),
-    `---\ntitle: notify 985\ncwd: ${cwd}\nsourcePromptId: ${epicId}\n---\n\nbody\n`,
-    'utf8',
-  );
-  return cwd;
-}
-
-test('PRD 985: an ARCHIVED-only PRD still routes its check-in to the authoring Epic', async () => {
-  const epicId = 'psess-985-archived';
-  const slug = '985-archived-twin';
-  const cwd = makeEpicTree({ epicId, slug, archived: true });
-
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const sendPrompt = vi.fn();
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  // NOTE: no parsePrdRaw override — the real one runs against the temp tree.
-  await notifyOriginatingTab(
-    { slug, status: 'completed', cwd, epicId: null },
-    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    cwd, epicId, expect.stringContaining(slug),
-    expect.objectContaining({ prdSlug: slug, outcome: 'completed' }),
-  );
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, epicId, expect.anything());
-  expect(sendPrompt).not.toHaveBeenCalled();
-});
-
-test('PRD 985: a PRD missing entirely still routes via the job row\'s own epicId', async () => {
-  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-none-'));
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const sendPrompt = vi.fn();
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-
-  await notifyOriginatingTab(
-    { slug: '985-no-prd-on-disk', status: 'failed', cwd, epicId: 'psess-985-from-queue-row' },
-    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledWith(
-    cwd, 'psess-985-from-queue-row', expect.stringContaining('985-no-prd-on-disk'),
-    expect.objectContaining({ prdSlug: '985-no-prd-on-disk', outcome: 'failed' }),
-  );
-  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, 'psess-985-from-queue-row', expect.anything());
-});
-
-// ─── PRD 1407: validator jobs stamp verdicts onto the authoring Epic ────────
-// A completed validator job's result text carries one `VALIDATION: <slug>
-// VERIFIED|REFUTED` line per PRD it checked. Each parsed verdict becomes its
-// own response event BEFORE the validator's own (still-unvalidated)
-// check-in, and the validator's check-in never enqueues a validation prompt
-// for itself.
-test('PRD 1407: a validator job with two sentinel lines appends two verdict events plus its own check-in, and never enqueues validation', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const appendTranscriptTurn = vi.fn(async () => {});
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-validator-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const readResultFromLog = vi.fn(() => [
-    'VALIDATION: 111-alpha VERIFIED',
-    'VALIDATION: 222-beta REFUTED — missing coverage',
-  ].join('\n'));
-
-  await notifyOriginatingTab(
-    { slug: '1407-validator-run', status: 'completed', cwd: '/some/cwd', agentType: 'validator' },
-    {
-      parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent,
-      appendTranscriptTurn, readResultFromLog, enqueueValidation,
-    },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(3);
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    1, '/some/cwd', 'psess-validator-1', expect.stringContaining('111-alpha'),
-    { prdSlug: '111-alpha', outcome: 'completed', validation: 'verified' },
-  );
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    2, '/some/cwd', 'psess-validator-1', expect.stringContaining('222-beta'),
-    { prdSlug: '222-beta', outcome: 'completed', validation: 'refuted' },
-  );
-  expect(appendResponseEvent).toHaveBeenNthCalledWith(
-    3, '/some/cwd', 'psess-validator-1', expect.stringContaining('1407-validator-run'),
-    { prdSlug: '1407-validator-run', outcome: 'completed', validation: 'unvalidated' },
-  );
-  expect(enqueueValidation).not.toHaveBeenCalled();
-});
-
-// ─── PRD 1408: a downstream validator suppresses the per-PRD validation ask ─
-test('skips enqueueValidation when loadJobs reports a pending validator row depending on this job', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const loadJobs = vi.fn(async () => ([
-    { slug: '1408-work-item' },
-    { slug: '1408-validate', agentType: 'validator', status: 'pending', dependsOn: ['1408-work-item'] },
-  ]));
-
-  await notifyOriginatingTab(
-    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(loadJobs).toHaveBeenCalledTimes(1);
-  expect(enqueueValidation).not.toHaveBeenCalled();
-});
-
-test('still enqueues validation when loadJobs reports no downstream validator', async () => {
-  const sendPrompt = vi.fn();
-  const appendResponseEvent = vi.fn(async () => true);
-  const enqueueValidation = vi.fn();
-  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
-  const loadSessions = vi.fn(async () => ({ tabs: [] }));
-  const loadJobs = vi.fn(async () => ([{ slug: '1408-work-item' }]));
-
-  await notifyOriginatingTab(
-    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
-    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
-  );
-
-  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
-  expect(enqueueValidation).toHaveBeenCalledTimes(1);
-});

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;
-  }
-});