switchroom 0.5.0

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

@@ -0,0 +1,183 @@
+/**
+ * End-to-end tests for the auto-fallback notification dispatcher
+ * (#11 / #420 / #421).
+ *
+ * `auto-fallback.ts` returns a `FallbackPlan` (pure). This test
+ * exercises the side-effecting half: given a plan, does the
+ * dispatcher emit the right Bot API call to the owner chat?
+ *
+ * The pure plan logic itself is covered by `auto-fallback.test.ts`.
+ * This file locks in the wiring so a regression in dispatch (wrong
+ * parse_mode, missing link-preview disable, swallowed errors) is
+ * caught here instead of going silent in production.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  dispatchFallbackNotification,
+  type DispatchOutcome,
+} from '../auto-fallback-dispatcher.js';
+import type { FallbackPlan } from '../auto-fallback.js';
+import { createFakeBotApi, errors, type FakeBot } from './fake-bot-api.js';
+
+const OWNER = 'chat-owner';
+
+let bot: FakeBot;
+
+beforeEach(() => {
+  bot = createFakeBotApi({ startMessageId: 200 });
+});
+
+function planExecuted(): FallbackPlan {
+  return {
+    kind: 'executed',
+    previousSlot: 'default',
+    newSlot: 'personal',
+    resetAtMs: Date.now() + 60_000,
+    notificationHtml:
+      '⚠️ <b>Quota exhausted</b> on slot <code>default</code>. Switched to <code>personal</code>.',
+    agentName: 'clerk',
+    triggerReason: '429-response',
+  };
+}
+
+function planExhaustedAll(): FallbackPlan {
+  return {
+    kind: 'exhausted-all',
+    activeSlot: 'default',
+    resetAtMs: Date.now() + 4 * 60 * 60_000,
+    notificationHtml:
+      '🚨 <b>All slots quota-exhausted</b> for clerk. Run /auth add to attach another subscription.',
+    agentName: 'clerk',
+  };
+}
+
+describe('dispatchFallbackNotification — happy path', () => {
+  it('sends executed plan with HTML parse_mode + link preview disabled', async () => {
+    const plan = planExecuted();
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan,
+    });
+    expect(outcome).toEqual<DispatchOutcome>({ kind: 'sent', messageId: 200 });
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    const [chat, text, opts] = bot.api.sendMessage.mock.calls[0];
+    expect(chat).toBe(OWNER);
+    expect(text).toBe(plan.notificationHtml);
+    expect(opts).toMatchObject({
+      parse_mode: 'HTML',
+      link_preview_options: { is_disabled: true },
+    });
+  });
+
+  it('sends exhausted-all plan to owner chat', async () => {
+    const plan = planExhaustedAll();
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan,
+    });
+    expect(outcome.kind).toBe('sent');
+    const text = bot.api.sendMessage.mock.calls[0][1] as string;
+    expect(text).toContain('All slots quota-exhausted');
+    expect(text).toContain('clerk');
+  });
+
+  it('chat model reflects the sent message', async () => {
+    await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan: planExecuted(),
+    });
+    const sent = bot.messagesIn(OWNER);
+    expect(sent).toHaveLength(1);
+    expect(sent[0].text).toContain('Quota exhausted');
+    expect(sent[0].parse_mode).toBe('HTML');
+  });
+});
+
+describe('dispatchFallbackNotification — no chat', () => {
+  it('returns no-chat when ownerChatId is null', async () => {
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: null,
+      plan: planExecuted(),
+    });
+    expect(outcome).toEqual({ kind: 'no-chat' });
+    expect(bot.api.sendMessage).not.toHaveBeenCalled();
+  });
+
+  it('returns no-chat when ownerChatId is undefined (access.allowFrom empty)', async () => {
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: undefined,
+      plan: planExecuted(),
+    });
+    expect(outcome).toEqual({ kind: 'no-chat' });
+    expect(bot.api.sendMessage).not.toHaveBeenCalled();
+  });
+
+  it('returns no-chat for empty string', async () => {
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: '',
+      plan: planExecuted(),
+    });
+    expect(outcome).toEqual({ kind: 'no-chat' });
+    expect(bot.api.sendMessage).not.toHaveBeenCalled();
+  });
+});
+
+describe('dispatchFallbackNotification — error paths', () => {
+  it('forbidden error (bot blocked) is reported via onError, never throws', async () => {
+    bot.faults.next('sendMessage', errors.forbidden());
+    const onError = vi.fn();
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan: planExecuted(),
+      onError,
+    });
+    expect(outcome).toEqual({ kind: 'error' });
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  it('flood-wait error is reported via onError, never throws', async () => {
+    bot.faults.next('sendMessage', errors.floodWait(15));
+    const onError = vi.fn();
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan: planExhaustedAll(),
+      onError,
+    });
+    expect(outcome).toEqual({ kind: 'error' });
+    expect(onError).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  it('network error is reported via onError, never throws', async () => {
+    bot.faults.next('sendMessage', errors.networkError('ECONNRESET'));
+    const onError = vi.fn();
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan: planExecuted(),
+      onError,
+    });
+    expect(outcome).toEqual({ kind: 'error' });
+    expect(onError).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  it('omitted onError still resolves cleanly on failure', async () => {
+    bot.faults.next('sendMessage', errors.forbidden());
+    // No onError supplied — should not throw, just return error outcome.
+    const outcome = await dispatchFallbackNotification({
+      bot,
+      ownerChatId: OWNER,
+      plan: planExecuted(),
+    });
+    expect(outcome).toEqual({ kind: 'error' });
+  });
+});

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

@@ -0,0 +1,381 @@
+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 {
+  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,
+    },
+  };
+}
+
+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");
+  });
+
+  it("5h utilization at default threshold → fallback", () => {
+    const d = evaluateFallbackTrigger({
+      quota: okQuota(DEFAULT_TRIGGER_UTILIZATION_PCT, 50),
+      activeSlot: "default",
+      now: NOW,
+      lockout: emptyLockout(),
+    });
+    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(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,
+    });
+    expect(d.action).toBe("fallback");
+    if (d.action === "fallback") expect(d.triggerReason).toBe("429-response");
+  });
+
+  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,
+    });
+    expect(d.action).toBe("noop");
+    if (d.action === "noop") expect(d.reason).toMatch(/cooldown/);
+  });
+
+  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,
+    });
+    expect(d.action).toBe("fallback");
+  });
+
+  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,
+    });
+    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());
+  });
+});

package/telegram-plugin/tests/boot-card-account-quota.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Boot card per-account quota rendering — issue #708.
+ *
+ * Verifies:
+ *   - When `accounts` is absent / empty, the card stays silent (today's
+ *     contract — no accounts section).
+ *   - When `accounts` is present, the card appends an "Accounts (N)"
+ *     header and one line per account with 5h % / 7d % / nearest reset.
+ *   - The ▶ marker tags the active-for-this-agent account; ↳ tags the
+ *     rest.
+ *   - HTML escaping on account labels.
+ *   - Account with no quota fields (label only) renders the row without
+ *     any percent / reset suffix.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  renderBootCard,
+  renderAccountRows,
+} from '../gateway/boot-card.js'
+import type { AccountSummary } from '../auth-dashboard.js'
+
+const NOW = new Date('2026-05-05T10:00:00Z')
+
+function mk(overrides: Partial<AccountSummary> = {}): AccountSummary {
+  return {
+    label: 'pixsoul@gmail.com',
+    health: 'healthy',
+    enabledHere: true,
+    activeForThisAgent: false,
+    fiveHourPct: 10,
+    sevenDayPct: 79,
+    fiveHourResetAt: NOW.getTime() + 2 * 3600_000 + 14 * 60_000,
+    sevenDayResetAt: NOW.getTime() + 5 * 86_400_000,
+    ...overrides,
+  }
+}
+
+describe('renderBootCard — per-account quota (issue #708)', () => {
+  it('omits the accounts section when accounts is undefined', () => {
+    const out = renderBootCard({ agentName: 'clerk', version: 'v0.7.0' })
+    expect(out).not.toContain('Accounts')
+  })
+
+  it('omits the accounts section when accounts is empty', () => {
+    const out = renderBootCard({
+      agentName: 'clerk',
+      version: 'v0.7.0',
+      accounts: [],
+    })
+    expect(out).not.toContain('Accounts')
+  })
+
+  it('renders the active account with ▶ and inline 5h / 7d / reset', () => {
+    const out = renderBootCard({
+      agentName: 'clerk',
+      version: 'v0.7.0',
+      accounts: [mk({ activeForThisAgent: true })],
+      now: NOW,
+    })
+    expect(out).toContain('Accounts (1)')
+    expect(out).toContain('▶')
+    expect(out).toContain('pixsoul@gmail.com')
+    expect(out).toContain('10%')
+    expect(out).toContain('79%')
+    expect(out).toContain('5h resets in')
+  })
+
+  it('renders fallback accounts with ↳', () => {
+    const out = renderBootCard({
+      agentName: 'clerk',
+      version: 'v0.7.0',
+      now: NOW,
+      accounts: [
+        mk({ activeForThisAgent: true }),
+        mk({ label: 'ken+work@example.com', activeForThisAgent: false }),
+      ],
+    })
+    expect(out).toContain('Accounts (2)')
+    expect(out).toMatch(/↳ <code>ken\+work@example\.com<\/code>/)
+  })
+
+  it('escapes HTML in labels', () => {
+    const out = renderAccountRows(
+      [mk({ label: 'evil<script>', activeForThisAgent: true })],
+      NOW,
+    )
+    expect(out.join('\n')).toContain('evil&lt;script&gt;')
+    expect(out.join('\n')).not.toContain('<script>')
+  })
+
+  it('renders a row with no quota numbers as label-only', () => {
+    const summary: AccountSummary = {
+      label: 'just-added',
+      health: 'healthy',
+      enabledHere: true,
+      activeForThisAgent: false,
+    }
+    const out = renderAccountRows([summary], NOW)
+    expect(out).toHaveLength(2)
+    expect(out[1]).toBe('↳ <code>just-added</code>')
+  })
+
+  it('shows 7d reset when 5h reset is missing', () => {
+    const out = renderAccountRows(
+      [
+        mk({
+          activeForThisAgent: true,
+          fiveHourPct: 0,
+          sevenDayPct: 99,
+          fiveHourResetAt: undefined,
+          sevenDayResetAt: NOW.getTime() + 86_400_000 + 3 * 3600_000,
+        }),
+      ],
+      NOW,
+    )
+    expect(out.join('\n')).toContain('7d resets in')
+  })
+
+  it('drops the reset suffix once the reset timestamp has elapsed', () => {
+    const out = renderAccountRows(
+      [
+        mk({
+          activeForThisAgent: true,
+          fiveHourPct: 0,
+          sevenDayPct: 0,
+          fiveHourResetAt: NOW.getTime() - 60_000,
+          sevenDayResetAt: undefined,
+        }),
+      ],
+      NOW,
+    )
+    // Past-reset timestamps return "" from formatNearestAccountResetSuffix,
+    // so the line should not contain "resets in" at all.
+    expect(out.join('\n')).not.toContain('resets in')
+  })
+})