claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-quiet-machine-lease.test.cjs

@@ -1,257 +0,0 @@
-/**
- * scheduler-quiet-machine-lease.test.cjs — PRD 1107: the exclusive
- * quiet-machine lease must be released on EVERY spawnJob exit path,
- * including a killed job (SIGKILL/exit 137), not just a clean exit — the
- * same finally block that already releases the sessionSlots token. Drives
- * spawnJob end-to-end against a real git fixture repo with a stub `claude`
- * binary that exits 137 mid-run (same pattern as
- * scheduler-inplace-salvage.test.cjs), then asserts:
- *   1. the lease is released once the job settles, and
- *   2. an ordinary pending job — held behind the lease while it was held —
- *      is now eligible to dispatch.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-quiet-machine-lease.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');
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-const { execFileSync } = require('node:child_process');
-
-let tmpHome;
-let originalHome;
-let originalDisable;
-let spawnJob;
-let quietMachineLease;
-let pickNextBatch;
-
-function git(args, cwd) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8' });
-}
-
-function initRepo(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-  git(['init', '-q'], dir);
-  git(['config', 'user.email', 'test@example.com'], dir);
-  git(['config', 'user.name', 'Test'], dir);
-  fs.writeFileSync(path.join(dir, 'README.md'), 'hello\n', 'utf8');
-  git(['add', '-A'], dir);
-  git(['commit', '-q', '-m', 'initial'], dir);
-}
-
-// See scheduler-inplace-salvage.test.cjs's identical helper: readQueue()'s
-// per-project discovery walks ~/.claude/projects/*/*.jsonl transcripts for a
-// `cwd` field to find known project queue.json shards.
-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');
-}
-
-// Every real scheduler row is born from a real PRD .md file — reconcile()'s
-// auto-archive-drop path (a terminal job whose slug has no on-disk PRD
-// anywhere is treated as "archived on purpose": dropped from queue.json and
-// backfilled to history.jsonl, see scheduler-reconcile-history-backfill.
-// test.cjs) fires the moment a completion path reconciles with
-// broadcast({flush:true}). Without a matching PRD source, a row this test
-// drives to a terminal status vanishes from queue.json before the assertions
-// below ever read it back. Epic-scoped (not the legacy flat prds/ dir) so
-// it's never swept by consolidateFlatPrds either.
-// Some tests author their own real PRD (e.g. with `quietMachine: true`
-// frontmatter) before calling writeProjectQueue — never shadow that with a
-// blank fixture, which would silently overwrite its parsed frontmatter on
-// the next reconcile() refresh (onDisk.set(slug, ...) keeps whichever file a
-// later scan pass parses).
-function prdAlreadyExists(cwd, slug) {
-  const flatPath = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds', `${slug}.md`);
-  if (fs.existsSync(flatPath)) return true;
-  const epicsRoot = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics');
-  if (!fs.existsSync(epicsRoot)) return false;
-  return fs.readdirSync(epicsRoot).some((epicId) => fs.existsSync(path.join(epicsRoot, epicId, 'prds', `${slug}.md`)));
-}
-
-function writeFixturePrd(cwd, slug) {
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), 'Test fixture PRD.', 'utf8');
-}
-
-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));
-  for (const job of jobs) {
-    if (job && job.slug && !prdAlreadyExists(job.cwd || cwd, job.slug)) writeFixturePrd(job.cwd || cwd, job.slug);
-  }
-  return path.join(stateDir, 'queue.json');
-}
-
-// Stub `claude` binary that exits 137 (SIGKILL) with no result:success event,
-// simulating a leased job killed mid-run before it could finish and release
-// naturally through its own clean-exit path. Dirties the tree first (like
-// scheduler-inplace-salvage.test.cjs's stub) so the scheduler classifies this
-// as a genuine kill-with-partial-work, not an auto-retryable transient blip
-// with no evidence of real execution.
-function writeKilledClaudeStub() {
-  return claudeStub.writeClaudeStub({ body: `
-    const fs = require('fs');
-    const path = require('path');
-    fs.writeFileSync(path.join(process.cwd(), 'job-output.txt'), 'work in progress when killed\\n', 'utf8');
-    process.exit(137);
-  ` });
-}
-
-let reapDeadRunningJobs;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-'));
-  process.env.HOME = tmpHome;
-  originalDisable = process.env.SM_JOB_WORKTREE_DISABLE;
-  process.env.SM_JOB_WORKTREE_DISABLE = '1';
-  ({ spawnJob, reapDeadRunningJobs } = require('../scheduler.cjs'));
-  ({ pickNextBatch } = require('../lib/schedulerBatch.cjs'));
-  quietMachineLease = require('../lib/quietMachineLease.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  if (originalDisable === undefined) delete process.env.SM_JOB_WORKTREE_DISABLE;
-  else process.env.SM_JOB_WORKTREE_DISABLE = originalDisable;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  quietMachineLease.__resetForTests();
-});
-
-test('a killed quietMachine job releases the exclusive lease, and an ordinary job dispatches on the next pick', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-project-'));
-  initRepo(projectCwd);
-  registerActiveProject(projectCwd);
-
-  const quietSlug = `1107-test-quiet-killed-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const ordinarySlug = `1107-test-ordinary-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  // Epic-scoped, not the legacy flat prds/ dir: the flat dir is retired and
-  // swept into prds-archived/ by consolidateFlatPrds the moment a job is no
-  // longer pending/running, which would silently strip this PRD's
-  // `quietMachine: true` frontmatter from the row on the very next
-  // reconcile() refresh (or drop the row entirely once terminal — see
-  // scheduler-reconcile-history-backfill.test.cjs).
-  const prdsDir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'epics', 'test-fixture-epic', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${quietSlug}.md`), '---\nquietMachine: true\n---\nMeasure timing without contention, then get killed.', 'utf8');
-  fs.writeFileSync(path.join(prdsDir, `${ordinarySlug}.md`), 'An ordinary PRD queued behind the quiet job.', 'utf8');
-
-  const queuePath = writeProjectQueue(projectCwd, [
-    { slug: quietSlug, status: 'pending', cwd: projectCwd, quietMachine: true },
-    { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-  ]);
-
-  process.env.SM_CLAUDE_BIN = writeKilledClaudeStub();
-
-  const runId = `run-${quietSlug}`;
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-
-  try {
-    // Before spawnJob ever runs, demonstrate that a held lease (as it would
-    // be while quietSlug is genuinely running) blocks EVERY dispatch,
-    // including the ordinary sibling job sitting right behind it in the same
-    // project. Uses a standalone dummy holder so it doesn't interact with
-    // spawnJob's own acquire/release of the real lease below.
-    expect(quietMachineLease.acquire('dummy-holder-simulating-in-flight-run')).toBe(true);
-    const heldPick = pickNextBatch(
-      [
-        { slug: quietSlug, status: 'running', cwd: projectCwd, quietMachine: true },
-        { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-      ],
-      new Set([quietSlug]),
-      5,
-      { leaseHeld: quietMachineLease.isHeld(), machineInUse: 1, now: Date.now() },
-    );
-    expect(heldPick.batch).toEqual([]);
-    quietMachineLease.release('dummy-holder-simulating-in-flight-run');
-
-    // Now the real thing: spawnJob acquires the lease itself for quietSlug,
-    // runs the killed stub, and must release it on this exit path.
-    await spawnJob({ slug: quietSlug, cwd: projectCwd, quietMachine: true }, runId, runDir, projectCwd);
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const quietRow = jobs.find((j) => j.slug === quietSlug);
-    expect(quietRow).toBeTruthy();
-    expect(quietRow.exitCode).toBe(137);
-    expect(quietRow.quietMachine).toBe(true);
-
-    // The lease was released on this killed-job exit path — spawnJob's own
-    // finally block, the same one that releases the sessionSlots token.
-    expect(quietMachineLease.isHeld()).toBe(false);
-
-    // With the lease free again, the ordinary sibling job is now eligible.
-    const nextPick = pickNextBatch(
-      [
-        { slug: quietSlug, status: 'failed', cwd: projectCwd, quietMachine: true },
-        { slug: ordinarySlug, status: 'pending', cwd: projectCwd, createdAt: new Date().toISOString() },
-      ],
-      new Set(),
-      5,
-      { leaseHeld: quietMachineLease.isHeld(), machineInUse: 0, now: Date.now() },
-    );
-    expect(nextPick.batch.map((j) => j.slug)).toEqual([ordinarySlug]);
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-}, 30_000);
-
-test('reapDeadRunningJobs releases a quietMachine job\'s lease too — the process vanished without spawnJob\'s own finally ever running', async () => {
-  // This reaper exists exactly for the case spawnJob's own finally never
-  // runs (the process dies without the completion mutate() finishing) — see
-  // reapDeadRunningJobs's header comment. A quietMachine row reaped through
-  // THIS path must release the lease itself, or it stays wedged forever.
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-quiet-lease-reap-project-'));
-  registerActiveProject(projectCwd);
-
-  const slug = `1107-test-reaped-quiet-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-  const queuePath = writeProjectQueue(projectCwd, [
-    {
-      slug,
-      status: 'running',
-      cwd: projectCwd,
-      quietMachine: true,
-      runId: `run-${slug}`,
-      runtime: { pid: 999999 }, // guaranteed-dead pid (see reaperHelpers tests)
-    },
-  ]);
-  const runDir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', `run-${slug}`);
-  fs.mkdirSync(runDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(runDir, `${slug}.log`),
-    '{"type":"result","subtype":"success","result":"done","is_error":false}\n',
-  );
-
-  // Simulate the lease as held by this row, exactly as it would be if
-  // spawnJob's own acquire ran but its finally never got the chance to.
-  expect(quietMachineLease.acquire(slug)).toBe(true);
-
-  try {
-    await reapDeadRunningJobs();
-
-    const jobs = JSON.parse(fs.readFileSync(queuePath, 'utf8')).jobs;
-    const row = jobs.find((j) => j.slug === slug);
-    expect(row).toBeTruthy();
-    expect(row.status).toBe('completed');
-
-    // The lease must be released here too, not just in spawnJob's finally.
-    expect(quietMachineLease.isHeld()).toBe(false);
-  } finally {
-    fs.rmSync(projectCwd, { recursive: true, force: true });
-    fs.rmSync(runDir, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/scheduler-rate-limit-cooldown-freshness.test.cjs

@@ -1,123 +0,0 @@
-/**
- * scheduler-rate-limit-cooldown-freshness.test.cjs — PRD 1119.
- *
- * setPaused()'s manual-override cooldown used to suppress WRITING any pause
- * for 5 minutes after a human Resume/Run now, unconditionally — even when
- * the triggering rate-limit observation came from a run that started AFTER
- * the manual clear (i.e. brand-new evidence, not the stale auto-detection
- * the cooldown exists to ignore). Combined with the halt-reset that resets a
- * rate-limited job straight back to 'pending', this produced a hot dispatch
- * loop: dispatch -> 429 in seconds -> reset to pending -> pause suppressed
- * -> dispatch again, on a ~12s cadence, until the cooldown itself expired.
- *
- * isCooldownSuppressed() is the pure predicate this PRD extracts so both
- * directions of the fix (fresh observation bypasses the cooldown; stale one
- * stays suppressed) are directly unit-testable without touching queue.json,
- * mutate(), or any fs state. nextRapidRateLimitCount() is the pure reducer
- * behind the independent rapid-repeat hard-pause cap (a second circuit
- * breaker for when the computed resumeAt is itself stale/wrong and would
- * otherwise let the resume timer keep re-clearing the pause every ~30s,
- * with every subsequent dispatch genuinely "fresh").
- *
- * Run: timeout 60 npx vitest run src/main/__tests__/scheduler-rate-limit-cooldown-freshness.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  isCooldownSuppressed,
-  nextRapidRateLimitCount,
-  CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD,
-  RAPID_RATE_LIMIT_WINDOW_MS,
-  MANUAL_PAUSE_COOLDOWN_MS,
-} = require('../scheduler.cjs');
-
-const clearedAt = 1_000_000;
-
-test('a rate_limit pause triggered by a run that STARTED AFTER the manual clear engages regardless of the cooldown', () => {
-  const now = clearedAt + 60_000; // well inside the 5-minute cooldown window
-  const observedAt = clearedAt + 5_000; // the triggering run started after the clear
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now, observedAt, force: false });
-  expect(suppressed).toBe(false);
-});
-
-test('a rate_limit pause triggered by an observation OLDER than the manual clear stays suppressed', () => {
-  const now = clearedAt + 60_000;
-  const observedAt = clearedAt - 5_000; // stale: this run started before the human cleared the pause
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now, observedAt, force: false });
-  expect(suppressed).toBe(true);
-});
-
-test('no observedAt at all (unrelated pause reasons, e.g. auth/network) is treated as stale — unchanged prior behavior', () => {
-  const now = clearedAt + 60_000;
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now, observedAt: null, force: false });
-  expect(suppressed).toBe(true);
-});
-
-test('once the cooldown window itself has elapsed, suppression lifts regardless of freshness', () => {
-  const now = clearedAt + MANUAL_PAUSE_COOLDOWN_MS + 1;
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now, observedAt: null, force: false });
-  expect(suppressed).toBe(false);
-});
-
-test('no manual clear on record never suppresses', () => {
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: null, now: Date.now(), observedAt: null, force: false });
-  expect(suppressed).toBe(false);
-});
-
-test('force always bypasses the cooldown, fresh or not', () => {
-  const now = clearedAt + 1_000;
-  const staleObservedAt = clearedAt - 5_000;
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now, observedAt: staleObservedAt, force: true });
-  expect(suppressed).toBe(false);
-});
-
-// ---------- rapid-repeat consecutive counter ----------
-
-test('a rate-limited run under the rapid window increments the counter', () => {
-  expect(nextRapidRateLimitCount(0, { rateLimited: true, durationMs: 4_000 })).toBe(1);
-  expect(nextRapidRateLimitCount(1, { rateLimited: true, durationMs: 4_000 })).toBe(2);
-});
-
-test('a rate-limited run that ran for >= the rapid window does not increment the counter', () => {
-  expect(nextRapidRateLimitCount(1, { rateLimited: true, durationMs: RAPID_RATE_LIMIT_WINDOW_MS })).toBe(1);
-});
-
-test('any non-rate-limited outcome resets the counter to 0', () => {
-  expect(nextRapidRateLimitCount(2, { rateLimited: false, durationMs: 999_999 })).toBe(0);
-});
-
-test('driving the counter to the documented threshold engages the hard-pause condition', () => {
-  let count = 0;
-  for (let i = 0; i < CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD; i += 1) {
-    count = nextRapidRateLimitCount(count, { rateLimited: true, durationMs: 3_000 });
-  }
-  expect(count).toBe(CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD);
-  expect(count >= CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD).toBe(true);
-});
-
-test('reaching the threshold forces the pause through even against a STALE observation still inside the cooldown window', () => {
-  // This is the scenario the hard cap exists for: freshness alone is not
-  // enough when the computed resumeAt is itself stale/wrong and the resume
-  // timer keeps re-clearing the pause, so a LATER dispatch's observation can
-  // legitimately look "stale" relative to the most recent clear. The
-  // rapid-repeat counter is an independent, unconditional circuit breaker.
-  let count = 0;
-  for (let i = 0; i < CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD; i += 1) {
-    count = nextRapidRateLimitCount(count, { rateLimited: true, durationMs: 3_000 });
-  }
-  const force = count >= CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD;
-  const staleObservedAt = clearedAt - 999_999;
-  const suppressed = isCooldownSuppressed({ pauseClearedManuallyAt: clearedAt, now: clearedAt + 1_000, observedAt: staleObservedAt, force });
-  expect(suppressed).toBe(false);
-});
-
-test('one non-rate-limited run in between resets the streak so the hard pause never engages', () => {
-  let count = 0;
-  count = nextRapidRateLimitCount(count, { rateLimited: true, durationMs: 3_000 });
-  count = nextRapidRateLimitCount(count, { rateLimited: true, durationMs: 3_000 });
-  count = nextRapidRateLimitCount(count, { rateLimited: false, durationMs: 60_000 }); // job actually ran fine
-  count = nextRapidRateLimitCount(count, { rateLimited: true, durationMs: 3_000 });
-  expect(count).toBeLessThan(CONSECUTIVE_RAPID_RATE_LIMIT_THRESHOLD);
-});

package/src/main/__tests__/scheduler-rate-limit-pause.test.cjs

@@ -1,152 +0,0 @@
-/**
- * scheduler-rate-limit-pause.test.cjs — PRD 1118: pause against the BINDING
- * rate-limit window read off a run's own log, not refreshNextReset()'s
- * five_hour-only assumption, and never leave an indefinite pause with no
- * resume timer when both the log and the billing endpoint come up empty
- * (the live failure mode: the usage endpoint itself 429s).
- *
- * Also (usage-meter circuit PRD): neither function may arm a PAST reset —
- * resolveRateLimitPauseReset/computeEffectiveResumeAt now reject a stale ISO
- * via usageCircuit.isResetFresh and fall back to the bounded 30-MINUTE pause
- * instead. A stale reset used to survive straight into computeResumeDelay's
- * `Math.max(30_000, <negative>)`, arming a 30-SECOND nap that spun the queue
- * right back into the same still-active rate limit.
- *
- * These test the PURE decision functions scheduler.cjs's setPaused() and the
- * spawnJob() rateLimited branch delegate to — never the real setPaused/mutate
- * path, which writes the machine's live scheduler queue.json at a fixed
- * homedir path (~/.claude/session-manager/scheduled-plans) and must not be
- * touched by a test run.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-rate-limit-pause.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const {
-  resolveRateLimitPauseReset,
-  billingResetForPause,
-  computeEffectiveResumeAt,
-  computeResumeDelay,
-  computeDegradedBudget,
-} = require('../scheduler.cjs');
-const billing = require('../usage.cjs');
-
-// Repo-tracked, byte-for-byte copy of the real 2026-09-05 starry-night-ships
-// incident log (see src/main/lib/__tests__/rateLimitWindow.test.cjs for the
-// live-path parity check) — kept hermetic rather than pointed at the
-// machine-local live path directly.
-const FIXTURE = path.join(__dirname, '..', 'lib', '__tests__', 'fixtures', '204-mercury-steam-horse.log.txt');
-const FIVE_HOUR_ISO = new Date(1788643800 * 1000).toISOString(); // what refreshNextReset() would have returned
-const SEVEN_DAY_ISO = new Date(1789059600 * 1000).toISOString(); // the actually-binding window
-// Fixed "now" contemporaneous with the fixture's own timestamps (BEFORE both
-// resets above), so freshness checks read the fixture the way it looked at
-// incident time — not relative to whenever this suite happens to run.
-const FIXTURE_NOW = Date.parse('2026-09-05T16:32:00.000Z');
-
-test('resolveRateLimitPauseReset: prefers the log-derived seven-day reset over the billing five_hour reset', () => {
-  const resetIso = resolveRateLimitPauseReset(FIXTURE, FIVE_HOUR_ISO, FIXTURE_NOW);
-  assert.strictEqual(resetIso, SEVEN_DAY_ISO);
-  assert.notStrictEqual(resetIso, FIVE_HOUR_ISO);
-});
-
-test('resolveRateLimitPauseReset: falls back to the billing reset when the log yields none', () => {
-  const resetIso = resolveRateLimitPauseReset('/nonexistent/path/job.log', FIVE_HOUR_ISO, FIXTURE_NOW);
-  assert.strictEqual(resetIso, FIVE_HOUR_ISO);
-});
-
-test('resolveRateLimitPauseReset: null when BOTH the log and the billing endpoint are unavailable', () => {
-  assert.strictEqual(resolveRateLimitPauseReset('/nonexistent/path/job.log', null, FIXTURE_NOW), null);
-});
-
-test('resolveRateLimitPauseReset: a PAST log-derived reset is rejected, not returned stale', () => {
-  // "now" is AFTER both fixture resets have already elapsed.
-  const longAfter = Date.parse('2026-09-15T00:00:00.000Z');
-  const resetIso = resolveRateLimitPauseReset(FIXTURE, FIVE_HOUR_ISO, longAfter);
-  assert.strictEqual(resetIso, null);
-});
-
-test('resolveRateLimitPauseReset: log yields nothing and the billing reset has already passed -> null, not the stale value', () => {
-  const longAfter = Date.parse('2026-09-15T00:00:00.000Z');
-  const resetIso = resolveRateLimitPauseReset('/nonexistent/path/job.log', FIVE_HOUR_ISO, longAfter);
-  assert.strictEqual(resetIso, null);
-});
-
-test('computeEffectiveResumeAt: rate_limit with no resumeAt gets the same bounded 30-minute fallback as network', () => {
-  const now = FIXTURE_NOW;
-  const resumeAt = computeEffectiveResumeAt('rate_limit', null, now);
-  assert.strictEqual(resumeAt, new Date(now + 30 * 60_000).toISOString());
-});
-
-test('computeEffectiveResumeAt: a FRESH explicit resumeAt (the log-derived reset) is never overridden', () => {
-  const resumeAt = computeEffectiveResumeAt('rate_limit', SEVEN_DAY_ISO, FIXTURE_NOW);
-  assert.strictEqual(resumeAt, SEVEN_DAY_ISO);
-});
-
-test('computeEffectiveResumeAt: a PAST resumeAt gets the 30-minute fallback, not a ~30-second nap', () => {
-  // now is well AFTER SEVEN_DAY_ISO has already elapsed — the exact shape of
-  // the bug: Math.max(30_000, <negative>) used to arm a 30-second resume.
-  const longAfter = Date.parse('2026-09-15T00:00:00.000Z');
-  const resumeAt = computeEffectiveResumeAt('rate_limit', SEVEN_DAY_ISO, longAfter);
-  assert.strictEqual(resumeAt, new Date(longAfter + 30 * 60_000).toISOString());
-  assert.notStrictEqual(resumeAt, SEVEN_DAY_ISO);
-  const { delayMs } = computeResumeDelay(resumeAt, longAfter);
-  assert.ok(delayMs >= 30 * 60_000, `expected >= 30 minutes, got ${delayMs}ms`);
-});
-
-test('computeEffectiveResumeAt: other reasons (e.g. auth) get no fallback — stays indefinite', () => {
-  assert.strictEqual(computeEffectiveResumeAt('auth', null, Date.now()), null);
-});
-
-test('billingResetForPause: skips refreshNextReset() (no billing.fetchUsage call) while the shared circuit is OPEN', async () => {
-  const originalFetchUsage = billing.fetchUsage;
-  let fetchCalls = 0;
-  billing.fetchUsage = async () => { fetchCalls++; return { kind: 'ok', data: { usage: {} } }; };
-  try {
-    // Force the shared circuit open (3 consecutive failures), same threshold usageCircuit.cjs uses.
-    billing.usageCircuit.recordFailure('a');
-    billing.usageCircuit.recordFailure('a');
-    billing.usageCircuit.recordFailure('a');
-    assert.strictEqual(billing.usageCircuit.state(), 'open');
-
-    await billingResetForPause();
-    assert.strictEqual(fetchCalls, 0, 'refreshNextReset() must not call billing.fetchUsage() while the circuit is open');
-  } finally {
-    billing.usageCircuit.recordSuccess({}); // close the shared circuit back up for later tests/files
-    billing.fetchUsage = originalFetchUsage;
-  }
-});
-
-test('computeResumeDelay: a seven-day-out reset (~5 days from now) is armed, not treated as too-far', () => {
-  const now = Date.parse('2026-09-05T16:32:00.000Z');
-  // ~5 days out — comfortably under the 0x7fffffff (~24.8 day) setTimeout cap.
-  const fiveDaysOut = new Date(now + 5 * 24 * 60 * 60_000).toISOString();
-  const { delayMs, tooFar } = computeResumeDelay(fiveDaysOut, now);
-  assert.strictEqual(tooFar, false);
-  assert.ok(delayMs < 0x7fffffff, `expected delay under setTimeout cap, got ${delayMs}`);
-  assert.ok(delayMs > 400_000_000, `expected ~5 days in ms, got ${delayMs}`);
-});
-
-test('computeResumeDelay: a reset far enough out DOES trip the overflow guard', () => {
-  const now = Date.parse('2026-09-05T16:32:00.000Z');
-  const thirtyDaysOut = new Date(now + 30 * 24 * 60 * 60_000).toISOString();
-  const { tooFar } = computeResumeDelay(thirtyDaysOut, now);
-  assert.strictEqual(tooFar, true);
-});
-
-test('refreshNextReset (via billingResetForPause) seeds lastGoodUsagePayload: a following degraded cycle yields the fetched percent, not 100', async () => {
-  const originalFetchUsage = billing.fetchUsage;
-  billing.fetchUsage = async () => ({
-    kind: 'ok',
-    data: { usage: { limits: [{ kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true }] } },
-  });
-  try {
-    await billingResetForPause();
-    assert.strictEqual(computeDegradedBudget().utilization, 64);
-  } finally {
-    billing.fetchUsage = originalFetchUsage;
-  }
-});