claude-code-session-manager 0.86.0 → 0.88.0

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

@@ -0,0 +1,56 @@
+// schedulerRuntimeState.cjs + quietMachineLease.cjs — fail-closed expiry.
+const assert = require('node:assert');
+const state = require('../schedulerRuntimeState.cjs');
+const lease = require('../quietMachineLease.cjs');
+
+const NOW = 10_000_000;
+const GRACE = 10 * 60 * 1000;
+
+beforeEach(() => { state.__resetForTests(); lease.__resetForTests(); });
+afterEach(() => { state.__resetForTests(); lease.__resetForTests(); });
+
+test('lease: expires only when holder not running AND past grace', () => {
+  lease.acquire('q', { claimedAt: NOW - GRACE - 1 });
+  assert.equal(lease.expireDead({ liveSlugs: new Set(['q']), now: NOW, graceMs: GRACE }), false, 'running row keeps it');
+  assert.equal(lease.isHeld(), true);
+  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), true);
+  assert.equal(lease.isHeld(), false);
+});
+
+test('lease: inside the grace window or claimed after the pass began is kept', () => {
+  lease.acquire('q', { claimedAt: NOW - 1000 });
+  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), false);
+  lease.release('q');
+  lease.acquire('q', { claimedAt: NOW + 10 });
+  assert.equal(lease.expireDead({ liveSlugs: new Set(), now: NOW, graceMs: GRACE }), false);
+  assert.equal(lease.isHeld(), true);
+});
+
+test('investigations: set semantics, no double reservation, idempotent release', () => {
+  assert.equal(state.reserveInvestigation('a'), true);
+  assert.equal(state.reserveInvestigation('a'), false);
+  assert.equal(state.investigationCount(), 1);
+  assert.equal(state.releaseInvestigation('a'), true);
+  assert.equal(state.releaseInvestigation('a'), false);
+  assert.equal(state.investigationCount(), 0);
+});
+
+test('investigations: dead stamped pid with no investigating row expires; live pid/row survives', () => {
+  state.reserveInvestigation('dead', { claimedAt: NOW - 1000 });
+  state.stampInvestigationPid('dead', 111);
+  state.reserveInvestigation('alive', { claimedAt: NOW - 1000 });
+  state.stampInvestigationPid('alive', 222);
+  state.reserveInvestigation('rowlive', { claimedAt: NOW - 2 * GRACE });
+  const out = state.expireDeadInvestigations({
+    liveSlugs: new Set(['rowlive']), pidAlive: (p) => p === 222, now: NOW, graceMs: GRACE,
+  });
+  assert.deepEqual(out, ['dead']);
+  assert.equal(state.investigationCount(), 2);
+});
+
+test('investigations: pidless reservation expires past grace only', () => {
+  state.reserveInvestigation('old', { claimedAt: NOW - GRACE - 1 });
+  state.reserveInvestigation('fresh', { claimedAt: NOW - 1000 });
+  const out = state.expireDeadInvestigations({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
+  assert.deepEqual(out, ['old']);
+});

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

@@ -97,3 +97,48 @@ test('snapshot names holders for attribution', () => {
   assert.equal(snap.inUse, 2);
   assert.deepEqual(snap.holders.map((h) => h.owner).sort(), ['chat:tab-1', 'scheduler:42-fix-thing']);
 });
+
+// ── expireDead: fail-closed release of provably-dead scheduler reservations ──
+const NOW = 10_000_000;
+const GRACE = 10 * 60 * 1000;
+
+test('expireDead: stamped dead pid with no live row is released', () => {
+  const t = slots.acquire('scheduler:a', { claimedAt: NOW - 1000 });
+  slots.stampPid(t, 4242);
+  const out = slots.expireDead({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
+  assert.deepEqual(out, ['scheduler:a']);
+  assert.equal(slots.inUse(), 0);
+});
+
+test('expireDead: a live pid or a live row keeps the token', () => {
+  const t1 = slots.acquire('scheduler:a', { claimedAt: NOW - 2 * GRACE });
+  slots.stampPid(t1, 4242);
+  const t2 = slots.acquire('scheduler:b', { claimedAt: NOW - 2 * GRACE });
+  slots.expireDead({ liveSlugs: new Set(['b']), pidAlive: () => true, now: NOW, graceMs: GRACE });
+  assert.equal(slots.inUse(), 2, 'live pid (a) and live row (b) both survive');
+  assert.ok(t1 && t2);
+});
+
+test('expireDead: pidless token expires only past the grace window', () => {
+  slots.acquire('scheduler:old', { claimedAt: NOW - GRACE - 1 });
+  slots.acquire('scheduler:fresh', { claimedAt: NOW - GRACE + 1000 });
+  const out = slots.expireDead({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
+  assert.deepEqual(out, ['scheduler:old']);
+  assert.equal(slots.inUse(), 1);
+});
+
+test('expireDead: chat and project-brief tokens are never touched', () => {
+  slots.acquire('chat:tab1', { claimedAt: 0 });
+  slots.acquire('project-brief:x', { claimedAt: 0 });
+  const out = slots.expireDead({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
+  assert.deepEqual(out, []);
+  assert.equal(slots.inUse(), 2);
+});
+
+test('expireDead: a mid-launch reservation (claimed after the pass began) survives even with a dead pid', () => {
+  const t = slots.acquire('scheduler:mid', { claimedAt: NOW + 5 });
+  slots.stampPid(t, 4242);
+  const out = slots.expireDead({ liveSlugs: new Set(), pidAlive: () => false, now: NOW, graceMs: GRACE });
+  assert.deepEqual(out, []);
+  assert.equal(slots.inUse(), 1);
+});

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

@@ -183,7 +183,7 @@ test('duplicate cwds across tabs are visited once; a missing cwd is skipped with
 
 test('an ephemeral epic-worktree cwd is never scanned as its own project', async () => {
   const home = await mkHome();
-  const ephemeral = path.join(os.tmpdir(), 'session-manager-epic-worktrees', 'abc123', 'psess-xyz');
+  const ephemeral = path.join(process.env.SM_WORKTREE_ROOT || os.tmpdir(), 'session-manager-epic-worktrees', 'abc123', 'psess-xyz');
   const opsDir = path.join(ephemeral, 'session-manager-operations', 'logs');
   fs.mkdirSync(opsDir, { recursive: true });
   fs.writeFileSync(path.join(opsDir, `errors-${recentDateStr()}.jsonl`), JSON.stringify(errLine(1)) + '\n');

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

@@ -0,0 +1,130 @@
+'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

@@ -0,0 +1,285 @@
+/**
+ * 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);
+});
+
+test('bindingWindow: limits[] with weekly_all is_active wins over five_hour', () => {
+  const payload = {
+    five_hour: { utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
+    limits: [
+      { type: 'five_hour', is_active: false, utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
+      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+    ],
+  };
+  const win = bindingWindow(payload);
+  assert.strictEqual(win.name, 'weekly_all');
+  assert.strictEqual(win.utilization, 81);
+  assert.strictEqual(win.resets_at, '2026-09-19T00:00: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[] present but nothing is_active also falls back to five_hour', () => {
+  const payload = {
+    five_hour: { utilization: 12, resets_at: null },
+    limits: [
+      { type: 'five_hour', is_active: false, utilization: 12, resets_at: null },
+      { type: 'weekly_all', is_active: false, utilization: 81, resets_at: null },
+    ],
+  };
+  const win = bindingWindow(payload);
+  assert.strictEqual(win.name, 'five_hour');
+  assert.strictEqual(win.utilization, 12);
+});
+
+test('degradedBudget: never yields 0 utilization, even when the last good binding window read 0', () => {
+  const payload = { five_hour: { utilization: 0, resets_at: null } };
+  const { utilization } = degradedBudget(payload, {});
+  assert.notStrictEqual(utilization, 0);
+  assert.strictEqual(utilization, 100); // no real signal -> conservative default
+});
+
+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: [
+      { type: 'five_hour', is_active: false, utilization: 0, resets_at: null },
+      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+    ],
+  };
+  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);
+});