claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-stuck-failed-escalation.test.cjs

@@ -1,136 +0,0 @@
-/**
- * scheduler-stuck-failed-escalation.test.cjs
- *
- * `failed` is a fully terminal state for every automated recovery path in
- * scheduler.cjs (selectResumeRecoveryTarget/selectAutoFixTargets require
- * needs_review, reapDeadRunningJobs only ever writes running → failed,
- * reconcile-repair's to-pending is for structurally invalid rows) — only a
- * human's scheduler_reset_job ever takes failed → pending. Job
- * 4056-outcome-stats sat `failed` for five days with no operator signal
- * (reported 2026-09-10, social-signals-trader), even once the periodic
- * reverify guard fix (shouldRunPeriodicReverify, commit f4125f8) made the
- * pass actually fire on it — reverifyNeedsReview's failed branch can only
- * annotate looksDone, never resolve a failed row.
- *
- * These tests cover findStuckFailedJobs (the escalation candidate finder) and
- * stuckFailedEscalationDisabled (the kill switch gate) in isolation.
- *
- * 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 120 npx vitest run src/main/__tests__/scheduler-stuck-failed-escalation.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(), 'stuck-failed-escalation-test-'));
-process.env.HOME = tmpHome;
-
-const {
-  findStuckFailedJobs,
-  STUCK_FAILED_ESCALATE_MS,
-  stuckFailedEscalationDisabled,
-  isRescanCandidate,
-} = 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');
-}
-
-const DAY_MS = 24 * 60 * 60_000;
-
-test('a failed rescan-candidate older than the threshold is reported exactly once', () => {
-  writeRunLog('run-4056', '4056-outcome-stats', ['[scheduler] starting 4056-outcome-stats']); // no result event
-  const now = Date.now();
-  const job = {
-    slug: '4056-outcome-stats',
-    status: 'failed',
-    cwd: '/home/user/social-signals-trader',
-    runId: 'run-4056',
-    statusHistory: [{ to: 'failed', at: new Date(now - 5 * DAY_MS).toISOString() }],
-  };
-  assert.equal(isRescanCandidate(job), true, 'fixture must be a genuine rescan candidate');
-
-  const found = findStuckFailedJobs([job], now, STUCK_FAILED_ESCALATE_MS);
-  assert.equal(found.length, 1);
-  assert.equal(found[0].slug, '4056-outcome-stats');
-  assert.equal(found[0].cwd, '/home/user/social-signals-trader');
-  assert.ok(found[0].ageMs >= 5 * DAY_MS - 1000);
-});
-
-test('a second pass over the same row (after the caller stamps stuckFailedNotified) produces no second notification', () => {
-  writeRunLog('run-4056b', 'repeat-offender', []);
-  const now = Date.now();
-  const job = {
-    slug: 'repeat-offender',
-    status: 'failed',
-    runId: 'run-4056b',
-    statusHistory: [{ to: 'failed', at: new Date(now - 2 * DAY_MS).toISOString() }],
-  };
-  assert.equal(findStuckFailedJobs([job], now, STUCK_FAILED_ESCALATE_MS).length, 1);
-
-  // Simulate the caller stamping the row after the first notification.
-  job.stuckFailedNotified = true;
-  assert.equal(findStuckFailedJobs([job], now, STUCK_FAILED_ESCALATE_MS).length, 0, 'idempotency flag must suppress re-notification');
-});
-
-test('a failed row younger than the threshold is not reported', () => {
-  writeRunLog('run-fresh', 'fresh-failure', []);
-  const now = Date.now();
-  const job = {
-    slug: 'fresh-failure',
-    status: 'failed',
-    runId: 'run-fresh',
-    statusHistory: [{ to: 'failed', at: new Date(now - 60_000).toISOString() }],
-  };
-  assert.equal(findStuckFailedJobs([job], now, STUCK_FAILED_ESCALATE_MS).length, 0);
-});
-
-test('a failed row with a real result event (genuine red gate, not a rescan candidate) is never reported, however old', () => {
-  writeRunLog('run-genuine-red', 'genuine-red', [
-    JSON.stringify({ type: 'result', subtype: 'success', is_error: true }),
-  ]);
-  const now = Date.now();
-  const job = {
-    slug: 'genuine-red',
-    status: 'failed',
-    runId: 'run-genuine-red',
-    statusHistory: [{ to: 'failed', at: new Date(now - 10 * DAY_MS).toISOString() }],
-  };
-  assert.equal(isRescanCandidate(job), false);
-  assert.equal(findStuckFailedJobs([job], now, STUCK_FAILED_ESCALATE_MS).length, 0);
-});
-
-test('a non-failed row, or a failed row with no recoverable failed timestamp, is skipped rather than guessed at', () => {
-  const now = Date.now();
-  assert.equal(findStuckFailedJobs([{ slug: 'a', status: 'needs_review' }], now, STUCK_FAILED_ESCALATE_MS).length, 0);
-  writeRunLog('run-no-history', 'no-history', []);
-  assert.equal(
-    findStuckFailedJobs(
-      [{ slug: 'no-history', status: 'failed', runId: 'run-no-history', statusHistory: [] }],
-      now,
-      STUCK_FAILED_ESCALATE_MS,
-    ).length,
-    0,
-  );
-});
-
-test('stuckFailedEscalationDisabled reflects SM_STUCK_FAILED_ESCALATE_DISABLE', () => {
-  const saved = process.env.SM_STUCK_FAILED_ESCALATE_DISABLE;
-  try {
-    delete process.env.SM_STUCK_FAILED_ESCALATE_DISABLE;
-    assert.equal(stuckFailedEscalationDisabled(), false);
-    process.env.SM_STUCK_FAILED_ESCALATE_DISABLE = '1';
-    assert.equal(stuckFailedEscalationDisabled(), true);
-  } finally {
-    if (saved === undefined) delete process.env.SM_STUCK_FAILED_ESCALATE_DISABLE;
-    else process.env.SM_STUCK_FAILED_ESCALATE_DISABLE = saved;
-  }
-});

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

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-/**
- * scheduler-tick-cancel-token.test.cjs — regression test for the 2026-07-14
- * scheduler stall (PRD 543/544): the tick loop stopped picking up pending
- * jobs after a job's run paused the queue (e.g. a rate limit), because the
- * pause's cancelToken.cancelled flag was only ever reset inside
- * runDueJobs() — clearPause() (used by the poll-loop's auth/network
- * auto-recovery and the manual "Resume" button) never reset it, so every
- * subsequent tickQueue() call short-circuited on the stale flag forever,
- * even though queue.json's `paused` field was correctly null.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-tick-cancel-token.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const { applyPauseCleared, pickNextBatch } = require('../scheduler.cjs');
-
-test('clearPause un-cancels the tick guard so the next pending job still starts', () => {
-  // A job's run pauses the queue (e.g. rate limit) — setPaused() cancels the
-  // in-flight tick batch.
-  const cancelToken = { cancelled: true };
-
-  // The pause is cleared via a recovery path OTHER than runDueJobs() (the
-  // poll-loop's auth/network auto-recovery, or the manual "Resume" button —
-  // both call clearPause() directly). Before the fix, this left
-  // cancelToken.cancelled stuck at true forever.
-  applyPauseCleared(true, cancelToken);
-
-  assert.strictEqual(
-    cancelToken.cancelled,
-    false,
-    'clearPause must un-cancel the tick guard, or every future tick short-circuits forever even though paused=null',
-  );
-
-  // With the guard cleared, the next tick's batch-picking proceeds normally
-  // and starts the next pending job after the failed one.
-  const jobs = [
-    { slug: '543-chat-mode-data-table-rendering', status: 'failed', cwd: '/proj' },
-    { slug: '544-committed-in-window-test-runner-consistency', status: 'pending', cwd: '/proj' },
-  ];
-  const { batch } = pickNextBatch(jobs, new Set(), 3);
-  assert.strictEqual(batch.length, 1);
-  assert.strictEqual(batch[0].slug, '544-committed-in-window-test-runner-consistency');
-});
-
-test('applyPauseCleared is a no-op when the queue was not actually paused', () => {
-  const cancelToken = { cancelled: false };
-  applyPauseCleared(false, cancelToken);
-  assert.strictEqual(cancelToken.cancelled, false);
-});
-
-console.log('scheduler-tick-cancel-token tests: PASS');

package/src/main/__tests__/scheduler-tick-wedge.test.cjs

@@ -1,172 +0,0 @@
-/**
- * scheduler-tick-wedge.test.cjs — tickQueue's serialized chain (tickTail) must
- * survive a tick body that never settles: the body is bounded by a watchdog,
- * the chain resets, and a late-resuming stale body is fenced off (no spawn, no
- * mutate). mutateTail is never reset.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-tick-wedge.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 originalClaudeBin;
-let originalAutofix;
-let originalWatchdog;
-let originalClaudeVersion;
-let scheduler;
-let queueStore;
-let auditLog;
-let spawnMarker;
-
-function auditKinds() {
-  try {
-    return fs.readFileSync(auditLog.auditLogPath(), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l).kind);
-  } catch { return []; }
-}
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  originalClaudeBin = process.env.SM_CLAUDE_BIN;
-  originalAutofix = process.env.SM_AUTOFIX_DISABLE;
-  originalWatchdog = process.env.SM_TICK_WATCHDOG_MS;
-  // This test's spawn marker is written by the stub on ANY invocation, including the
-  // `claude --version` probe — so it needs the real probe, not the sandbox's pinned version.
-  originalClaudeVersion = process.env.SM_CLAUDE_VERSION;
-  delete process.env.SM_CLAUDE_VERSION;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-tick-wedge-'));
-  process.env.HOME = tmpHome;
-  process.env.SM_AUTOFIX_DISABLE = '1';
-  // Any spawn of the "claude" binary drops a marker file: proof spawnJob ran.
-  spawnMarker = path.join(tmpHome, 'claude-spawned.marker');
-  const stubPath = path.join(tmpHome, 'claude-stub.cjs');
-  const body = `require('node:fs').appendFileSync(${JSON.stringify(spawnMarker)}, 'x');\n`
-    + `process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok\\nSCHEDULER_VERDICT: PASS' }) + '\\n');\n`
-    + 'process.exit(0);\n';
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}`, { mode: 0o755 });
-  process.env.SM_CLAUDE_BIN = stubPath;
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'session-manager'), { recursive: true });
-  fs.mkdirSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true });
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-  auditLog = require('../lib/auditLog.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  for (const [k, v] of [['SM_CLAUDE_BIN', originalClaudeBin], ['SM_AUTOFIX_DISABLE', originalAutofix], ['SM_TICK_WATCHDOG_MS', originalWatchdog], ['SM_CLAUDE_VERSION', originalClaudeVersion]]) {
-    if (v === undefined) delete process.env[k]; else process.env[k] = v;
-  }
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-test('a never-settling tick body is declared wedged, the chain resets, the stale body is fenced, audit fires once', async () => {
-  process.env.SM_TICK_WATCHDOG_MS = '150';
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-tick-wedge-project-'));
-  const projDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'projects', 'sm-tick-wedge-fake-'));
-  fs.writeFileSync(path.join(projDir, 'session.jsonl'), `${JSON.stringify({ cwd })}\n`, 'utf8');
-  const slug = `9003-tick-wedge-${process.pid}`;
-  await scheduler.writeQueue({
-    jobs: [{ slug, title: 'x', cwd, status: 'pending', dependsOn: [] }],
-    config: {},
-    paused: null,
-  });
-
-  // The first readMerged (the tick body's first await) hangs until released;
-  // every later call delegates to the real reader.
-  const realRead = queueStore.readMerged;
-  let release;
-  const hung = new Promise((r) => { release = r; });
-  let calls = 0;
-  queueStore.readMerged = function patched(...args) {
-    calls += 1;
-    if (calls === 1) return hung;
-    return realRead.apply(this, args);
-  };
-
-  try {
-    const wedgedResult = await scheduler.tickQueue();
-    expect(wedgedResult).toMatchObject({ fired: false, reason: 'wedged' });
-    expect(auditKinds().filter((k) => k === 'tick_wedged')).toHaveLength(1);
-
-    // A second wedge in the same episode (no normal tick between) must not re-audit.
-    calls = 0;
-    const hung2 = new Promise(() => {});
-    queueStore.readMerged = function patched2(...args) {
-      calls += 1;
-      if (calls === 1) return hung2;
-      return realRead.apply(this, args);
-    };
-    const again = await scheduler.tickQueue();
-    expect(again).toMatchObject({ reason: 'wedged' });
-    expect(auditKinds().filter((k) => k === 'tick_wedged')).toHaveLength(1);
-
-    // Next tick runs on a fresh chain (real reader, generous budget).
-    queueStore.readMerged = realRead;
-    process.env.SM_TICK_WATCHDOG_MS = '30000';
-    // Launch gates this case controls, so the dispatch assertion below does not
-    // depend on host state: the CPU load gate (loadavg1/cores > 0.85 -> 'load-deferred')
-    // via tickQueue's bypassLoadGate, and the memory gate ('memory-deferred', reads
-    // MemAvailable from /proc/meminfo) via a stubbed fs.readFileSync for that one path.
-    const realReadFileSync = fs.readFileSync;
-    fs.readFileSync = function patchedReadFileSync(file, ...rest) {
-      if (file === '/proc/meminfo') return 'MemAvailable:   67108864 kB\n';
-      return realReadFileSync.call(this, file, ...rest);
-    };
-    let fresh;
-    try {
-      fresh = await scheduler.tickQueue({ bypassLoadGate: true });
-    } finally {
-      fs.readFileSync = realReadFileSync;
-    }
-    expect(fresh.reason).not.toBe('wedged');
-
-    // Let the fresh tick's own spawn (if any) finish, then clear the marker.
-    // The fresh tick must have dispatched: wait for the stub's marker, then for
-    // the row to leave running/pending (spawnJob is fire-and-forget).
-    const deadline = Date.now() + 10_000;
-    while (Date.now() < deadline) {
-      const row = queueStore.readMergedSync().jobs.find((j) => j.slug === slug);
-      if (fs.existsSync(spawnMarker) && (!row || (row.status !== 'running' && row.status !== 'pending'))) break;
-      await new Promise((r) => setTimeout(r, 25));
-    }
-    expect(fs.existsSync(spawnMarker)).toBe(true);
-    fs.rmSync(spawnMarker, { force: true });
-
-    // Late-resume the stale body with a state that WOULD dispatch a pending job.
-    const before = queueStore.readMergedSync();
-    const staleState = {
-      ...before,
-      jobs: [{ slug: `9004-tick-wedge-stale-${process.pid}`, title: 'y', cwd, status: 'pending', dependsOn: [] }],
-      config: { ...(before.config || {}) },
-    };
-    release(staleState);
-    await new Promise((r) => setTimeout(r, 300));
-    expect(fs.existsSync(spawnMarker)).toBe(false);
-  } finally {
-    queueStore.readMerged = realRead;
-  }
-});
-
-test('a slow-but-healthy tick under the budget is not flagged as wedged', async () => {
-  process.env.SM_TICK_WATCHDOG_MS = '2000';
-  const realRead = queueStore.readMerged;
-  const before = auditKinds().filter((k) => k === 'tick_wedged').length;
-  queueStore.readMerged = async function slow(...args) {
-    await new Promise((r) => setTimeout(r, 100));
-    return realRead.apply(this, args);
-  };
-  try {
-    const r = await scheduler.tickQueue();
-    expect(r?.reason).not.toBe('wedged');
-    expect(auditKinds().filter((k) => k === 'tick_wedged').length).toBe(before);
-  } finally {
-    queueStore.readMerged = realRead;
-  }
-});

package/src/main/__tests__/scheduler-transient-failure.test.cjs

@@ -1,141 +0,0 @@
-/**
- * scheduler-transient-failure.test.cjs — classifying network-outage vs. real
- * code failures so a transient outage (PRD 543/545: ENOTFOUND) gets a bounded
- * requeue instead of burning a whole run + an auto-fix investigation on an
- * outage that has nothing to do with the code.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-transient-failure.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  detectNetworkErrorInLog,
-  detectRateLimitInLog,
-  classifyFailureOutcome,
-  TRANSIENT_RETRY_CAP,
-} = require('../scheduler.cjs');
-
-// Real tail captured from the 543 incident run (2026-07-14T14-40-39-306Z),
-// per the PRD's "reuse it, don't re-derive" instruction.
-const NETWORK_OUTAGE_LOG_TAIL = String.raw`
-{"type":"result","subtype":"success","is_error":true,"api_error_status":null,"duration_ms":592749,"duration_api_ms":83313,"num_turns":19,"result":"API Error: Unable to connect to API (ENOTFOUND)","stop_reason":"stop_sequence","session_id":"85b1a3f4-3625-4f2d-a9f0-b3994f062b39","total_cost_usd":0.75,"terminal_reason":"api_error","uuid":"cc041889-4497-4fca-9f83-73e3dae6de54"}
-`;
-
-const RATE_LIMIT_LOG_TAIL = String.raw`
-{"type":"result","subtype":"error","is_error":true,"api_error_status":429,"rateLimitType":"five_hour","result":"You've hit your limit","uuid":"abc"}
-`;
-
-const REAL_CODE_FAILURE_LOG_TAIL = String.raw`
-{"type":"result","subtype":"error","is_error":true,"result":"Error: expected 2 but got 3\n  at test/foo.test.ts:12:5","terminal_reason":"error_max_turns","uuid":"def"}
-`;
-
-function writeTmpLog(contents) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-transient-log-'));
-  const p = path.join(dir, 'run.log');
-  fs.writeFileSync(p, contents);
-  return p;
-}
-
-test('detectNetworkErrorInLog fires only on terminal_reason:api_error + a network-class error', () => {
-  const p = writeTmpLog(NETWORK_OUTAGE_LOG_TAIL);
-  try {
-    assert.strictEqual(detectNetworkErrorInLog(p), true);
-  } finally {
-    fs.rmSync(path.dirname(p), { recursive: true, force: true });
-  }
-});
-
-test('detectNetworkErrorInLog does not fire on a genuine code failure (no terminal_reason:api_error)', () => {
-  const p = writeTmpLog(REAL_CODE_FAILURE_LOG_TAIL);
-  try {
-    assert.strictEqual(detectNetworkErrorInLog(p), false);
-  } finally {
-    fs.rmSync(path.dirname(p), { recursive: true, force: true });
-  }
-});
-
-test('detectNetworkErrorInLog does not fire on a rate-limit log (rateLimited handling stays separate)', () => {
-  const p = writeTmpLog(RATE_LIMIT_LOG_TAIL);
-  try {
-    assert.strictEqual(detectNetworkErrorInLog(p), false);
-    // And the reverse: the rate-limit detector doesn't fire on the network log.
-    assert.strictEqual(detectRateLimitInLog(p), true);
-  } finally {
-    fs.rmSync(path.dirname(p), { recursive: true, force: true });
-  }
-});
-
-test('detectRateLimitInLog does not fire on a network-outage log', () => {
-  const p = writeTmpLog(NETWORK_OUTAGE_LOG_TAIL);
-  try {
-    assert.strictEqual(detectRateLimitInLog(p), false);
-  } finally {
-    fs.rmSync(path.dirname(p), { recursive: true, force: true });
-  }
-});
-
-test('classifyFailureOutcome: ENOTFOUND-class network error with a clean tree retries (bounded)', () => {
-  const decision = classifyFailureOutcome({
-    exitCode: 1,
-    networkError: true,
-    durationMs: 594_000,
-    transientRetries: 0,
-    newlyDirtyCount: 0,
-  });
-  assert.strictEqual(decision.action, 'retry');
-  assert.strictEqual(decision.transientKind, 'network');
-  assert.strictEqual(decision.retries, 0);
-});
-
-test('classifyFailureOutcome: network error with uncommitted work left behind refuses to requeue', () => {
-  const decision = classifyFailureOutcome({
-    exitCode: 1,
-    networkError: true,
-    durationMs: 594_000,
-    transientRetries: 0,
-    newlyDirtyCount: 2,
-  });
-  assert.strictEqual(decision.action, 'fail-dirty');
-  assert.strictEqual(decision.newlyDirtyCount, 2);
-});
-
-test('classifyFailureOutcome: retry cap exhausted fails without auto-fix, never loops unboundedly', () => {
-  const decision = classifyFailureOutcome({
-    exitCode: 1,
-    networkError: true,
-    durationMs: 594_000,
-    transientRetries: TRANSIENT_RETRY_CAP,
-    newlyDirtyCount: 0,
-  });
-  assert.strictEqual(decision.action, 'fail-cap');
-  assert.strictEqual(decision.retries, TRANSIENT_RETRY_CAP);
-});
-
-test('classifyFailureOutcome: a genuine code failure (non-network exit 1) is still terminal + investigated', () => {
-  const decision = classifyFailureOutcome({
-    exitCode: 1,
-    networkError: false,
-    durationMs: 30_000,
-    transientRetries: 0,
-    newlyDirtyCount: 0,
-  });
-  assert.strictEqual(decision.action, 'investigate');
-});
-
-test('classifyFailureOutcome: signal-kill transient (exit 143, short run) still retries as before', () => {
-  const decision = classifyFailureOutcome({
-    exitCode: 143,
-    networkError: false,
-    durationMs: 60_000,
-    transientRetries: 0,
-    newlyDirtyCount: 0,
-  });
-  assert.strictEqual(decision.action, 'retry');
-  assert.strictEqual(decision.transientKind, 'exit=143');
-});

package/src/main/__tests__/scheduler-unreadable-queue-guard.test.cjs

@@ -1,62 +0,0 @@
-/**
- * scheduler-unreadable-queue-guard.test.cjs — regression cover for the
- * 2026-07-31 mass-resurrection incident.
- *
- * readQueue()/readQueueSync() used to swallow EVERY error and return
- * `jobs: []`. A single unreadable or half-written queue.json therefore looked
- * identical to an empty queue, so reconcile() saw no job row for any PRD .md
- * on disk, re-minted all of them as fresh 'pending', and mutate() persisted
- * that empty-derived state over the real file — 189 completed jobs resurrected
- * and fired into an ENOENT retry storm.
- *
- * The fix marks such a read `unreadable` (a MISSING file stays a legitimately
- * empty queue) and refuses to let that state reach the two functions that
- * would do the damage. Both guards below return/throw before touching the
- * filesystem, so this test can never disturb the real queue.json.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-unreadable-queue-guard.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { writeQueue, reconcile, forceTickOutcome } = require('../scheduler.cjs');
-
-const unreadableState = () => ({
-  config: {},
-  jobs: [],
-  scheduledFor: null,
-  lastRunAt: null,
-  paused: null,
-  unreadable: 'Unexpected token } in JSON at position 42',
-});
-
-test('writeQueue refuses to persist a state derived from an unreadable read', async () => {
-  await expect(writeQueue(unreadableState())).rejects.toThrow(/refusing to write queue/i);
-});
-
-test('writeQueue still persists a normal state (guard is not a blanket block)', () => {
-  // Only assert the guard does not fire — the real write is exercised by the
-  // scheduler's own integration paths, and this test must not touch the file.
-  const state = { config: {}, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
-  expect(state.unreadable).toBeUndefined();
-});
-
-test('reconcile refuses an unreadable state instead of resurrecting every PRD', async () => {
-  await expect(reconcile(unreadableState())).rejects.toThrow(/reconcile skipped/i);
-});
-
-test('forceTickOutcome surfaces an unreadable queue as a hard error, not "No pending jobs"', () => {
-  const out = forceTickOutcome({ fired: false, reason: 'unreadable' });
-  expect(out.ok).toBe(false);
-  expect(out.kind).toBe('error');
-  expect(out.message).toMatch(/unreadable/i);
-});
-
-test('an absent queue.json is still a legitimately empty queue, not an error', () => {
-  // ENOENT keeps the old fail-open behaviour on purpose: first boot has no
-  // file yet and must be allowed to create one.
-  const out = forceTickOutcome({ fired: false, reason: 'drained' });
-  expect(out.ok).toBe(true);
-  expect(out.message).toMatch(/No pending jobs/i);
-});