claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/lib/__tests__/updateCheck.test.cjs

@@ -1,63 +0,0 @@
-'use strict';
-import { describe, it, expect, vi } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { getUpdateStatus, isBehind } = require('../updateCheck.cjs');
-
-function mk(over = {}) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'upd-'));
-  const fetchJson = vi.fn().mockResolvedValue({ latest: '0.91.1' });
-  const writeJson = vi.fn(async (f, data) => { fs.writeFileSync(f, JSON.stringify(data)); });
-  const deps = {
-    app: { getVersion: () => '0.89.0', getPath: () => dir },
-    env: {}, now: () => 1_000_000, packageName: () => 'pkg-x', fetchJson, writeJson, ...over,
-  };
-  return { dir, fetchJson, writeJson, deps, cache: path.join(dir, 'update-check.json') };
-}
-
-describe('getUpdateStatus', () => {
-  it('fresh fetch populates the cache and reports behind', async () => {
-    const t = mk();
-    expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: '0.91.1', behind: true });
-    expect(t.fetchJson).toHaveBeenCalledWith('https://registry.npmjs.org/-/package/pkg-x/dist-tags', 3000);
-    expect(JSON.parse(fs.readFileSync(t.cache, 'utf8'))).toEqual({ checkedAt: 1_000_000, latest: '0.91.1' });
-  });
-  it('cache hit inside 6h makes no network call', async () => {
-    const t = mk();
-    fs.writeFileSync(t.cache, JSON.stringify({ checkedAt: 1_000_000 - 1000, latest: '0.91.1' }));
-    expect((await getUpdateStatus({ deps: t.deps })).behind).toBe(true);
-    expect(t.fetchJson).not.toHaveBeenCalled();
-  });
-  it('expired cache refetches', async () => {
-    const t = mk({ now: () => 1_000_000 + 6 * 3600_000 + 1 });
-    fs.writeFileSync(t.cache, JSON.stringify({ checkedAt: 1_000_000, latest: '0.90.0' }));
-    expect((await getUpdateStatus({ deps: t.deps })).latest).toBe('0.91.1');
-    expect(t.fetchJson).toHaveBeenCalledTimes(1);
-  });
-  it('corrupt cache is a miss', async () => {
-    const t = mk();
-    fs.writeFileSync(t.cache, '{nope');
-    expect((await getUpdateStatus({ deps: t.deps })).latest).toBe('0.91.1');
-  });
-  it('offline falls back to latest null', async () => {
-    const t = mk({ fetchJson: vi.fn().mockRejectedValue(new Error('ENOTFOUND')) });
-    expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: null, behind: false });
-  });
-  it('SM_UPDATE_CHECK=0 and E2E short-circuit with no network call', async () => {
-    for (const env of [{ SM_UPDATE_CHECK: '0' }, { SM_E2E: '1' }]) {
-      const t = mk({ env });
-      expect(await getUpdateStatus({ deps: t.deps })).toEqual({ current: '0.89.0', latest: null, behind: false });
-      expect(t.fetchJson).not.toHaveBeenCalled();
-    }
-  });
-});
-
-describe('isBehind', () => {
-  it('compares numeric triples', () => {
-    expect(isBehind('0.89.0', '0.91.1')).toBe(true);
-    expect(isBehind('0.91.1', '0.91.1')).toBe(false);
-    expect(isBehind('0.100.0', '0.91.1')).toBe(false);
-    expect(isBehind('0.92.0', '0.91.1')).toBe(false);
-  });
-});

package/src/main/lib/__tests__/upgradeDrain.test.cjs

@@ -1,130 +0,0 @@
-'use strict';
-
-// Run: timeout 120 npx vitest run src/main/lib/__tests__/upgradeDrain.test.cjs
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const ud = require('../upgradeDrain.cjs');
-
-const T0 = Date.parse('2026-09-18T00:00:00Z');
-const req = (extra = {}) => ({ reason: 'r', requestedBy: 'u', requestedAt: new Date(T0).toISOString(), ...extra });
-const ev = (o) => ud.evaluateDrain({ now: T0 + 1000, ...o }).action;
-
-function tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), 'upgrade-drain-')); }
-
-describe('evaluateDrain state machine', () => {
-  test('no request → none', () => {
-    assert.equal(ev({ request: null, queueSnapshot: { running: 2 }, drainState: null }), 'none');
-  });
-  test('pending request, drain not active → pause (even when idle)', () => {
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 0, investigating: 0 }, drainState: null }), 'pause');
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 3 }, drainState: null }), 'pause');
-  });
-  test('drain active + running or investigating → wait', () => {
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 1, investigating: 0 }, drainState: { active: true } }), 'wait');
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 0, investigating: 1 }, drainState: { active: true } }), 'wait');
-  });
-  test('drain active + zero busy → restart', () => {
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 0, investigating: 0 }, drainState: { active: true } }), 'restart');
-  });
-  test('deadline converts to abort, default 4 h', () => {
-    const now = T0 + ud.DEFAULT_DRAIN_DEADLINE_MS;
-    assert.equal(ud.DEFAULT_DRAIN_DEADLINE_MS, 4 * 60 * 60_000);
-    assert.equal(ud.evaluateDrain({ request: req(), queueSnapshot: { running: 1 }, drainState: { active: true }, now }).action, 'abort');
-    assert.equal(ud.evaluateDrain({ request: req(), queueSnapshot: { running: 1 }, drainState: { active: true }, now: now - 1 }).action, 'wait');
-    assert.equal(ud.evaluateDrain({ request: req(), queueSnapshot: {}, drainState: { active: true }, now: T0 + 500, deadlineMs: 100 }).action, 'abort');
-  });
-  test('completed request → none; stale drain without request → abort', () => {
-    assert.equal(ev({ request: req({ drainCompletedAt: 'x' }), queueSnapshot: {}, drainState: { active: true } }), 'none');
-    assert.equal(ev({ request: null, queueSnapshot: {}, drainState: { active: true } }), 'abort');
-  });
-  test('a rate-limit pause during a drain does not change the verdict: drain is its own field', () => {
-    // evaluateDrain never sees state.paused; a rate_limit pause overwriting
-    // `paused` leaves the drain field (and the verdict) untouched.
-    const state = { paused: { reason: 'rate_limit' }, drain: { active: true } };
-    assert.equal(ev({ request: req(), queueSnapshot: { running: 0, investigating: 0 }, drainState: state.drain }), 'restart');
-    assert.equal(ud.effectivePaused(state).reason, 'rate_limit');
-    assert.equal(ud.effectivePaused({ paused: null, drain: { active: true } }).reason, 'drain-for-upgrade');
-    assert.equal(ud.effectivePaused({ paused: null, drain: null }), null);
-  });
-});
-
-describe('request file lifecycle', () => {
-  test('requestRestart writes atomically and is idempotent while pending', () => {
-    const dir = tmp();
-    try {
-      const file = path.join(dir, 'restart-request.json');
-      const a = ud.requestRestart({ reason: 'x', requestedBy: 'user' }, { file, now: T0 });
-      const b = ud.requestRestart({ reason: 'y', requestedBy: 'auto' }, { file, now: T0 + 5000 });
-      assert.deepEqual(b, a, 'a second request must not reset the deadline');
-      assert.deepEqual(fs.readdirSync(dir), ['restart-request.json'], 'no tmp file left behind');
-      assert.equal(ud.readRestartRequest(file).requestedBy, 'user');
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  });
-  test('stampDrainCompleted marks it; a new request after completion starts fresh', () => {
-    const dir = tmp();
-    try {
-      const file = path.join(dir, 'restart-request.json');
-      ud.requestRestart({ reason: 'x', requestedBy: 'u' }, { file, now: T0 });
-      assert.ok(ud.stampDrainCompleted(T0 + 1, file).drainCompletedAt);
-      const fresh = ud.requestRestart({ reason: 'again', requestedBy: 'u' }, { file, now: T0 + 9 });
-      assert.equal(fresh.reason, 'again');
-      assert.equal(fresh.drainCompletedAt, undefined);
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  });
-  test('abort retires the request file', () => {
-    const dir = tmp();
-    try {
-      const file = path.join(dir, 'restart-request.json');
-      ud.requestRestart({ reason: 'x', requestedBy: 'u' }, { file, now: T0 });
-      ud.retireRestartRequest(file);
-      assert.equal(ud.readRestartRequest(file), null);
-      ud.retireRestartRequest(file); // absent → no throw
-      // With the request gone, a re-evaluation is 'none' — no abort flap.
-      assert.equal(ev({ request: ud.readRestartRequest(file), queueSnapshot: {}, drainState: null }), 'none');
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  });
-});
-
-describe('boot', () => {
-  test('clears a leftover drain whose request is complete or gone; keeps a pending one', () => {
-    assert.equal(ud.bootDrainAction({ drainState: { active: true }, request: req({ drainCompletedAt: 'x' }) }), 'clear');
-    assert.equal(ud.bootDrainAction({ drainState: { active: true }, request: null }), 'clear');
-    assert.equal(ud.bootDrainAction({ drainState: { active: true }, request: req() }), 'keep');
-    assert.equal(ud.bootDrainAction({ drainState: null, request: req() }), 'none');
-  });
-});
-
-describe('automatic trigger', () => {
-  test('only when both shas are known and differ — never from npm', () => {
-    assert.equal(ud.installedBuildDiffers({ running: 'aaa', installed: 'bbb' }), true);
-    assert.equal(ud.installedBuildDiffers({ running: 'aaa', installed: 'aaa' }), false);
-    assert.equal(ud.installedBuildDiffers({ running: null, installed: 'bbb' }), false);
-    assert.equal(ud.installedBuildDiffers({ running: 'aaa', installed: null }), false);
-  });
-});
-
-describe('queueBusyCount', () => {
-  test('counts running + investigating only', () => {
-    const jobs = [{ status: 'running' }, { status: 'investigating' }, { status: 'pending' }, { status: 'needs_review' }];
-    assert.equal(ud.queueBusyCount(jobs), 2);
-    assert.equal(ud.queueBusyCount(jobs, 1), 3);
-  });
-});
-
-describe('restarting marker', () => {
-  test('active until expiry, then lapses', () => {
-    const dir = tmp();
-    try {
-      const file = path.join(dir, 'restarting.json');
-      assert.equal(ud.isRestartingMarkerActive({ file, now: T0 }), false);
-      ud.markRestarting({ file, now: T0, ttlMs: 1000 });
-      assert.equal(ud.isRestartingMarkerActive({ file, now: T0 + 999 }), true);
-      assert.equal(ud.isRestartingMarkerActive({ file, now: T0 + 1000 }), false);
-      ud.clearRestartingMarker(file);
-      assert.equal(ud.isRestartingMarkerActive({ file, now: T0 }), false);
-    } finally { fs.rmSync(dir, { recursive: true, force: true }); }
-  });
-});

package/src/main/lib/__tests__/usageCircuit.test.cjs

@@ -1,354 +0,0 @@
-/**
- * usageCircuit.test.cjs — breaker transitions, jitter bounds, bindingWindow
- * fallback, reset freshness, degraded-budget floor/cap, singleFlight dedup.
- *
- * Run: timeout 300 npx vitest run src/main/lib/__tests__/usageCircuit.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const {
-  createUsageCircuit,
-  backoffWithJitter,
-  isResetFresh,
-  bindingWindow,
-  degradedBudget,
-  singleFlight,
-} = require('../usageCircuit.cjs');
-
-test('state machine: closed -> open after 3 consecutive failures', () => {
-  let nowMs = 0;
-  const circuit = createUsageCircuit({ now: () => nowMs });
-  assert.strictEqual(circuit.state(), 'closed');
-  circuit.recordFailure('meter_rate_limited');
-  assert.strictEqual(circuit.state(), 'closed');
-  circuit.recordFailure('meter_rate_limited');
-  assert.strictEqual(circuit.state(), 'closed');
-  circuit.recordFailure('meter_rate_limited');
-  assert.strictEqual(circuit.state(), 'open');
-});
-
-test('open -> half_open after the backoff interval elapses, exactly one probe granted', () => {
-  let nowMs = 0;
-  const circuit = createUsageCircuit({ now: () => nowMs });
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  assert.strictEqual(circuit.state(), 'open');
-
-  nowMs += 10_000; // still inside the (>=15s) minimum backoff window
-  assert.strictEqual(circuit.state(), 'open');
-
-  nowMs += 60 * 60 * 1000; // well past any possible backoff interval
-  assert.strictEqual(circuit.state(), 'half_open');
-  // Re-querying before the probe's result is recorded must not grant a second probe.
-  assert.strictEqual(circuit.state(), 'half_open');
-});
-
-test('half_open -> closed on a successful probe, resetting backoff', () => {
-  let nowMs = 0;
-  const circuit = createUsageCircuit({ now: () => nowMs });
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  nowMs += 60 * 60 * 1000;
-  assert.strictEqual(circuit.state(), 'half_open');
-  circuit.recordSuccess({ five_hour: { utilization: 10, resets_at: null } });
-  assert.strictEqual(circuit.state(), 'closed');
-});
-
-test('half_open -> open on a failed probe, with backoff doubled (probe takes longer to reopen)', () => {
-  let nowMs = 0;
-  const circuit = createUsageCircuit({ now: () => nowMs });
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  nowMs += 60 * 60 * 1000;
-  assert.strictEqual(circuit.state(), 'half_open');
-  circuit.recordFailure('a');
-  assert.strictEqual(circuit.state(), 'open');
-  nowMs += 25_000; // below the doubled 2nd-stage backoff's own 30s floor
-  assert.strictEqual(circuit.state(), 'open');
-  nowMs += 60 * 60 * 1000;
-  assert.strictEqual(circuit.state(), 'half_open');
-});
-
-test('backoffWithJitter: 1000 samples stay within [0.5x, 1.0x] of the doubled base, floor 30s / cap 8min', () => {
-  for (let i = 0; i < 1000; i++) {
-    const first = backoffWithJitter(0);
-    assert.ok(first >= 15_000 && first <= 30_000, `first=${first}`);
-
-    const second = backoffWithJitter(30_000);
-    assert.ok(second >= 30_000 && second <= 60_000, `second=${second}`);
-
-    const atCap = backoffWithJitter(8 * 60 * 1000);
-    assert.ok(atCap >= 4 * 60 * 1000 && atCap <= 8 * 60 * 1000, `atCap=${atCap}`);
-
-    const beyondCap = backoffWithJitter(20 * 60 * 1000); // doubling would exceed the 8min cap
-    assert.ok(beyondCap >= 4 * 60 * 1000 && beyondCap <= 8 * 60 * 1000, `beyondCap=${beyondCap}`);
-  }
-});
-
-test('isResetFresh: past -> false, future -> true, null -> false', () => {
-  const now = Date.parse('2026-09-13T12:00:00Z');
-  assert.strictEqual(isResetFresh('2026-09-13T11:59:59Z', now), false); // past
-  assert.strictEqual(isResetFresh('2026-09-13T12:00:00Z', now), false); // at now
-  assert.strictEqual(isResetFresh('2026-09-13T12:00:01Z', now), true); // future
-  assert.strictEqual(isResetFresh(null, now), false);
-  assert.strictEqual(isResetFresh(undefined, now), false);
-  assert.strictEqual(isResetFresh('not-a-date', now), false);
-});
-
-const REAL_LIMITS = [
-  { kind: 'session', group: 'session', percent: 6, severity: 'normal', resets_at: '2026-09-22T00:40:00.280514+00:00', scope: null, is_active: false },
-  { kind: 'weekly_all', group: 'weekly', percent: 64, severity: 'normal', resets_at: '2026-09-24T17:00:00.280532+00:00', scope: null, is_active: true },
-  { kind: 'weekly_scoped', group: 'weekly', percent: 18, severity: 'normal', resets_at: '2026-09-24T17:00:00.280763+00:00', scope: { model: { id: null, display_name: 'Fable' }, surface: null }, is_active: false },
-];
-
-test('bindingWindow: verbatim real payload selects weekly_all 64', () => {
-  const payload = {
-    five_hour: { utilization: 6, resets_at: '2026-09-22T00:40:00.280514+00:00' },
-    seven_day: { utilization: 64, resets_at: '2026-09-24T17:00:00.280532+00:00' },
-    limits: REAL_LIMITS,
-  };
-  assert.deepStrictEqual(bindingWindow(payload), {
-    name: 'weekly_all',
-    utilization: 64,
-    resets_at: '2026-09-24T17:00:00.280532+00:00',
-  });
-});
-
-test('bindingWindow: max percent wins over is_active (session 95 beats weekly_all 64)', () => {
-  const win = bindingWindow({
-    limits: [
-      { kind: 'session', percent: 95, resets_at: '2026-09-22T00:40:00Z', scope: null, is_active: false },
-      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
-    ],
-  });
-  assert.strictEqual(win.name, 'session');
-  assert.strictEqual(win.utilization, 95);
-});
-
-test('bindingWindow: is_active breaks a percent tie', () => {
-  const win = bindingWindow({
-    limits: [
-      { kind: 'session', percent: 50, resets_at: null, scope: null, is_active: false },
-      { kind: 'weekly_all', percent: 50, resets_at: null, scope: null, is_active: true },
-    ],
-  });
-  assert.strictEqual(win.name, 'weekly_all');
-});
-
-test('bindingWindow: a high weekly_scoped entry is never selected', () => {
-  const win = bindingWindow({
-    limits: [
-      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
-      { kind: 'weekly_all', percent: 10, resets_at: null, scope: null, is_active: true },
-      { kind: 'weekly_scoped', percent: 99, resets_at: null, scope: { model: { display_name: 'Fable' } }, is_active: false },
-    ],
-  });
-  assert.strictEqual(win.name, 'weekly_all');
-  assert.strictEqual(win.utilization, 10);
-});
-
-test('bindingWindow: percent over 100 is returned raw, not clamped', () => {
-  const win = bindingWindow({ limits: [{ kind: 'session', percent: 112, resets_at: null, scope: null }] });
-  assert.strictEqual(win.utilization, 112);
-});
-
-test('bindingWindow: null resets_at backfills from the matching flat window', () => {
-  const win = bindingWindow({
-    five_hour: { utilization: 40, resets_at: '2026-09-22T00:40:00Z' },
-    seven_day: { utilization: 5, resets_at: '2026-09-24T17:00:00Z' },
-    limits: [
-      { kind: 'session', percent: 40, resets_at: null, scope: null },
-      { kind: 'weekly_all', percent: 5, resets_at: null, scope: null },
-    ],
-  });
-  assert.strictEqual(win.name, 'session');
-  assert.strictEqual(win.resets_at, '2026-09-22T00:40:00Z');
-});
-
-test('bindingWindow: limits[] absent falls back to five_hour', () => {
-  const payload = { five_hour: { utilization: 42, resets_at: '2026-09-13T15:00:00Z' } };
-  const win = bindingWindow(payload);
-  assert.strictEqual(win.name, 'five_hour');
-  assert.strictEqual(win.utilization, 42);
-});
-
-test('bindingWindow: limits[] with only scoped / non-finite entries falls back to five_hour', () => {
-  const payload = {
-    five_hour: { utilization: 12, resets_at: null },
-    limits: [
-      { kind: 'weekly_scoped', percent: 81, resets_at: null, scope: { model: { display_name: 'Fable' } } },
-      { kind: 'session', resets_at: null, scope: null },
-    ],
-  };
-  const win = bindingWindow(payload);
-  assert.strictEqual(win.name, 'five_hour');
-  assert.strictEqual(win.utilization, 12);
-});
-
-test('degradedBudget: a last-good binding window that genuinely read 0% carries forward as 0, not 100', () => {
-  const payload = { five_hour: { utilization: 0, resets_at: null } };
-  assert.strictEqual(degradedBudget(payload, {}).utilization, 0);
-});
-
-test('degradedBudget: no payload ever received (null/absent) still yields 100, never a blind 0', () => {
-  assert.strictEqual(degradedBudget(null, {}).utilization, 100);
-  assert.strictEqual(degradedBudget(undefined, {}).utilization, 100);
-});
-
-test('degradedBudget: a degraded cycle after a real-shape poll carries forward the real percent (64), not 100', () => {
-  const payload = {
-    limits: [
-      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
-      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
-    ],
-  };
-  assert.strictEqual(degradedBudget(payload, {}).utilization, 64);
-});
-
-test('degradedBudget: carries forward the real last-good BINDING (weekly_all) utilization, e.g. 81%, never 0', () => {
-  const payload = {
-    five_hour: { utilization: 0, resets_at: null },
-    limits: [
-      { kind: 'session', is_active: false, percent: 0, resets_at: null, scope: null },
-      { kind: 'weekly_all', is_active: true, percent: 81, resets_at: '2026-09-19T00:00:00Z', scope: null },
-    ],
-  };
-  const { utilization } = degradedBudget(payload, {});
-  assert.strictEqual(utilization, 81);
-});
-
-test('degradedBudget: caps concurrency at 2 regardless of a higher configured cap', () => {
-  const payload = { five_hour: { utilization: 30, resets_at: null } };
-  const { concurrencyCap } = degradedBudget(payload, { configuredCap: 5 });
-  assert.strictEqual(concurrencyCap, 2);
-});
-
-test('degradedBudget: respects a configured cap below 2', () => {
-  const payload = { five_hour: { utilization: 30, resets_at: null } };
-  const { concurrencyCap } = degradedBudget(payload, { configuredCap: 1 });
-  assert.strictEqual(concurrencyCap, 1);
-});
-
-test('degradedBudget: an executor-observed 429 whose window has not passed pins utilization to 100', () => {
-  const payload = { five_hour: { utilization: 5, resets_at: null } };
-  const now = Date.parse('2026-09-13T12:00:00Z');
-  const { utilization } = degradedBudget(payload, {
-    observed429: true,
-    resetsAt: '2026-09-13T13:00:00Z', // still in the future
-    now,
-  });
-  assert.strictEqual(utilization, 100);
-});
-
-test('degradedBudget: once the 429 window passes, it stops pinning to 100 and falls back to real utilization', () => {
-  const payload = { five_hour: { utilization: 5, resets_at: null } };
-  const now = Date.parse('2026-09-13T12:00:00Z');
-  const { utilization } = degradedBudget(payload, {
-    observed429: true,
-    resetsAt: '2026-09-13T11:00:00Z', // already passed
-    now,
-  });
-  assert.strictEqual(utilization, 5);
-});
-
-test('singleFlight: concurrent callers share the same in-flight promise, fn invoked once', async () => {
-  let calls = 0;
-  let resolveFn;
-  const fn = () => new Promise((resolve) => { resolveFn = resolve; calls += 1; });
-  const wrapped = singleFlight(fn);
-
-  const p1 = wrapped();
-  const p2 = wrapped();
-  assert.strictEqual(p1, p2);
-  assert.strictEqual(calls, 1);
-  resolveFn('done');
-  assert.strictEqual(await p1, 'done');
-
-  const p3 = wrapped();
-  assert.notStrictEqual(p3, p1);
-  assert.strictEqual(calls, 2);
-  resolveFn('done2');
-  await p3;
-});
-
-test('openedAt: null while closed, stamped the moment it opens, stays stamped through a failed half_open probe, clears on success', () => {
-  let nowMs = 1000;
-  const circuit = createUsageCircuit({ now: () => nowMs });
-  assert.strictEqual(circuit.openedAt(), null);
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  assert.strictEqual(circuit.openedAt(), null); // still closed, 2 of 3
-  circuit.recordFailure('a');
-  assert.strictEqual(circuit.state(), 'open');
-  assert.strictEqual(circuit.openedAt(), 1000);
-
-  nowMs += 60 * 60 * 1000;
-  assert.strictEqual(circuit.state(), 'half_open');
-  assert.strictEqual(circuit.openedAt(), 1000); // unchanged through the probe
-
-  circuit.recordFailure('a'); // failed probe -> reopens
-  assert.strictEqual(circuit.state(), 'open');
-  assert.strictEqual(circuit.openedAt(), 1000); // still the ORIGINAL open time, not re-stamped
-
-  circuit.recordSuccess({});
-  assert.strictEqual(circuit.openedAt(), null);
-});
-
-test('getConsecutiveFailures: tracks failures, resets on success', () => {
-  const circuit = createUsageCircuit({ now: () => 0 });
-  assert.strictEqual(circuit.getConsecutiveFailures(), 0);
-  circuit.recordFailure('a');
-  circuit.recordFailure('a');
-  assert.strictEqual(circuit.getConsecutiveFailures(), 2);
-  circuit.recordSuccess({});
-  assert.strictEqual(circuit.getConsecutiveFailures(), 0);
-});
-
-test('SM_USAGE_CIRCUIT=0 bypasses the breaker entirely: state stays closed no matter how many failures', () => {
-  const prev = process.env.SM_USAGE_CIRCUIT;
-  process.env.SM_USAGE_CIRCUIT = '0';
-  try {
-    const circuit = createUsageCircuit({ now: () => 0 });
-    circuit.recordFailure('a');
-    circuit.recordFailure('a');
-    circuit.recordFailure('a');
-    circuit.recordFailure('a');
-    assert.strictEqual(circuit.state(), 'closed');
-    assert.strictEqual(circuit.openedAt(), null);
-  } finally {
-    if (prev === undefined) delete process.env.SM_USAGE_CIRCUIT; else process.env.SM_USAGE_CIRCUIT = prev;
-  }
-});
-
-test('SM_USAGE_DEGRADED_CAP overrides degradedBudget concurrencyCap outright, bypassing min(cap, 2)', () => {
-  const prev = process.env.SM_USAGE_DEGRADED_CAP;
-  process.env.SM_USAGE_DEGRADED_CAP = '7';
-  try {
-    const payload = { five_hour: { utilization: 30, resets_at: null } };
-    const { concurrencyCap } = degradedBudget(payload, { configuredCap: 2 });
-    assert.strictEqual(concurrencyCap, 7);
-  } finally {
-    if (prev === undefined) delete process.env.SM_USAGE_DEGRADED_CAP; else process.env.SM_USAGE_DEGRADED_CAP = prev;
-  }
-});
-
-test('singleFlight: de-dupes even when fn rejects, next call gets a fresh attempt', async () => {
-  let calls = 0;
-  const fn = () => (calls++ === 0 ? Promise.reject(new Error('boom')) : Promise.resolve('ok'));
-  const wrapped = singleFlight(fn);
-
-  const p1 = wrapped();
-  const p2 = wrapped();
-  assert.strictEqual(p1, p2);
-  await assert.rejects(p1, /boom/);
-
-  const p3 = wrapped();
-  assert.strictEqual(await p3, 'ok');
-  assert.strictEqual(calls, 2);
-});