switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/active-pins-sweep.test.ts

@@ -1,309 +0,0 @@
-/**
- * Tests for sweepActivePins — the shared helper called by both the
- * startup failsafe and the /restart, /reconcile --restart, and /update
- * command handlers to unpin any still-pinned progress cards and clear
- * the sidecar.
- *
- * The real unpin path goes through `lockedBot.api.unpinChatMessage`.
- * These tests inject a fake unpin callback so behavior is verified
- * without a Telegram stub — the shape under test is:
- *
- *   1. Reads the sidecar
- *   2. Calls unpinFn(chatId, messageId) for each entry
- *   3. Swallows unpin errors (best-effort — the message may already be
- *      gone, or the bot may have lost admin rights)
- *   4. Clears the sidecar regardless of success/failure
- *   5. Bounded by timeoutMs so a hung Telegram API can't block a
- *      restart indefinitely
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { addActivePin, readActivePins, ACTIVE_PINS_FILENAME, type ActivePin } from "../active-pins.js";
-import {
-  sweepActivePins,
-  sweepBotAuthoredPins,
-  type PinnedMessageInfo,
-} from "../active-pins-sweep.js";
-
-describe("sweepActivePins", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "active-pins-sweep-"));
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  const makePin = (overrides: Partial<ActivePin> = {}): ActivePin => ({
-    chatId: "100",
-    messageId: 42,
-    turnKey: "100:0:1",
-    pinnedAt: 1_700_000_000_000,
-    ...overrides,
-  });
-
-  it("is a no-op when the sidecar is empty", async () => {
-    const calls: Array<[string, number]> = [];
-    const result = await sweepActivePins(tmp, async (chatId, messageId) => {
-      calls.push([chatId, messageId]);
-    });
-    expect(calls).toEqual([]);
-    expect(result.swept).toEqual([]);
-    expect(result.timedOut).toBe(false);
-  });
-
-  it("calls unpin for each sidecar entry and clears the file", async () => {
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 1, turnKey: "A:0:1" }));
-    addActivePin(tmp, makePin({ chatId: "B", messageId: 2, turnKey: "B:0:1" }));
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 3, turnKey: "A:0:2" }));
-
-    const calls: Array<[string, number]> = [];
-    const result = await sweepActivePins(tmp, async (chatId, messageId) => {
-      calls.push([chatId, messageId]);
-    });
-
-    expect(calls.sort()).toEqual([
-      ["A", 1],
-      ["A", 3],
-      ["B", 2],
-    ]);
-    expect(result.swept).toHaveLength(3);
-    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    expect(readActivePins(tmp)).toEqual([]);
-  });
-
-  it("still clears the sidecar when unpin throws for every entry", async () => {
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
-    addActivePin(tmp, makePin({ chatId: "B", messageId: 2, turnKey: "B:0:1" }));
-
-    const errors: string[] = [];
-    await sweepActivePins(
-      tmp,
-      async () => {
-        throw new Error("message to unpin not found");
-      },
-      { log: (msg) => errors.push(msg) },
-    );
-
-    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    expect(readActivePins(tmp)).toEqual([]);
-    // Each failure is logged — log receives one "sweeping N" line plus
-    // one "unpin failed" line per entry.
-    expect(errors.some((e) => e.includes("sweeping 2"))).toBe(true);
-    expect(errors.filter((e) => e.includes("unpin failed"))).toHaveLength(2);
-  });
-
-  it("tolerates a mix of successful and failing unpins", async () => {
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 2, turnKey: "A:0:2" }));
-
-    const unpinned: Array<[string, number]> = [];
-    await sweepActivePins(tmp, async (chatId, messageId) => {
-      if (messageId === 2) throw new Error("nope");
-      unpinned.push([chatId, messageId]);
-    });
-
-    expect(unpinned).toEqual([["A", 1]]);
-    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-  });
-
-  it("returns after timeoutMs even if unpin never resolves", async () => {
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
-
-    const start = Date.now();
-    const result = await sweepActivePins(
-      tmp,
-      () => new Promise(() => { /* never resolves */ }),
-      { timeoutMs: 50 },
-    );
-    const elapsed = Date.now() - start;
-
-    expect(result.timedOut).toBe(true);
-    expect(elapsed).toBeLessThan(500);
-    // Sidecar is cleared even though the unpin never landed — stale
-    // entries get retried from Telegram's side on next boot but we
-    // don't want the sweep to keep re-firing them forever.
-    expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-  });
-
-  it("passes the caller-provided log hook", async () => {
-    addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
-    const lines: string[] = [];
-    await sweepActivePins(
-      tmp,
-      async () => { /* succeed silently */ },
-      { log: (msg) => lines.push(msg) },
-    );
-    expect(lines).toContain("sweeping 1 active pin(s)");
-  });
-});
-
-describe("sweepBotAuthoredPins", () => {
-  const BOT_ID = 1000;
-
-  /**
-   * Build a fake getTopPin backed by a map of { chatId: queue }.
-   * Each unpin pops the head of the queue — which mimics Telegram's
-   * "unpinning the top reveals the next most recent pin" behavior.
-   */
-  function fakeChats(
-    state: Record<string, Array<{ messageId: number; fromId: number | null }>>,
-  ) {
-    const getTopPin = async (chatId: string): Promise<PinnedMessageInfo | null> => {
-      const q = state[chatId] ?? [];
-      return q.length === 0 ? null : { ...q[0] };
-    };
-    const unpinCalls: Array<[string, number]> = [];
-    const unpin = async (chatId: string, messageId: number): Promise<void> => {
-      unpinCalls.push([chatId, messageId]);
-      const q = state[chatId] ?? [];
-      if (q[0]?.messageId === messageId) q.shift();
-    };
-    return { getTopPin, unpin, unpinCalls };
-  }
-
-  it("is a no-op when no chats are provided", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({});
-    const result = await sweepBotAuthoredPins([], BOT_ID, getTopPin, unpin);
-    expect(unpinCalls).toEqual([]);
-    expect(result.total).toBe(0);
-    expect(result.perChat).toEqual({});
-  });
-
-  it("is a no-op when a chat has no pinned message", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({ A: [] });
-    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
-    expect(unpinCalls).toEqual([]);
-    expect(result.total).toBe(0);
-  });
-
-  it("unpins consecutive bot-authored pins until a foreign pin is reached", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({
-      A: [
-        { messageId: 10, fromId: BOT_ID },
-        { messageId: 9, fromId: BOT_ID },
-        { messageId: 8, fromId: 42 }, // user pin — barrier
-        { messageId: 7, fromId: BOT_ID }, // would be unpinned if barrier weren't there
-      ],
-    });
-    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
-    expect(unpinCalls).toEqual([
-      ["A", 10],
-      ["A", 9],
-    ]);
-    expect(result.total).toBe(2);
-    expect(result.perChat).toEqual({ A: 2 });
-  });
-
-  it("stops immediately when the top pin belongs to someone else", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({
-      A: [
-        { messageId: 5, fromId: 999 },
-        { messageId: 4, fromId: BOT_ID },
-      ],
-    });
-    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
-    expect(unpinCalls).toEqual([]);
-    expect(result.total).toBe(0);
-  });
-
-  it("treats pins with no from.id as foreign (anonymous channel post)", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({
-      A: [
-        { messageId: 5, fromId: null },
-        { messageId: 4, fromId: BOT_ID },
-      ],
-    });
-    const result = await sweepBotAuthoredPins(["A"], BOT_ID, getTopPin, unpin);
-    expect(unpinCalls).toEqual([]);
-    expect(result.total).toBe(0);
-  });
-
-  it("iterates across multiple chats independently", async () => {
-    const { getTopPin, unpin, unpinCalls } = fakeChats({
-      A: [
-        { messageId: 1, fromId: BOT_ID },
-        { messageId: 2, fromId: BOT_ID },
-      ],
-      B: [{ messageId: 3, fromId: 777 }],
-      C: [{ messageId: 4, fromId: BOT_ID }],
-    });
-    const result = await sweepBotAuthoredPins(
-      ["A", "B", "C"],
-      BOT_ID,
-      getTopPin,
-      unpin,
-    );
-    expect(unpinCalls).toEqual([
-      ["A", 1],
-      ["A", 2],
-      ["C", 4],
-    ]);
-    expect(result.total).toBe(3);
-    expect(result.perChat).toEqual({ A: 2, C: 1 });
-  });
-
-  it("advances to the next chat when getTopPin throws", async () => {
-    const unpinCalls: Array<[string, number]> = [];
-    const errors: string[] = [];
-    const result = await sweepBotAuthoredPins(
-      ["A", "B"],
-      BOT_ID,
-      async (chatId) => {
-        if (chatId === "A") throw new Error("boom");
-        return { messageId: 7, fromId: BOT_ID };
-      },
-      async (chatId, messageId) => {
-        unpinCalls.push([chatId, messageId]);
-        // Simulate "pin is gone after unpin" so the B loop terminates
-        throw new Error("already gone");
-      },
-      { log: (msg) => errors.push(msg) },
-    );
-    // A errored on getChat; B attempted one unpin (which threw) then stopped
-    expect(unpinCalls).toEqual([["B", 7]]);
-    expect(result.total).toBe(0);
-    expect(errors.some((e) => e.includes("getChat failed for A"))).toBe(true);
-    expect(errors.some((e) => e.includes("unpin failed for B/7"))).toBe(true);
-  });
-
-  it("breaks out of a chat on unpin failure to avoid infinite loops", async () => {
-    const calls: Array<[string, number]> = [];
-    const result = await sweepBotAuthoredPins(
-      ["A"],
-      BOT_ID,
-      async () => ({ messageId: 1, fromId: BOT_ID }),
-      async (chatId, messageId) => {
-        calls.push([chatId, messageId]);
-        throw new Error("permission denied");
-      },
-    );
-    // Without the break, the fake getTopPin would keep returning the same
-    // pin and we'd loop until maxPerChat. With the break, we see exactly
-    // one call and the sweep moves on.
-    expect(calls).toEqual([["A", 1]]);
-    expect(result.total).toBe(0);
-  });
-
-  it("is bounded by maxPerChat when pins keep re-appearing", async () => {
-    // A pathological case: getTopPin always returns a bot-authored pin,
-    // and unpin silently "succeeds" without removing it. Without the
-    // maxPerChat bound the loop would be infinite.
-    let calls = 0;
-    await sweepBotAuthoredPins(
-      ["A"],
-      BOT_ID,
-      async () => ({ messageId: 1, fromId: BOT_ID }),
-      async () => {
-        calls++;
-      },
-      { maxPerChat: 5 },
-    );
-    expect(calls).toBe(5);
-  });
-});

package/telegram-plugin/tests/active-pins.test.ts

@@ -1,187 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  readActivePins,
-  writeActivePins,
-  addActivePin,
-  removeActivePin,
-  clearActivePins,
-  ACTIVE_PINS_FILENAME,
-  type ActivePin,
-} from "../active-pins.js";
-
-describe("active-pins sidecar", () => {
-  let tmp: string;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "active-pins-"));
-  });
-
-  afterEach(() => {
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  const makePin = (overrides: Partial<ActivePin> = {}): ActivePin => ({
-    chatId: "100",
-    messageId: 42,
-    turnKey: "100:0:1",
-    pinnedAt: 1_700_000_000_000,
-    ...overrides,
-  });
-
-  describe("readActivePins", () => {
-    it("returns [] when the file is missing", () => {
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-
-    it("returns [] when the file is empty", () => {
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), "");
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-
-    it("returns [] when the file is not valid JSON", () => {
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), "{not json");
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-
-    it("returns [] when the JSON root is not an array", () => {
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), '{"oops": true}');
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-
-    it("round-trips valid pin entries", () => {
-      const pin = makePin();
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify([pin]));
-      expect(readActivePins(tmp)).toEqual([pin]);
-    });
-
-    it("drops entries with missing or wrong-typed fields", () => {
-      const good = makePin({ messageId: 7 });
-      const bad = [
-        good,
-        { chatId: "x", messageId: "not-a-number", turnKey: "k", pinnedAt: 1 },
-        { chatId: "y", messageId: 1, turnKey: "k" }, // missing pinnedAt
-        null,
-        "nope",
-      ];
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify(bad));
-      expect(readActivePins(tmp)).toEqual([good]);
-    });
-  });
-
-  describe("writeActivePins", () => {
-    it("creates the sidecar with JSON content", () => {
-      const pins = [makePin(), makePin({ messageId: 43, turnKey: "100:0:2" })];
-      writeActivePins(tmp, pins);
-      const raw = readFileSync(join(tmp, ACTIVE_PINS_FILENAME), "utf-8");
-      expect(JSON.parse(raw)).toEqual(pins);
-    });
-
-    it("deletes the sidecar when writing an empty list", () => {
-      writeFileSync(join(tmp, ACTIVE_PINS_FILENAME), JSON.stringify([makePin()]));
-      writeActivePins(tmp, []);
-      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    });
-
-    it("is idempotent — deleting an already-missing file is a no-op", () => {
-      writeActivePins(tmp, []);
-      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    });
-  });
-
-  describe("addActivePin", () => {
-    it("creates the sidecar on first add", () => {
-      addActivePin(tmp, makePin());
-      expect(readActivePins(tmp)).toHaveLength(1);
-    });
-
-    it("appends distinct pins", () => {
-      addActivePin(tmp, makePin({ messageId: 1, turnKey: "a" }));
-      addActivePin(tmp, makePin({ messageId: 2, turnKey: "b" }));
-      const pins = readActivePins(tmp);
-      expect(pins).toHaveLength(2);
-      expect(pins.map((p) => p.messageId).sort()).toEqual([1, 2]);
-    });
-
-    it("replaces an existing entry with the same (chatId, messageId)", () => {
-      addActivePin(tmp, makePin({ pinnedAt: 100 }));
-      addActivePin(tmp, makePin({ pinnedAt: 200 }));
-      const pins = readActivePins(tmp);
-      expect(pins).toHaveLength(1);
-      expect(pins[0].pinnedAt).toBe(200);
-    });
-
-    it("treats different chatIds as distinct even with matching messageIds", () => {
-      addActivePin(tmp, makePin({ chatId: "A", messageId: 1 }));
-      addActivePin(tmp, makePin({ chatId: "B", messageId: 1 }));
-      expect(readActivePins(tmp)).toHaveLength(2);
-    });
-  });
-
-  describe("removeActivePin", () => {
-    it("removes the matching entry", () => {
-      addActivePin(tmp, makePin({ messageId: 1, turnKey: "a" }));
-      addActivePin(tmp, makePin({ messageId: 2, turnKey: "b" }));
-      removeActivePin(tmp, "100", 1);
-      const pins = readActivePins(tmp);
-      expect(pins).toHaveLength(1);
-      expect(pins[0].messageId).toBe(2);
-    });
-
-    it("deletes the sidecar when the last entry is removed", () => {
-      addActivePin(tmp, makePin());
-      removeActivePin(tmp, "100", 42);
-      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    });
-
-    it("is a no-op when the file is missing", () => {
-      removeActivePin(tmp, "100", 42);
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-
-    it("is a no-op when no entry matches", () => {
-      addActivePin(tmp, makePin({ messageId: 1 }));
-      removeActivePin(tmp, "100", 999);
-      expect(readActivePins(tmp)).toHaveLength(1);
-    });
-
-    it("only matches on (chatId, messageId) — turnKey/pinnedAt are ignored", () => {
-      addActivePin(tmp, makePin({ chatId: "A", messageId: 1, turnKey: "x" }));
-      removeActivePin(tmp, "A", 1);
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-  });
-
-  describe("clearActivePins", () => {
-    it("deletes the sidecar outright", () => {
-      addActivePin(tmp, makePin());
-      addActivePin(tmp, makePin({ messageId: 43, turnKey: "b" }));
-      clearActivePins(tmp);
-      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    });
-
-    it("is a no-op when the file is missing", () => {
-      clearActivePins(tmp);
-      expect(existsSync(join(tmp, ACTIVE_PINS_FILENAME))).toBe(false);
-    });
-  });
-
-  describe("crash → restart simulation", () => {
-    it("sidecar survives to be read by a fresh process", () => {
-      addActivePin(tmp, makePin({ chatId: "C1", messageId: 10, turnKey: "C1:0:1" }));
-      addActivePin(tmp, makePin({ chatId: "C2", messageId: 20, turnKey: "C2:0:1" }));
-      // simulated restart — only thing a fresh process has is agentDir
-      const recovered = readActivePins(tmp);
-      expect(recovered).toHaveLength(2);
-      expect(recovered.map((p) => `${p.chatId}/${p.messageId}`).sort()).toEqual([
-        "C1/10",
-        "C2/20",
-      ]);
-      // sweep: unpin each then clear
-      clearActivePins(tmp);
-      expect(readActivePins(tmp)).toEqual([]);
-    });
-  });
-});

package/telegram-plugin/tests/auth-account-identity-surface.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  buildDashboardText,
-  formatRateLimitTier,
-  type DashboardState,
-  type DashboardSlot,
-} from "../auth-dashboard";
-
-function slot(o: Partial<DashboardSlot> = {}): DashboardSlot {
-  return { slot: "default", active: false, health: "healthy", quotaExhaustedUntil: null, fiveHourPct: null, sevenDayPct: null, ...o };
-}
-
-/**
- * 2026-04-22 — account-identity surface.
- *
- * Context: a user reauths an agent onto their Max 20x account, but the
- * OAuth browser flow gets hijacked by Telegram's in-app WebView (which
- * uses a separate cookie jar from their main browser) and the saved
- * token ends up for a different account (e.g. a Max 5x) instead. The
- * dashboard header showed 'Plan: max' \u2014 indistinguishable between
- * 5x and 20x \u2014 so the mismatch was silent until the user hit a quota wall
- * hours later.
- *
- * Fix: surface the full `rateLimitTier` string on the dashboard so a
- * wrong-account reauth is IMMEDIATELY visible. User expected max_20x,
- * sees max_5x, acts.
- *
- * Pair fixes (out of scope for these tests but covered in the PR):
- * - Auth response now includes a \ud83d\udccb Copy URL button so the user can
- *   paste into their main browser instead of Telegram's WebView.
- * - Auth response text includes a tip about the in-app-browser pitfall.
- */
-
-describe("formatRateLimitTier", () => {
-  it("shortens default_claude_max_5x to max_5x", () => {
-    expect(formatRateLimitTier("default_claude_max_5x")).toBe("max_5x");
-  });
-
-  it("shortens default_claude_max_20x to max_20x", () => {
-    expect(formatRateLimitTier("default_claude_max_20x")).toBe("max_20x");
-  });
-
-  it("shortens default_claude_pro to pro", () => {
-    expect(formatRateLimitTier("default_claude_pro")).toBe("pro");
-  });
-
-  it("passes unknown tiers through unchanged", () => {
-    // We don't pretend to understand every future tier string. Passthrough
-    // means a new Anthropic tier name is visible verbatim until we
-    // update the formatter.
-    expect(formatRateLimitTier("team_custom_42")).toBe("team_custom_42");
-    expect(formatRateLimitTier("enterprise_unlimited")).toBe("enterprise_unlimited");
-  });
-
-  it("handles empty/null-ish input gracefully", () => {
-    expect(formatRateLimitTier("")).toBe("");
-  });
-});
-
-describe("dashboard header surfaces rateLimitTier when present", () => {
-  const base: DashboardState = {
-    agent: "lawgpt",
-    bankId: "lawgpt",
-    plan: "max",
-    slots: [slot({ active: true })],
-    quotaHot: false,
-  };
-
-  it("shows max_20x when on the bigger plan", () => {
-    const text = buildDashboardText({ ...base, rateLimitTier: "default_claude_max_20x" });
-    expect(text).toContain("Plan: <b>max_20x</b>");
-    // Should NOT just say 'max' \u2014 that's the ambiguous label that
-    // hid the account mismatch in the incident.
-    expect(text).not.toContain("Plan: <b>max</b>");
-  });
-
-  it("shows max_5x when on the smaller plan", () => {
-    const text = buildDashboardText({ ...base, rateLimitTier: "default_claude_max_5x" });
-    expect(text).toContain("Plan: <b>max_5x</b>");
-  });
-
-  it("falls back to plan label when rateLimitTier missing", () => {
-    const text = buildDashboardText({ ...base, rateLimitTier: null });
-    expect(text).toContain("Plan: <b>max</b>");
-  });
-
-  it("falls back to plan label when rateLimitTier undefined", () => {
-    const text = buildDashboardText({ ...base });
-    expect(text).toContain("Plan: <b>max</b>");
-  });
-
-  it("omits Plan: when neither tier nor plan are known", () => {
-    const text = buildDashboardText({ ...base, plan: null, rateLimitTier: null });
-    expect(text).not.toContain("Plan:");
-    expect(text).toContain("Bank: <code>lawgpt</code>");
-  });
-
-  it("escapes HTML in tier (injection guard)", () => {
-    const text = buildDashboardText({
-      ...base,
-      rateLimitTier: "<script>alert(1)</script>",
-    });
-    expect(text).not.toContain("<script>");
-    expect(text).toContain("&lt;script&gt;");
-  });
-
-  it("pair assertion: user can distinguish 5x from 20x without hunting", () => {
-    // Regression anchor: this was the exact confusion in the incident.
-    // The user saw 'Plan: max' for both accounts and couldn't tell
-    // which got authorized. With the tier string present, 5x and 20x
-    // look different in a glance.
-    const fivex = buildDashboardText({ ...base, rateLimitTier: "default_claude_max_5x" });
-    const twentyx = buildDashboardText({ ...base, rateLimitTier: "default_claude_max_20x" });
-    expect(fivex).not.toBe(twentyx);
-    expect(fivex).toContain("5x");
-    expect(twentyx).toContain("20x");
-  });
-});