switchroom 0.10.0 → 0.11.1

package/telegram-plugin/tests/auto-fallback-fleet.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Tests for the fleet-wide auto-fallback planner. Pure-data —
+ * no broker UDS, no Telegram bot. The injected `setActive` is a
+ * vi.fn we assert on.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { runFleetAutoFallback, pickFallbackTarget } from '../auto-fallback-fleet.js';
+import type { QuotaResult, QuotaUtilization } from '../quota-check.js';
+import type { ListStateData } from '../../src/auth/broker/client.js';
+
+const NOW = new Date('2026-05-15T00:53:00Z');
+
+function quota(part: Partial<QuotaUtilization>): QuotaUtilization {
+  return {
+    fiveHourUtilizationPct: 0,
+    sevenDayUtilizationPct: 0,
+    fiveHourResetAt: null,
+    sevenDayResetAt: null,
+    representativeClaim: null,
+    overageStatus: null,
+    overageDisabledReason: null,
+    ...part,
+  };
+}
+
+function qOk(part: Partial<QuotaUtilization>): QuotaResult {
+  return { ok: true, data: quota(part) };
+}
+
+function state(active: string, accounts: string[]): ListStateData {
+  return {
+    active,
+    fallback_order: accounts,
+    accounts: accounts.map((label) => ({ label, exhausted: false })),
+    agents: [],
+    consumers: [],
+  };
+}
+
+describe('runFleetAutoFallback', () => {
+  it('switches to the lowest-utilization healthy account via broker.setActive', async () => {
+    const setActive = vi.fn(async (label: string) => ({
+      active: label,
+      fanned: ['alice', 'bob'],
+    }));
+    const out = await runFleetAutoFallback({
+      state: state('ken@x', ['ken@x', 'me@x', 'pixsoul@x']),
+      quotas: [
+        // ken: just blew 5h
+        qOk({
+          fiveHourUtilizationPct: 100,
+          fiveHourResetAt: new Date('2026-05-15T05:50:00Z'),
+          representativeClaim: 'five_hour',
+        }),
+        // me: dead on 7d for 2 days
+        qOk({
+          sevenDayUtilizationPct: 100,
+          sevenDayResetAt: new Date('2026-05-17T10:00:00Z'),
+          representativeClaim: 'seven_day',
+        }),
+        // pixsoul: healthy 5h/7d
+        qOk({ fiveHourUtilizationPct: 8, sevenDayUtilizationPct: 20 }),
+      ],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('switched');
+    expect(setActive).toHaveBeenCalledTimes(1);
+    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+    if (out.kind === 'switched') {
+      expect(out.oldLabel).toBe('ken@x');
+      expect(out.newLabel).toBe('pixsoul@x');
+      expect(out.announcement).toContain('5-hour limit on ken@x');
+      expect(out.announcement).toContain('Triggered by: agent <b>carrie</b>');
+      expect(out.announcement).toContain('plenty of headroom');
+    }
+  });
+
+  it('returns all-blocked WITHOUT calling setActive when every alternative is blocked', async () => {
+    const setActive = vi.fn();
+    const out = await runFleetAutoFallback({
+      state: state('ken@x', ['ken@x', 'me@x']),
+      quotas: [
+        qOk({
+          fiveHourUtilizationPct: 100,
+          fiveHourResetAt: new Date('2026-05-15T05:50:00Z'),
+          representativeClaim: 'five_hour',
+        }),
+        qOk({
+          sevenDayUtilizationPct: 100,
+          sevenDayResetAt: new Date('2026-05-17T10:00:00Z'),
+          representativeClaim: 'seven_day',
+        }),
+      ],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('all-blocked');
+    expect(setActive).not.toHaveBeenCalled();
+    if (out.kind === 'all-blocked') {
+      expect(out.announcement).toContain('All accounts blocked');
+      expect(out.announcement).toContain('/auth add');
+    }
+  });
+
+  it('idempotency: skips swap when active probes healthy (stale event)', async () => {
+    const setActive = vi.fn();
+    const out = await runFleetAutoFallback({
+      state: state('ken@x', ['ken@x', 'pixsoul@x']),
+      quotas: [
+        qOk({ fiveHourUtilizationPct: 5, sevenDayUtilizationPct: 10 }),
+        qOk({ fiveHourUtilizationPct: 5, sevenDayUtilizationPct: 10 }),
+      ],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('no-eligible-target');
+    expect(setActive).not.toHaveBeenCalled();
+    expect(out.announcement).toContain('skipped');
+    expect(out.announcement).toContain('Stale event?');
+  });
+
+  it('returns no-old-active when broker has no active account (corrupt state)', async () => {
+    const setActive = vi.fn();
+    const out = await runFleetAutoFallback({
+      state: { active: '', fallback_order: [], accounts: [], agents: [], consumers: [] },
+      quotas: [],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('no-old-active');
+    expect(setActive).not.toHaveBeenCalled();
+  });
+
+  it('falls back to a throttling alternative when no healthy one exists', async () => {
+    const setActive = vi.fn(async (label: string) => ({ active: label, fanned: [] }));
+    const out = await runFleetAutoFallback({
+      state: state('ken@x', ['ken@x', 'pixsoul@x']),
+      quotas: [
+        qOk({
+          fiveHourUtilizationPct: 100,
+          fiveHourResetAt: new Date('2026-05-15T05:50:00Z'),
+          representativeClaim: 'five_hour',
+        }),
+        // pixsoul throttling at 85% but not blocked
+        qOk({ fiveHourUtilizationPct: 85, sevenDayUtilizationPct: 20 }),
+      ],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('switched');
+    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+    if (out.kind === 'switched') {
+      expect(out.announcement).toContain('near limit — watch this');
+    }
+  });
+
+  it('skips unknown-health (probe failed) when picking a target', async () => {
+    const setActive = vi.fn(async (label: string) => ({ active: label, fanned: [] }));
+    const out = await runFleetAutoFallback({
+      state: state('ken@x', ['ken@x', 'broken@x', 'pixsoul@x']),
+      quotas: [
+        qOk({ fiveHourUtilizationPct: 100, fiveHourResetAt: new Date('2026-05-15T05:50:00Z') }),
+        { ok: false, reason: 'HTTP 401' },
+        qOk({ fiveHourUtilizationPct: 5 }),
+      ],
+      setActive,
+      triggerAgent: 'carrie',
+      now: NOW,
+      tz: 'UTC',
+    });
+
+    expect(out.kind).toBe('switched');
+    expect(setActive).toHaveBeenCalledWith('pixsoul@x');
+  });
+});
+
+describe('pickFallbackTarget', () => {
+  it('prefers lower-5h-utilization healthy account', () => {
+    const snaps = [
+      { label: 'a@x', isActive: true, quota: quota({ fiveHourUtilizationPct: 100 }) },
+      { label: 'low@x', isActive: false, quota: quota({ fiveHourUtilizationPct: 5 }) },
+      { label: 'med@x', isActive: false, quota: quota({ fiveHourUtilizationPct: 30 }) },
+    ];
+    const target = pickFallbackTarget(snaps);
+    expect(target?.label).toBe('low@x');
+  });
+
+  it('returns null when only blocked alternatives exist', () => {
+    const snaps = [
+      { label: 'a@x', isActive: true, quota: quota({ fiveHourUtilizationPct: 100 }) },
+      { label: 'b@x', isActive: false, quota: quota({ sevenDayUtilizationPct: 100 }) },
+    ];
+    expect(pickFallbackTarget(snaps)).toBeNull();
+  });
+});

package/telegram-plugin/tests/auto-fallback.test.ts

@@ -1,381 +1,83 @@
-import { describe, it, expect } from "vitest";
-import {
-  evaluateFallbackTrigger,
-  performAutoFallback,
-  nextLockout,
-  emptyLockout,
-  loadLockout,
-  saveLockout,
-  DEFAULT_TRIGGER_UTILIZATION_PCT,
-  DEFAULT_FALLBACK_COOLDOWN_MS,
-  type LockoutRecord,
-  type FallbackDecision,
-} from "../auto-fallback";
-import type { QuotaResult } from "../quota-check";
-
-const NOW = 1_780_000_000_000;
-
-function okQuota(fivePct: number, sevenPct = 0, resetOffsetMs = 60 * 60_000): QuotaResult {
+import { describe, expect, it } from "vitest";
+import { loadLockout, type LockoutRecord, type LockoutPersistOps } from "../auto-fallback.js";
+
+// The auto-fallback module is read-only since PR #1329 — the writer +
+// decision logic + plan executor were retired alongside the legacy
+// per-agent poller (fleet-wide path supersedes them). The only
+// remaining consumer is gateway.ts's `isAutoFallbackCooldownActive`,
+// which reads the existing on-disk lockout to bound a pending-restart
+// drain. This test set covers that one read path.
+
+const EMPTY: LockoutRecord = { lastTransitionedFrom: null, lastTransitionAt: 0 };
+
+function fakeOps(initial: Record<string, string> = {}): LockoutPersistOps & {
+  files: Map<string, string>;
+} {
+  const files = new Map(Object.entries(initial));
   return {
-    ok: true,
-    data: {
-      fiveHourUtilizationPct: fivePct,
-      sevenDayUtilizationPct: sevenPct,
-      fiveHourResetAt: new Date(NOW + resetOffsetMs),
-      sevenDayResetAt: new Date(NOW + resetOffsetMs * 2),
-      representativeClaim: null,
-      overageStatus: null,
-      overageDisabledReason: null,
+    files,
+    readFileSync: (p: string) => {
+      const v = files.get(p);
+      if (v === undefined) throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
+      return v;
     },
+    // unused by loadLockout — present to satisfy the interface.
+    writeFileSync: () => { throw new Error("writes are retired"); },
+    mkdirSync: () => { throw new Error("mkdir is retired"); },
+    existsSync: (p: string) => files.has(p),
+    joinPath: (...parts: string[]) => parts.join("/"),
   };
 }
 
-describe("evaluateFallbackTrigger", () => {
-  it("no active slot → noop", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(100),
-      activeSlot: null,
-      now: NOW,
-      lockout: emptyLockout(),
-    });
-    expect(d.action).toBe("noop");
-  });
-
-  it("utilization below threshold → noop", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(95),
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
-    });
-    expect(d.action).toBe("noop");
+describe("loadLockout — read-only after #1329", () => {
+  it("returns the empty lockout when no file exists", () => {
+    expect(loadLockout("/agent", fakeOps())).toEqual(EMPTY);
   });
 
-  it("5h utilization at default threshold → fallback", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(DEFAULT_TRIGGER_UTILIZATION_PCT, 50),
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
+  it("returns the parsed record on a well-formed file", () => {
+    const ops = fakeOps({
+      "/agent/.claude/auto-fallback-lockout.json": JSON.stringify({
+        lastTransitionedFrom: "ken@example.com",
+        lastTransitionAt: 1_700_000_000_000,
+      }),
     });
-    expect(d.action).toBe("fallback");
-    if (d.action === "fallback") {
-      expect(d.triggerReason).toBe("utilization-over-threshold");
-      expect(d.utilizationPct).toBe(DEFAULT_TRIGGER_UTILIZATION_PCT);
-    }
-  });
-
-  it("7d utilization over threshold (5h fine) → still fallback", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(80, 100),
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
+    expect(loadLockout("/agent", ops)).toEqual({
+      lastTransitionedFrom: "ken@example.com",
+      lastTransitionAt: 1_700_000_000_000,
     });
-    expect(d.action).toBe("fallback");
-    if (d.action === "fallback") expect(d.utilizationPct).toBe(100);
   });
 
-  it("saw429=true short-circuits utilization check", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(40, 40),
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
-      saw429: true,
+  it("falls back to the empty lockout on malformed JSON", () => {
+    const ops = fakeOps({
+      "/agent/.claude/auto-fallback-lockout.json": "{broken json",
     });
-    expect(d.action).toBe("fallback");
-    if (d.action === "fallback") expect(d.triggerReason).toBe("429-response");
+    expect(loadLockout("/agent", ops)).toEqual(EMPTY);
   });
 
-  it("within cooldown for same slot → noop", () => {
-    const lockout: LockoutRecord = { lastTransitionedFrom: "default", lastTransitionAt: NOW - 10_000 };
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(100),
-      activeSlot: "default",
-      now: NOW,
-      lockout,
+  it("falls back to the empty lockout on missing fields", () => {
+    const ops = fakeOps({
+      "/agent/.claude/auto-fallback-lockout.json": JSON.stringify({ wrong: "shape" }),
     });
-    expect(d.action).toBe("noop");
-    if (d.action === "noop") expect(d.reason).toMatch(/cooldown/);
+    expect(loadLockout("/agent", ops)).toEqual(EMPTY);
   });
 
-  it("cooldown expired → fallback fires again", () => {
-    const lockout: LockoutRecord = {
-      lastTransitionedFrom: "default",
-      lastTransitionAt: NOW - DEFAULT_FALLBACK_COOLDOWN_MS - 1,
-    };
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(100),
-      activeSlot: "default",
-      now: NOW,
-      lockout,
+  it("falls back to the empty lockout when lastTransitionAt is non-finite", () => {
+    const ops = fakeOps({
+      "/agent/.claude/auto-fallback-lockout.json": JSON.stringify({
+        lastTransitionedFrom: "ken@example.com",
+        lastTransitionAt: "not a number",
+      }),
     });
-    expect(d.action).toBe("fallback");
+    expect(loadLockout("/agent", ops)).toEqual(EMPTY);
   });
 
-  it("cooldown applies per-slot (different slot allowed)", () => {
-    const lockout: LockoutRecord = { lastTransitionedFrom: "personal", lastTransitionAt: NOW - 10_000 };
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(100),
-      activeSlot: "default",
-      now: NOW,
-      lockout,
+  it("accepts an explicit-null lastTransitionedFrom", () => {
+    const ops = fakeOps({
+      "/agent/.claude/auto-fallback-lockout.json": JSON.stringify({
+        lastTransitionedFrom: null,
+        lastTransitionAt: 0,
+      }),
     });
-    expect(d.action).toBe("fallback");
-  });
-
-  it("quota fetch failed → noop with reason", () => {
-    const quota: QuotaResult = { ok: false, reason: "no OAuth token" };
-    const d = evaluateFallbackTrigger({
-      quota,
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
-    });
-    expect(d.action).toBe("noop");
-    if (d.action === "noop") expect(d.reason).toMatch(/no OAuth/);
-  });
-
-  it("quota ok but no utilization headers → noop", () => {
-    const quota: QuotaResult = {
-      ok: true,
-      data: {
-        fiveHourUtilizationPct: null as unknown as number,
-        sevenDayUtilizationPct: null as unknown as number,
-        fiveHourResetAt: null,
-        sevenDayResetAt: null,
-        representativeClaim: null,
-        overageStatus: null,
-        overageDisabledReason: null,
-      },
-    };
-    const d = evaluateFallbackTrigger({
-      quota,
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
-    });
-    expect(d.action).toBe("noop");
-  });
-
-  it("custom threshold override respected", () => {
-    const d = evaluateFallbackTrigger({
-      quota: okQuota(90),
-      activeSlot: "default",
-      now: NOW,
-      lockout: emptyLockout(),
-      thresholdPct: 85,
-    });
-    expect(d.action).toBe("fallback");
-  });
-});
-
-describe("performAutoFallback", () => {
-  const baseDecision: Extract<FallbackDecision, { action: "fallback" }> = {
-    action: "fallback",
-    triggerReason: "utilization-over-threshold",
-    resetAtMs: NOW + 60 * 60_000,
-    utilizationPct: 100,
-  };
-
-  function mkDeps(overrides?: Partial<{ active: string | null; next: string | null; previous: string | null }>) {
-    const marks: Array<{ slot: string; resetAtMs?: number; reason?: string }> = [];
-    const fallbacks: Array<{ name: string; agentDir: string }> = [];
-    const initialActive = overrides?.active === undefined ? "default" : overrides.active;
-    return {
-      marks,
-      fallbacks,
-      deps: {
-        currentActiveSlot: () => initialActive,
-        markSlotQuotaExhausted: (
-          _agentDir: string,
-          slot: string,
-          resetAtMs?: number,
-          reason?: string,
-        ) => {
-          marks.push({ slot, resetAtMs, reason });
-        },
-        fallbackToNextSlot: (name: string, agentDir: string) => {
-          fallbacks.push({ name, agentDir });
-          return {
-            newActive: overrides?.next === undefined ? "personal" : overrides.next,
-            previous: overrides?.previous === undefined ? initialActive : overrides.previous,
-          };
-        },
-      },
-    };
-  }
-
-  it("healthy fallback available → executes swap", () => {
-    const { marks, fallbacks, deps } = mkDeps();
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "clerk",
-      decision: baseDecision,
-      deps,
-    });
-    expect(plan.kind).toBe("executed");
-    if (plan.kind === "executed") {
-      expect(plan.previousSlot).toBe("default");
-      expect(plan.newSlot).toBe("personal");
-      expect(plan.notificationHtml).toContain("Quota exhausted");
-      // Slot names appear in the detail text (migrated to renderOperatorEvent)
-      expect(plan.notificationHtml).toContain("default");
-      expect(plan.notificationHtml).toContain("personal");
-    }
-    expect(marks).toHaveLength(1);
-    expect(marks[0].slot).toBe("default");
-    expect(marks[0].reason).toBe("utilization-over-threshold");
-    expect(fallbacks).toHaveLength(1);
-    expect(fallbacks[0].name).toBe("clerk");
-  });
-
-  it("no fallback available → exhausted-all plan", () => {
-    const { marks, deps } = mkDeps({ next: null });
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "clerk",
-      decision: baseDecision,
-      deps,
-    });
-    expect(plan.kind).toBe("exhausted-all");
-    if (plan.kind === "exhausted-all") {
-      expect(plan.notificationHtml).toContain("All account slots");
-      expect(plan.notificationHtml).toContain("/auth add clerk");
-    }
-    // Still marks the active slot exhausted before giving up.
-    expect(marks).toHaveLength(1);
-  });
-
-  it("fallbackToNextSlot returns same slot → treated as exhausted-all", () => {
-    const { deps } = mkDeps({ next: "default", previous: "default" });
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "clerk",
-      decision: baseDecision,
-      deps,
-    });
-    expect(plan.kind).toBe("exhausted-all");
-  });
-
-  it("no active slot when invoked → exhausted-all without marking", () => {
-    const { marks, deps } = mkDeps({ active: null });
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "clerk",
-      decision: baseDecision,
-      deps,
-    });
-    expect(plan.kind).toBe("exhausted-all");
-    expect(marks).toHaveLength(0);
-  });
-
-  it("uses Anthropic reset timestamp when available", () => {
-    const { deps } = mkDeps();
-    const resetAt = NOW + 3600_000;
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "clerk",
-      decision: { ...baseDecision, resetAtMs: resetAt },
-      deps,
-    });
-    if (plan.kind === "executed") {
-      expect(plan.resetAtMs).toBe(resetAt);
-      expect(plan.notificationHtml).toContain("Reset at");
-    }
-  });
-
-  it("escapes HTML in agent + slot names in notification", () => {
-    const { deps } = mkDeps({ previous: "<evil>", next: "<also>" });
-    const plan = performAutoFallback({
-      agentDir: "/tmp/x",
-      agentName: "<danger>",
-      decision: baseDecision,
-      deps,
-    });
-    expect(plan.notificationHtml).toContain("&lt;evil&gt;");
-    expect(plan.notificationHtml).toContain("&lt;also&gt;");
-    expect(plan.notificationHtml).toContain("&lt;danger&gt;");
-    expect(plan.notificationHtml).not.toContain("<evil>");
-  });
-});
-
-describe("nextLockout / emptyLockout", () => {
-  it("emptyLockout has no previous slot", () => {
-    const l = emptyLockout();
-    expect(l.lastTransitionedFrom).toBeNull();
-    expect(l.lastTransitionAt).toBe(0);
-  });
-  it("nextLockout records the slot we just transitioned from", () => {
-    const l = nextLockout("default", NOW);
-    expect(l.lastTransitionedFrom).toBe("default");
-    expect(l.lastTransitionAt).toBe(NOW);
-  });
-});
-
-describe("loadLockout / saveLockout (#417)", () => {
-  function fakeOps() {
-    const files = new Map<string, string>();
-    const dirs = new Set<string>();
-    return {
-      files,
-      dirs,
-      readFileSync: (p: string) => {
-        const v = files.get(p);
-        if (v === undefined) throw Object.assign(new Error("ENOENT"), { code: "ENOENT" });
-        return v;
-      },
-      writeFileSync: (p: string, data: string) => {
-        files.set(p, data);
-      },
-      existsSync: (p: string) => files.has(p),
-      mkdirSync: (p: string) => {
-        dirs.add(p);
-      },
-      joinPath: (...parts: string[]) => parts.join("/"),
-    };
-  }
-
-  it("returns emptyLockout when no file exists", () => {
-    const ops = fakeOps();
-    expect(loadLockout("/agent", ops)).toEqual(emptyLockout());
-  });
-
-  it("round-trips a saved lockout", () => {
-    const ops = fakeOps();
-    const original = nextLockout("default", NOW);
-    saveLockout("/agent", original, ops);
-    expect(loadLockout("/agent", ops)).toEqual(original);
-  });
-
-  it("creates the .claude directory before writing", () => {
-    const ops = fakeOps();
-    saveLockout("/agent", nextLockout("default", NOW), ops);
-    expect(ops.dirs.has("/agent/.claude")).toBe(true);
-  });
-
-  it("falls back to emptyLockout on malformed JSON (not a hard fail)", () => {
-    const ops = fakeOps();
-    ops.files.set("/agent/.claude/auto-fallback-lockout.json", "{broken json");
-    expect(loadLockout("/agent", ops)).toEqual(emptyLockout());
-  });
-
-  it("falls back to emptyLockout on missing fields", () => {
-    const ops = fakeOps();
-    ops.files.set(
-      "/agent/.claude/auto-fallback-lockout.json",
-      JSON.stringify({ wrong: "shape" }),
-    );
-    expect(loadLockout("/agent", ops)).toEqual(emptyLockout());
-  });
-
-  it("falls back to emptyLockout on non-finite lastTransitionAt", () => {
-    const ops = fakeOps();
-    ops.files.set(
-      "/agent/.claude/auto-fallback-lockout.json",
-      JSON.stringify({ lastTransitionedFrom: "x", lastTransitionAt: "nope" }),
-    );
-    expect(loadLockout("/agent", ops)).toEqual(emptyLockout());
+    expect(loadLockout("/agent", ops)).toEqual(EMPTY);
   });
 });