@opengeni/react 6.8.0 → 6.9.1-canary.41937124785001

package/src/app/components/session/subscription-account.test.ts

@@ -71,7 +71,9 @@ describe("one menu for every subscription provider", () => {
   test("Codex and Claude differ only in the provider name", () => {
     const claude = subscriptionAccountMenuContent(state({ provider: "claude" }));
     const codex = subscriptionAccountMenuContent(state({ provider: "codex" }));
-    const neutral = (value: unknown) => JSON.stringify(value).replaceAll(/Claude|Codex/g, "X");
+    // The provider name and the brand its plans are sold under.
+    const neutral = (value: unknown) =>
+      JSON.stringify(value).replaceAll(/Claude|Codex|ChatGPT/g, "X");
     expect(neutral(codex)).toBe(neutral(claude));
     expect(claude.ariaLabel).toBe("Claude account · Acme a");
     expect(codex.ariaLabel).toBe("Codex account · Acme a");
@@ -81,28 +83,25 @@ describe("one menu for every subscription provider", () => {
     const content = subscriptionAccountMenuContent(state());
     expect(content.selectionLabel).toBe("Current account");
     expect(content.identity).toBe("a@example.test");
-    expect(content.metadata).toBe("Pro · Organization");
-    expect(content.usage.windows?.map((window) => [window.label, window.usedPercent])).toEqual([
-      ["5h", 36],
-      ["Week", 62],
+    expect(content.metadata).toBe("Claude Pro · Organization");
+    expect(content.usage.windows?.map((window) => [window.label, window.leftPercent])).toEqual([
+      ["5h", 64],
+      ["Week", 38],
     ]);
     expect(content.usage.note).toStartWith("Updated ");
     expect(content.automaticLabel).toBe("Automatic");
     expect(content.actionLabel).toBe("Use for next turn");
-    // Other accounts summarize each window; the current one is shown above.
-    expect(content.accounts.map((row) => row.usageSummary)).toEqual([
-      undefined,
-      "5h 36% · Week 62% used",
-      undefined,
-    ]);
-    // Each summarized row also draws its most-used window as a bar.
-    expect(content.accounts.map((row) => row.usageBar)).toEqual([
-      undefined,
-      { label: "Week", usedPercent: 62 },
-      undefined,
-    ]);
+    // Other accounts list every window; the current one is shown above.
+    expect(
+      content.accounts.map((row) => row.windows?.map((window) => window.label) ?? null),
+    ).toEqual([null, ["5h", "Week"], []]);
     expect(content.accounts[2]).toMatchObject({ status: "Needs reconnect", disabled: true });
-    expect(content.accounts[1]?.detail).toBe("Acme b · b@example.test · Pro · This workspace");
+    expect(content.accounts[1]?.detail).toBe(
+      "Acme b · b@example.test · Claude Pro · This workspace",
+    );
+    // Every account has the same plan, so it is shown once, not on each row.
+    expect(content.plan).toBe("Claude Pro");
+    expect(content.accounts.map((row) => row.plan)).toEqual([null, null, null]);
   });
 
   test("a turn waiting for capacity offers a retry for any provider", () => {
@@ -172,11 +171,9 @@ describe("one menu for every subscription provider", () => {
 
   test("a failed check on the current account keeps the other accounts' readings", () => {
     const failed = subscriptionAccountMenuContent(state({ usageCheck: "failed" }));
-    expect(failed.accounts.map((row) => row.usageSummary)).toEqual([
-      undefined,
-      "5h 36% · Week 62% used",
-      undefined,
-    ]);
+    expect(
+      failed.accounts.map((row) => row.windows?.map((window) => window.leftPercent) ?? null),
+    ).toEqual([null, [64, 38], []]);
   });
 
   test("the serving account is the current account, even when another one is chosen", () => {
@@ -223,7 +220,7 @@ describe("one menu for every subscription provider", () => {
   test("a live check hides readings until it answers", () => {
     const checking = subscriptionAccountMenuContent(state({ usageCheck: "checking" }));
     expect(checking.usage).toEqual({ checking: true });
-    expect(checking.accounts.every((row) => row.usageSummary === undefined)).toBe(true);
+    expect(checking.accounts.every((row) => row.windows === null)).toBe(true);
     expect(subscriptionAccountMenuContent(state({ usageCheck: "failed" })).usage).toEqual({
       unavailable: true,
     });
@@ -236,67 +233,177 @@ describe("usage readings", () => {
       exhaustedUntil: "2026-10-22T10:00:00Z",
       exhaustedKind: "quota",
     });
-    expect(subscriptionAccountUsage(ended, Date.parse("2026-10-22T11:00:00Z")).message).toBe(
-      "No usage reading yet",
-    );
-    expect(subscriptionAccountUsage(ended, Date.parse("2026-10-22T09:00:00Z")).message).toStartWith(
-      "Limit reached until ",
-    );
+    expect(
+      subscriptionAccountUsage("claude", ended, Date.parse("2026-10-22T11:00:00Z")).message,
+    ).toBe("No usage reading yet");
+    expect(
+      subscriptionAccountUsage("claude", ended, Date.parse("2026-10-22T09:00:00Z")).message,
+    ).toStartWith("Limit reached until ");
   });
 
   test("missing readings and empty snapshots say there is no reading yet", () => {
-    expect(subscriptionAccountUsage(undefined).message).toBe("No usage reading yet");
-    expect(subscriptionAccountUsage(null).message).toBe("No usage reading yet");
-    const empty = subscriptionAccountUsage(snapshot([]));
+    expect(subscriptionAccountUsage("claude", undefined).message).toBe("No usage reading yet");
+    expect(subscriptionAccountUsage("claude", null).message).toBe("No usage reading yet");
+    const empty = subscriptionAccountUsage("claude", snapshot([]));
     expect(empty).toMatchObject({ message: "No usage reading yet", windows: [] });
-    expect(empty.note).toBeUndefined();
+    expect(empty.note).toBeNull();
+  });
+
+  test("an account-wide refusal still says until when beside a full Fable week", () => {
+    const now = Date.parse("2026-10-22T09:00:00Z");
+    const reading = snapshot(
+      [
+        { id: "seven_day", usedPercent: 40, resetsAt: null, status: "ok" },
+        { id: "seven_day_fable", usedPercent: 100, resetsAt: null, status: "ok" },
+      ],
+      { exhaustedUntil: "2026-10-22T10:00:00Z", exhaustedKind: "quota" },
+    );
+    expect(subscriptionAccountUsage("claude", reading, now).message).toStartWith(
+      "Limit reached until ",
+    );
   });
 
   test("partial and unknown windows are never completed, aggregated or given a made-up percent", () => {
     const view = subscriptionAccountUsage(
+      "claude",
       snapshot([
         { id: "seven_day_opus", usedPercent: null, resetsAt: null, status: "unknown" },
         { id: "overage", usedPercent: 125, resetsAt: null, status: "unknown" },
         { id: "custom", usedPercent: 8, resetsAt: null, status: "warning" },
       ]),
     );
-    expect(view.windows?.map((window) => window.usedPercent)).toEqual([null, 125, 8]);
-    expect(view.windows?.map((window) => window.label)).toEqual([
-      "Week · Opus",
-      "Overage",
-      "custom",
+    expect(view.windows.map((window) => [window.label, window.leftPercent])).toEqual([
+      ["Opus week", null],
+      ["Custom", 92],
+      ["Extra usage", 0],
     ]);
-    expect(view.summary).toBe("Week · Opus unknown · Overage 125% · custom 8% used");
-    expect(view.windows?.[0]?.detail).toContain("Status unknown");
-    expect(view.windows?.[2]?.detail).toContain("Near its limit");
+    // The provider's own warning counts even with plenty left.
+    expect(view.windows[1]?.nearLimit).toBe(true);
+    // Extra usage never makes the account look limited.
+    expect(view.limit).toMatchObject({ reached: false, near: true });
   });
 
-  test("neutral primary/secondary ids do not claim a window length", () => {
-    const view = subscriptionAccountUsage(
-      snapshot([{ id: "primary", usedPercent: 10, resetsAt: null, status: "ok" }]),
-    );
-    expect(view.windows?.[0]?.label).toBe("Primary");
+  test("neutral primary/secondary ids do not claim a window length outside Codex", () => {
+    const value = snapshot([{ id: "primary", usedPercent: 10, resetsAt: null, status: "ok" }]);
+    expect(subscriptionAccountUsage("claude", value).windows[0]?.label).toBe("Primary");
+    expect(subscriptionAccountUsage("xai", value).windows[0]?.label).toBe("Primary");
+    // The shared core stores Codex's 5-hour reading as `primary`.
+    expect(subscriptionAccountUsage("codex", value).windows[0]?.label).toBe("5h");
   });
 
   test("an account-wide limit without windows names when it ends", () => {
     const view = subscriptionAccountUsage(
+      "claude",
       snapshot([], { exhaustedKind: "rate_limit", exhaustedUntil: "2020-01-01T09:00:00Z" }),
       Date.parse("2020-01-01T08:00:00Z"),
     );
     expect(view.message).toStartWith("Limit reached until ");
+    expect(view.limit.reached).toBe(true);
     expect(view.windows).toEqual([]);
   });
 
-  test("a past reset keeps the reading but says it may be outdated", () => {
+  test("a past reset no longer claims the limit or a share left", () => {
     const value = snapshot([
       { id: "five_hour", usedPercent: 100, resetsAt: "2026-10-12T12:00:00Z", status: "exhausted" },
     ]);
-    const before = subscriptionAccountUsage(value, Date.parse("2026-10-12T11:00:00Z"));
-    const after = subscriptionAccountUsage(value, Date.parse("2026-10-12T13:00:00Z"));
-    expect(before.windows?.[0]?.detail).toContain("Resets ");
-    expect(after.windows?.[0]?.detail).toContain("Reset passed; usage may be outdated");
-    expect(after.windows?.[0]?.detail).toContain("Limit reached");
-    expect(after.windows?.[0]?.usedPercent).toBe(100);
+    const before = subscriptionAccountUsage("claude", value, Date.parse("2026-10-12T11:00:00Z"));
+    const after = subscriptionAccountUsage("claude", value, Date.parse("2026-10-12T13:00:00Z"));
+    expect(before.windows[0]).toMatchObject({ limitReached: true, leftPercent: 0 });
+    expect(before.limit).toMatchObject({
+      reached: true,
+      until: Date.parse("2026-10-12T12:00:00Z"),
+    });
+    expect(after.windows[0]).toMatchObject({
+      limitReached: false,
+      leftPercent: null,
+      resetPassed: true,
+      resetsAt: null,
+    });
+    expect(after.limit.reached).toBe(false);
+  });
+
+  test("only reported windows: verified Ultra and ChatGPT Pro have no 5-hour window", () => {
+    const ultra = subscriptionAccountUsage(
+      "claude",
+      snapshot([
+        { id: "seven_day", usedPercent: 24, resetsAt: null, status: "ok" },
+        { id: "seven_day_fable", usedPercent: 61, resetsAt: null, status: "ok" },
+        { id: "overage", usedPercent: 0, resetsAt: null, status: "ok" },
+      ]),
+    );
+    expect(ultra.windows.map((window) => window.label)).toEqual([
+      "Week",
+      "Fable week",
+      "Extra usage",
+    ]);
+    const pro = subscriptionAccountUsage(
+      "codex",
+      snapshot([{ id: "secondary", usedPercent: 40, resetsAt: null, status: "ok" }]),
+    );
+    expect(pro.windows.map((window) => [window.label, window.leftPercent])).toEqual([["Week", 60]]);
+  });
+});
+
+describe("plans and marks in the account list", () => {
+  const claudeAccounts = [
+    account("pro", { plan: "claude_pro", email: "sam.longername.lindqvist@example.test" }),
+    account("max", { plan: "claude_max_5x" }),
+    account("ultra", { plan: "claude_max_20x" }),
+    account("bare", { plan: "claude_max" }),
+  ];
+
+  test("plans read as the provider names them, on each row only when they differ", () => {
+    const content = subscriptionAccountMenuContent(
+      state({ accounts: claudeAccounts, current: null }),
+    );
+    expect(content.plan).toBeNull();
+    expect(content.accounts.map((row) => row.plan)).toEqual([
+      "Pro",
+      "Max",
+      "Ultra",
+      "Max or Ultra",
+    ]);
+    // Never the raw id.
+    expect(JSON.stringify(content)).not.toContain("claude_max");
+  });
+
+  test("the full email stays in the row, never shortened", () => {
+    const content = subscriptionAccountMenuContent(
+      state({ accounts: claudeAccounts, current: null }),
+    );
+    expect(content.accounts[0]).toMatchObject({
+      label: "Acme pro",
+      email: "sam.longername.lindqvist@example.test",
+    });
+  });
+
+  test("the chosen account is marked for the next turn and the serving one as in use", () => {
+    const content = subscriptionAccountMenuContent(
+      state({ automatic: false, chosenId: "b", serving: true }),
+    );
+    expect(content.accounts.map((row) => row.mark)).toEqual(["in_use", "next_turn", null]);
+    const automatic = subscriptionAccountMenuContent(state());
+    expect(automatic.automaticSelected).toBe(true);
+    expect(automatic.accounts.map((row) => row.mark)).toEqual(["in_use", null, null]);
+  });
+
+  test("ChatGPT and SuperGrok plans", () => {
+    const codex = subscriptionAccountMenuContent(
+      state({
+        provider: "codex",
+        accounts: [account("p", { plan: "plus" }), account("q", { plan: "team" })],
+        current: null,
+      }),
+    );
+    expect(codex.accounts.map((row) => row.plan)).toEqual(["Plus", "Business"]);
+    const grok = subscriptionAccountMenuContent(
+      state({
+        provider: "xai",
+        accounts: [account("g", { plan: "SuperGrok Heavy" })],
+        current: null,
+      }),
+    );
+    expect(grok.plan).toBe("SuperGrok Heavy");
   });
 });
 

package/src/app/components/session/subscription-account.ts

@@ -7,11 +7,17 @@ import type { ClientModel, ModelAccountChoiceRefusal } from "@opengeni/sdk";
 import { isClaudeSubscriptionModelId } from "@opengeni/contracts/claude-subscription-model-ids";
 import { connectedSubscriptionProvider } from "../../../model-policy";
 import { isCodexProductModel } from "../../lib/session-model";
+import {
+  subscriptionLimit,
+  subscriptionPlanLabel,
+  subscriptionWindows,
+  type SubscriptionLimit,
+  type SubscriptionWindow,
+} from "../../lib/subscription-accounts";
 import type { BillingClass } from "../billing-class-mark";
 import type {
   SubscriptionAccountMenuRow,
   SubscriptionAccountMenuUsage,
-  SubscriptionAccountUsageWindow,
 } from "./subscription-account-menu";
 
 export type SubscriptionAccountUsage = {
@@ -89,20 +95,6 @@ export function subscriptionProviderPresentation(provider: string): {
   return PROVIDER[provider] ?? { name: "Subscription", billingClass: "external" };
 }
 
-// Presentation labels only. Preserve every supplied window; never combine
-// family-specific, overage or partial windows into an account capacity score.
-const WINDOW_LABEL: Record<string, string> = {
-  // Neutral ids: they do not say how long the window is.
-  primary: "Primary",
-  secondary: "Secondary",
-  five_hour: "5h",
-  seven_day: "Week",
-  seven_day_opus: "Week · Opus",
-  seven_day_sonnet: "Week · Sonnet",
-  overage: "Overage",
-  billing: "Billing",
-};
-
 const REFUSAL_COPY: Record<ModelAccountChoiceRefusal, string> = {
   inactive: "Unavailable",
   personal_not_allowed: "Turned off here",
@@ -122,9 +114,11 @@ const STATUS_COPY: Record<string, string> = {
   limit_reached: "Limit reached",
 };
 
-function time(value: string | null): string | null {
-  if (!value || !Number.isFinite(Date.parse(value))) return null;
-  return new Date(value).toLocaleString(undefined, {
+function time(value: string | number | null): string | null {
+  if (value === null) return null;
+  const at = typeof value === "number" ? value : Date.parse(value);
+  if (!Number.isFinite(at)) return null;
+  return new Date(at).toLocaleString(undefined, {
     month: "short",
     day: "numeric",
     hour: "numeric",
@@ -132,8 +126,15 @@ function time(value: string | null): string | null {
   });
 }
 
-export function accountLabel(account: SubscriptionAccount): string {
-  return account.label ?? account.email ?? account.plan ?? "Account";
+/** The name an account goes by: its label, else its email, else its plan. */
+export function accountLabel(account: SubscriptionAccount, provider = ""): string {
+  return (
+    account.label ??
+    account.email ??
+    subscriptionPlanLabel(provider, account.plan) ??
+    account.plan ??
+    "Account"
+  );
 }
 
 export function accountStatus(account: SubscriptionAccount): string | null {
@@ -153,91 +154,46 @@ function accountSource(account: SubscriptionAccount): string | null {
         : null;
 }
 
-function windowLabel(id: string): string {
-  return WINDOW_LABEL[id] ?? id;
-}
+/** An account's usage as every surface shows it: its reported windows and its limit. */
+export type SubscriptionAccountUsageView = {
+  windows: SubscriptionWindow[];
+  limit: SubscriptionLimit;
+  /** Words instead of windows: no reading, or a limit with no window to show it. */
+  message: string | null;
+  /** "Updated 3 Nov, 15:29", when the reading says when it was taken. */
+  note: string | null;
+};
 
-/** The reading as usage rows: percentage used, with when each window resets. */
+/** The reading as the provider reported it: every window, labelled, never completed. */
 export function subscriptionAccountUsage(
+  provider: string,
   usage: SubscriptionAccountUsage | null | undefined,
   now = Date.now(),
-): {
-  windows?: SubscriptionAccountUsageWindow[];
-  message?: string;
-  note?: string;
-  summary?: string;
-} {
-  if (!usage) return { message: "No usage reading yet" };
-  const observed = time(usage.observedAt);
-  const windows = usage.windows.map((window) => {
-    const reset = time(window.resetsAt);
-    const past = reset !== null && Date.parse(window.resetsAt!) <= now;
-    return {
-      label: windowLabel(window.id),
-      usedPercent: window.usedPercent,
-      detail: [
-        window.status === "unknown"
-          ? "Status unknown"
-          : window.status === "warning"
-            ? "Near its limit"
-            : window.status === "exhausted"
-              ? "Limit reached"
-              : null,
-        past ? "Reset passed; usage may be outdated" : reset ? `Resets ${reset}` : null,
-      ]
-        .filter(Boolean)
-        .join(" · "),
-    };
-  });
-  const exhaustedTime = time(usage.exhaustedUntil);
-  // A limit whose end has passed no longer applies.
-  const exhausted =
-    usage.exhaustedKind !== null &&
-    !(usage.exhaustedUntil && Date.parse(usage.exhaustedUntil) <= now);
+): SubscriptionAccountUsageView {
+  const windows = subscriptionWindows(provider, usage?.windows ?? [], now);
+  const limit = subscriptionLimit(windows, usage?.exhaustedUntil ?? null, now);
+  const until = time(limit.until);
+  const observed = time(usage?.observedAt ?? null);
   return {
     windows,
-    ...(windows.length === 0
-      ? {
-          message: exhausted
-            ? `Limit reached${exhaustedTime ? ` until ${exhaustedTime}` : ""}`
-            : "No usage reading yet",
-        }
-      : {}),
-    ...(observed ? { note: `Updated ${observed}` } : {}),
-    ...(windows.length > 0
-      ? {
-          summary: `${windows
-            .map(
-              (window) =>
-                `${window.label} ${window.usedPercent === null ? "unknown" : `${Math.round(window.usedPercent)}%`}`,
-            )
-            .join(" · ")} used`,
-        }
-      : {}),
+    limit,
+    // A limit that no account-wide window shows (a refusal) still says until
+    // when; a full model-scoped week (Fable) doesn't show the account's limit.
+    message:
+      limit.reached && !windows.some((window) => window.limitReached && !window.scoped)
+        ? `Limit reached${until ? ` until ${until}` : ""}`
+        : windows.length === 0
+          ? "No usage reading yet"
+          : null,
+    note: observed ? `Updated ${observed}` : null,
   };
 }
 
-function nearLimit(usage: SubscriptionAccountUsage | null | undefined): boolean {
-  return (usage?.windows ?? []).some(
-    (window) =>
-      window.status === "warning" ||
-      window.status === "exhausted" ||
-      (window.usedPercent !== null && window.usedPercent >= 90),
-  );
-}
-
-/** The most-used window with a known reading: the one that runs out first. */
-function tightestWindow(
-  windows: SubscriptionAccountUsageWindow[] | undefined,
-): { label: string; usedPercent: number } | undefined {
-  let tightest: { label: string; usedPercent: number } | undefined;
-  for (const window of windows ?? []) {
-    if (window.usedPercent === null || !Number.isFinite(window.usedPercent)) continue;
-    if (!tightest || window.usedPercent > tightest.usedPercent) {
-      tightest = { label: window.label, usedPercent: window.usedPercent };
-    }
-  }
-  return tightest;
+/** One plan label when every listed account has the same plan, else null. */
+function sharedPlan(provider: string, accounts: readonly SubscriptionAccount[]): string | null {
+  const plans = new Set(accounts.map((account) => subscriptionPlanLabel(provider, account.plan)));
+  const [only] = plans;
+  return plans.size === 1 && only ? only : null;
 }
 
 /**
@@ -273,13 +229,17 @@ export function subscriptionAccountProvider(
 }
 
 /** Everything the account menu shows, from the neutral state. */
-export function subscriptionAccountMenuContent(state: SubscriptionAccountState) {
+export function subscriptionAccountMenuContent(
+  state: SubscriptionAccountState,
+  now: number = Date.now(),
+) {
   const { name } = subscriptionProviderPresentation(state.provider);
+  const provider = state.provider;
   const current = state.current;
   // A failed read does not know the selection; never claim Automatic for it.
   const unknown = state.unavailable && !current && !state.currentHidden;
   const displayName = current
-    ? accountLabel(current)
+    ? accountLabel(current, provider)
     : state.currentHidden
       ? "Account unavailable"
       : unknown
@@ -295,11 +255,12 @@ export function subscriptionAccountMenuContent(state: SubscriptionAccountState)
         : current
           ? "Current account"
           : "Account selection";
-  const usageNearLimit = nearLimit(current?.usage);
+  const currentUsage = current ? subscriptionAccountUsage(provider, current.usage, now) : null;
+  const limitTone = currentUsage?.limit.reached || currentUsage?.limit.near;
   const tone: "ok" | "warn" | "bad" =
     current?.status === "needs_relogin" || current?.status === "error"
       ? "bad"
-      : status || state.waiting || usageNearLimit
+      : status || state.waiting || limitTone
         ? "warn"
         : "ok";
   const usage: SubscriptionAccountMenuUsage = !current
@@ -314,38 +275,64 @@ export function subscriptionAccountMenuContent(state: SubscriptionAccountState)
       ? { checking: true }
       : state.usageCheck === "failed"
         ? { unavailable: true }
-        : subscriptionAccountUsage(current.usage);
+        : {
+            windows: currentUsage!.windows,
+            ...(currentUsage!.message ? { message: currentUsage!.message } : {}),
+            ...(currentUsage!.note ? { note: currentUsage!.note } : {}),
+          };
+  // The plan is shown once: beside the list when every account has the same
+  // plan, else on each row (by its own name, the provider being clear here).
+  const plan = sharedPlan(provider, state.accounts);
+  const selectedId = state.automatic || unknown ? null : state.chosenId;
   const accounts: SubscriptionAccountMenuRow[] = state.accounts.map((account) => {
-    // The current account's usage is already shown above the list.
+    const label = accountLabel(account, provider);
+    const rowStatus = accountStatus(account);
+    // The current account's usage is shown above the list; a live check
+    // hides every reading until it answers.
     const rowUsage =
       account.id === current?.id || state.usageCheck === "checking"
-        ? undefined
-        : subscriptionAccountUsage(account.usage);
+        ? null
+        : subscriptionAccountUsage(provider, account.usage, now);
     return {
       id: account.id,
-      label: accountLabel(account),
-      plan: account.plan,
-      status: accountStatus(account),
+      label,
+      email: account.email && account.email !== label ? account.email : null,
+      plan: plan ? null : subscriptionPlanLabel(provider, account.plan, { brand: false }),
+      status: rowStatus,
+      mark:
+        account.id === selectedId
+          ? "next_turn"
+          : account.id === current?.id && !state.currentHidden
+            ? "in_use"
+            : null,
+      windows: rowUsage?.windows ?? null,
+      // A row without a reading stays quiet; only a limit no window shows gets words.
+      usageMessage: rowUsage?.limit.reached ? rowUsage.message : null,
       detail: [
-        accountLabel(account),
+        label,
         account.email,
-        account.plan,
+        subscriptionPlanLabel(provider, account.plan),
         accountSource(account),
-        accountStatus(account),
+        rowStatus,
       ]
-        .filter(Boolean)
+        .filter((part, index, parts) => part && parts.indexOf(part) === index)
         .join(" · "),
       personal: account.source === "personal",
       disabled: !account.choosable,
-      usageSummary: rowUsage?.summary,
-      usageBar: rowUsage?.summary ? tightestWindow(rowUsage.windows) : undefined,
     };
   });
   return {
     ariaLabel: [
       `${name} account`,
       displayName,
-      state.waiting ? "Limit reached" : (status ?? (usageNearLimit ? "Near its limit" : null)),
+      state.waiting
+        ? "Limit reached"
+        : (status ??
+          (currentUsage?.limit.reached
+            ? "Limit reached"
+            : currentUsage?.limit.near
+              ? "Near its limit"
+              : null)),
     ]
       .filter(Boolean)
       .join(" · "),
@@ -353,13 +340,15 @@ export function subscriptionAccountMenuContent(state: SubscriptionAccountState)
     displayName,
     identity: current?.email && current.email !== displayName ? current.email : null,
     metadata: current
-      ? [current.plan, accountSource(current), status].filter(Boolean).join(" · ") ||
-        `${name} subscription`
+      ? [subscriptionPlanLabel(provider, current.plan), accountSource(current), status]
+          .filter(Boolean)
+          .join(" · ") || `${name} subscription`
       : `${name} subscription`,
     tone,
     usage,
     accounts,
-    selectedId: state.automatic || unknown ? null : state.chosenId,
+    plan,
+    selectedId,
     automaticSelected: state.automatic && !unknown,
     actionLabel: state.waiting ? "Retry with" : "Use for next turn",
     automaticLabel: "Automatic",