@modelprofile.com/authswitch 3.1.0 → 3.3.0

package/dist_ts/classes.tui.js

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import { accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usageWindowName, until, readAccountRows } from './accounts.js';
+import { accountBadge, accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usageWindowName, until, readAccountRows } from './accounts.js';
 import { plainText } from './formatting.js';
 import { AuthSwitchOperations } from './classes.operations.js';
 import { describeHarnessProcesses, describeStopOutcome } from './classes.harnessprocesses.js';
@@ -176,13 +176,16 @@ export class AuthSwitchTui {
                     return;
                 }
             }
-            if (!await screen.confirm(`Switch ${plainText(harness.label)} to ${plainText(target.label)}?`, { confirmLabel: 'Switch' }))
+            // The dashboard already holds this account's status, so the badge costs no further lookup.
+            const badge = accountBadge(rows.find(row => row.account.id === target.id)?.status);
+            if (!await screen.confirm(`Switch ${plainText(harness.label)} to ${plainText(target.label)}${badge}?`, { confirmLabel: 'Switch' }))
                 return;
             if (screen.signal.aborted)
                 return;
             const outcome = await this.operations.run(harness, { harnessId: harness.id, action: 'switch', accountId: target.id }, message => screen.confirm(message), settleInstances(screen));
             await refresh(screen);
-            showOutcome(outcome);
+            if (showOutcome(outcome))
+                ui.logs.append(`Now active: ${plainText(target.label)}${badge}`);
         };
         const remove = async (screen) => {
             const selected = table.selected;
@@ -238,4 +241,4 @@ export class AuthSwitchTui {
         return 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}

package/dist_ts/interfaces.harness.d.ts

@@ -127,12 +127,19 @@ export interface IHarnessUsageWindow {
     /** Set when the provider picks this window as the one a single-value summary shows. */
     headline?: true;
 }
+/**
+ * The provider's own name for an account's plan, and where that name comes from.
+ *
+ * `live` was read from the provider in this lookup; `stored` is the last name the saved login
+ * carries, which is the only answer available while a provider cannot be reached.
+ */
+export interface IAccountType {
+    plan: string;
+    source: 'live' | 'stored';
+}
 export interface IHarnessStatusSummary {
     /** A plan name does not imply an active billing status. */
-    subscription?: {
-        plan: string;
-        source: 'live' | 'stored';
-    };
+    subscription?: IAccountType;
     /** Live billing information only. Never infer these fields from a plan or entitlement expiry. */
     billing?: {
         hasActiveSubscription?: boolean;
@@ -157,6 +164,11 @@ export interface IHarnessOutcome {
     lines: string[];
     problems: string[];
 }
+/** A read-only status lookup. */
+export interface IHarnessStatusOptions {
+    /** Cancels the lookup's requests; an adapter still bounds each request with its own timeout. */
+    signal?: AbortSignal;
+}
 /** A single text-only inference request. Credentials remain inside the adapter. */
 export interface IHarnessPreuseOptions {
     prompt: string;
@@ -179,7 +191,7 @@ export interface IAuthHarness {
     readState(): THarnessResult<IHarnessState>;
     /** Running instances of this harness, when the adapter owns their lifecycle. */
     readonly processes?: IHarnessProcessControl;
-    readAccountStatus(accountIdArg: string): Promise<IHarnessAccountStatus>;
+    readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
     readonly loginProviders?: IHarnessLoginProvider[];
     beginLogin?(options: IHarnessLoginOptions): Promise<IHarnessLoginHandle>;
     /** Optional quota-consuming capability; never changes the active login. */

package/dist_ts/interfaces.list.d.ts

@@ -1,4 +1,4 @@
-import type { IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
+import type { IAccountType, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 /** Credential-free, versioned output of list --json. Missing status fields stay omitted. */
 export interface IAccountList {
     schemaVersion: 2;
@@ -37,6 +37,8 @@ export interface IAccountLimitRow {
     accountId: string | null;
     slotId?: string;
     isActive: boolean;
+    /** The adapter's plan name (`max`, `pro`), sanitised but not display-formatted; null when none is known or the row names no account. */
+    accountType: IAccountType | null;
     /** The provider's own window name, or null when no limit data is available. */
     limitType: string | null;
     scope: 'account' | 'feature' | null;
@@ -66,6 +68,8 @@ export interface IActiveAccountRow {
     account: string | null;
     accountId: string | null;
     slotId?: string;
+    /** The adapter's plan name (`max`, `pro`), sanitised but not display-formatted; null when none is known or the row names no account. */
+    accountType: IAccountType | null;
     /** When authswitch last saved this login; null when it was never stashed. */
     savedAt: string | null;
     /** Human elapsed time for the same `savedAt`, relative to `generatedAt`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -31,7 +31,7 @@
   "dependencies": {
     "@modelprofile.com/flexharness-models": "^7.0.1",
     "@modelprofile.com/flexharness-providers": "^7.0.1",
-    "@push.rocks/smartconsole": "^1.1.0"
+    "@push.rocks/smartconsole": "^1.3.0"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -307,6 +307,34 @@ authswitch codex use
 
 The account argument also accepts the directory slug, the local part, or a unique prefix, so `authswitch codex use alice` resolves to `alice@example.com` when that is unambiguous. It is deliberately not a substring match — this argument decides which credential becomes active, and an incidental substring hit should never pick an account you did not name.
 
+So you know what you switch to, every harness's switch names the account with a
+badge of its type and its current usage:
+
+```
+? Which Claude Code account should be active?
+❯ phil@example.com (active) (type:Max) (5h:12%) (w:75%)
+  alice@example.com (type:Pro, unverified) (w:40%)
+...
+Now active: alice@example.com (type:Pro, unverified) (w:40%)
+```
+
+The badge appears in the account picker of `use`, in the dashboard's switch
+confirmation and on the `Now active:` line that reports a completed switch (in the
+dashboard, its activity log). `type` is the account type as `limits` shows it; `5h`
+and `w` are the account's five-hour and weekly usage windows, rounded to whole
+percent. Feature limits never appear in it, and when several account windows share a
+period without the provider picking one of them, that part is left out rather than
+guessed.
+
+Usage is read live, read-only and once per command. The picker looks up the offered
+accounts, at most four at a time, before it asks; a switch named on the command line
+switches first and then looks up only its target for the `Now active:` line. Whatever
+has not answered after 2.5 seconds is left out and its requests are cancelled, so the
+command still exits at once. Every part the provider did not report is omitted, and
+with none known the account is named alone. Reading usage never delays the switch
+beyond that deadline and never fails it. The dashboard reuses the status it already
+shows and makes no extra lookup.
+
 ## What a switch actually does
 
 `use` runs as one sequence, and steps 1 to 4 stop at the first failure:
@@ -363,34 +391,54 @@ no invented 5-hour limit.
 Email addresses identify Codex accounts throughout the overview, usage/reset
 schedules, earned reset expiry details, grouped credits and activity metrics,
 saved-login notes and availability/actions tables. Other harnesses use their
-account labels. Provider facts already represented by structured fields are not
-repeated. Narrow terminals use compact account sections. Missing
-data stays Unavailable or Not reported; known zeroes remain zero. Stored plans are
-marked unverified. Renewal/cancellation dates are shown only when an adapter can
+account labels. When accounts of one harness share a label, every table numbers
+the later ones (`alice@example.com (2)`), so each account keeps its own column in
+the metric comparisons and reads the same everywhere. Provider facts already
+represented by structured fields are not repeated. Narrow terminals use compact
+account sections. Missing
+data stays Unavailable or Not reported; known zeroes remain zero. Plans read as in
+`limits` and the switch badge (`Max`), and stored plans are marked unverified
+(`Plus, unverified`). Renewal/cancellation dates are shown only when an adapter can
 provide live billing data. Codex uses the desktop app's account-check endpoint for
 automatic renewal, explicit renewal/cancellation dates and subscription expiry.
 
+Tables that list an account on several rows (the usage/reset schedule,
+feature-specific limits, earned reset details, and availability/actions) draw a
+divider between one account and the next. The divider follows the account id, not
+the email, so two accounts that share an address stay separate blocks, and the
+harness-level availability row is a block of its own. The overview and the metric
+comparisons show each account once and have no dividers. Each `list` section covers
+one harness, so no colour line is drawn. Narrow terminals separate the same blocks
+with a rule line.
+
 ### Condensed views
 
 `authswitch limits` answers "how much is left, and when does it come back" in one
 table. It is one row per account **and** limit type, sorted by provider and then by
-account email, with a two-unit countdown (`2h 13m`, `3d 4h`, `45m`, `<1m`, `due`):
+account email with each harness and each account kept together, and a two-unit countdown (`2h 13m`, `3d 4h`, `45m`, `<1m`, `due`):
 
 ```
 Account limits
 ┌──────────────────────┬─────────────────────────┬───────────────────────┬────────┬───────────────┐
 │ Provider             │ Account                 │ Limit type            │ Used % │     Resets in │
 ├──────────────────────┼─────────────────────────┼───────────────────────┼────────┼───────────────┤
-│ Claude Code          │ phil@example.com        │ Claude weekly         │    75% │         4d 3h │
-│ Claude Code          │ phil@example.com        │ Claude five-hour      │    12% │         1h 2m │
-│ Claude Code          │ phil@example.com        │ Fable weekly          │    88% │         2d 5h │
-│ Codex                │ alice@example.com       │ Codex secondary       │    12% │         3d 4h │
-│ Codex                │ alice@example.com       │ Codex primary         │    37% │        2h 13m │
-│ Codex                │ alice@example.com       │ Code review secondary │   100% │        3h 59m │
-│ Codex                │ bob@example.com         │ n/a                   │    n/a │           n/a │
-│ OpenCode / anthropic │ anthropic API key 20e75 │ n/a                   │    n/a │           n/a │
-│                      │ 1c3b707                 │                       │        │               │
-│ OpenCode / openai    │ alice@example.com       │ Codex primary         │     0% │ not scheduled │
+┃ Claude Code          │ phil@example.com        │ Claude weekly         │    75% │         4d 3h │
+┃                      │ Max                     │ Claude five-hour      │    12% │         1h 2m │
+┃                      │                         │ Fable weekly          │    88% │         2d 5h │
+├──────────────────────┼─────────────────────────┼───────────────────────┼────────┼───────────────┤
+┃ Codex                │ alice@example.com       │ Codex secondary       │    12% │         3d 4h │
+┃                      │ Pro                     │ Codex primary         │    37% │        2h 13m │
+┃                      │                         │ Code review secondary │   100% │        3h 59m │
+┃                      ├─────────────────────────┼───────────────────────┼────────┼───────────────┤
+┃                      │ bob@example.com         │ n/a                   │    n/a │           n/a │
+┃                      │ Plus, unverified        │                       │        │               │
+├──────────────────────┼─────────────────────────┼───────────────────────┼────────┼───────────────┤
+┃ OpenCode / anthropic │ anthropic API key 20e75 │ n/a                   │    n/a │           n/a │
+┃                      │ 1c3b707                 │                       │        │               │
+┃                      │ n/a                     │                       │        │               │
+├──────────────────────┼─────────────────────────┼───────────────────────┼────────┼───────────────┤
+┃ OpenCode / openai    │ alice@example.com       │ Codex primary         │     0% │ not scheduled │
+┃                      │ Pro                     │                       │        │               │
 └──────────────────────┴─────────────────────────┴───────────────────────┴────────┴───────────────┘
 
 n/a — Codex · bob@example.com: Subscription and limits: Login expired or was rejected.
@@ -411,12 +459,35 @@ session and the weekly total keeps its kind in parentheses
 (`Claude weekly (weekly_oauth)`). The provider column names the harness, qualified by
 the credential slot when a harness owns several (`OpenCode / openai`).
 
+Each provider and each account is named once. The **Provider** cell spans all rows of
+its provider, and the **Account** cell spans the rows of its account with two lines:
+the account label, and beneath it, dimmed, the **account type** — the provider's own
+plan name with its first letter capitalised (`Max`, `Pro`, `Prolite`). A type read
+from the stored login because the live lookup failed is marked `unverified` (`Plus, unverified`), and
+an account whose provider reports no plan, such as an API-key login, shows `n/a`. A
+provider row without an account has no type line.
+
 **Used %** is coloured by the provider's own reading when it reports one: orange for
 `warning`, red for `critical`, uncoloured for `normal`. Without a reading, `n/a` is
 orange and an exhausted window (100% or more) is red. Colour is omitted when
 `NO_COLOR` is set, output is not a terminal, or the terminal is narrower than 40
 columns.
 
+Rows are grouped in two independent ways. A divider separates one account from the
+next, so an account's limit types read as one block; a provider row without an
+account is a block of its own. Inside a provider's span the divider starts at the
+**Account** column, and a change of provider draws a full rule. A line along the left edge (`┃`) marks the harness:
+all its rows share one colour, including every credential slot of an OpenCode
+installation, and the next harness takes the next colour (cyan, orange, green, pink,
+blue, then again from the start). Without colour the `┃` edge still shows where the
+data rows are. Groups follow harness and account ids, never labels: two accounts
+that share an email are separate blocks, ordered by account id, and two harnesses
+that share a label are ordered by harness id. A harness is placed by its first
+provider name, so no other provider sorts between its slots. Below 40 columns the
+table becomes labelled lines; every row repeats its provider and its account with
+the type as a second line, a rule line separates the accounts, and no colour line is
+drawn.
+
 `authswitch active` answers "what am I logged in as" for every harness at once:
 
 ```
@@ -424,11 +495,11 @@ Active accounts
 ┌──────────────────────┬────────────────────────────────┬────────────┬─────────────────┐
 │ Provider             │ Account                        │      Saved │ Source          │
 ├──────────────────────┼────────────────────────────────┼────────────┼─────────────────┤
-│ Claude Code          │ phil@example.com               │    45m ago │ credential file │
-│ Codex                │ alice@example.com              │ 2h 13m ago │ credential file │
-│ Flex                 │ none                           │        n/a │ none            │
-│ OpenCode / anthropic │ anthropic API key 20e751c3b707 │    30d ago │ credential file │
-│ OpenCode / openai    │ alice@example.com              │  not saved │ credential file │
+┃ Claude Code          │ phil@example.com               │    45m ago │ credential file │
+┃ Codex                │ alice@example.com              │ 2h 13m ago │ credential file │
+┃ Flex                 │ none                           │        n/a │ none            │
+┃ OpenCode / anthropic │ anthropic API key 20e751c3b707 │    30d ago │ credential file │
+┃ OpenCode / openai    │ alice@example.com              │  not saved │ credential file │
 └──────────────────────┴────────────────────────────────┴────────────┴─────────────────┘
 
 note — OpenCode / openai · alice@example.com: This active login is not saved yet; authswitch cannot restore it after a switch.
@@ -439,6 +510,8 @@ own live credential, `stash only` means nothing is active and only saved copies
 exist, `none` means neither. **Saved** is how long ago `authswitch` last saved that
 login, or `not saved` — which is also the warning that a switch could not bring it
 back. A harness with no active login keeps its row and explains itself in a note.
+Each harness has its own colour line, ordered and coloured as in `limits`; the
+table has no dividers, since every row is a different credential slot.
 
 **Source** also answers whether the file still holds what the last switch wrote.
 When authswitch switches a login it records that account and the hash of the
@@ -471,7 +544,10 @@ arguments to these commands exit with 2.
 
 `limits --json` emits `IAccountLimits` and `active --json` emits `IActiveAccounts`:
 the same rows as the tables, plus the machine-readable fields the tables condense —
-`accountId`, `slotId`, `scope`, `windowSeconds`, the ISO `resetAt` beside the human
+`accountId`, `slotId`, `accountType` (`{ plan, source }` with the adapter's plan
+name, such as `max` or `pro`, sanitised but not display-formatted, and `source` `live`
+or `stored`; null when no type is known or the row names no account; both documents
+carry it), `scope`, `windowSeconds`, the ISO `resetAt` beside the human
 `resetsIn`, the provider's `severity` (`normal`, `warning`, `critical`, or null when
 it gave none) and `headline` (true for the window the provider picks for a
 single-value summary), the ISO `savedAt` beside the human `savedAgo`, the per-row
@@ -564,7 +640,11 @@ process.exitCode = await cli.run(process.argv.slice(2));
 
 Each adapter owns discovery, identity matching, save verification, credential
 storage, switching and process lifecycle, live status APIs, and diagnostics.
-`readState()` and `readAccountStatus()` must be read-only. `switchAccount()` must
+`readState()` and `readAccountStatus()` must be read-only. `readAccountStatus(accountId,
+options)` receives an optional `IHarnessStatusOptions` whose `signal` cancels the
+lookup's requests; authswitch aborts it when a status is no longer wanted, such as a
+switch badge past its deadline or a closed dashboard, so an adapter should pass it to
+every request it makes. `switchAccount()` must
 preserve and verify the outgoing credential without relying on the interactive
 save prompt. `removeAccount()` removes only the saved copy. Status facts carry
 provider-specific labels and units; unsupported capabilities are explicit. Adapter

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '3.1.0',
+  version: '3.3.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/accounts.ts

@@ -1,4 +1,4 @@
-import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessUsageWindow } from './interfaces.harness.js';
+import type { IAccountType, IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessUsageWindow } from './interfaces.harness.js';
 import { plainText } from './formatting.js';
 
 export interface IAccountRow {
@@ -68,10 +68,24 @@ export const credentialDriftNote = (harnessIdArg: string, driftArg: IHarnessCred
   + (driftArg.expectedLabel === null ? 'Switch to the intended account again.'
     : `Run authswitch ${plainText(harnessIdArg)} use ${plainText(driftArg.expectedLabel)} again.`);
 
-export const accountPlan = (rowArg: IAccountRow): string => {
-  const subscription = rowArg.status?.summary?.subscription;
-  return subscription ? `${plainText(subscription.plan)}${subscription.source === 'stored' ? ' (stored; unverified)' : ' (live)'}` : rowArg.status ? 'Unavailable' : 'Loading';
+/**
+ * How every view marks a plan that comes from the saved login because the provider did not confirm it: the
+ * word both earlier plan cells used, kept short so the type line of a limits cell does not wrap.
+ */
+const STORED_PLAN_MARK = 'unverified';
+/**
+ * How an account type reads in every view: the provider's plan name with its first letter capitalised
+ * (`max` reads `Max`), and a plan taken from the stored login marked `Plus, unverified`. The text holds no
+ * parentheses, so it reads the same inside a badge part. Nothing is invented: an unknown type is null, and
+ * each view decides how to show that.
+ */
+export const accountTypeText = (typeArg: IAccountType | null | undefined): string | null => {
+  if (!typeArg) return null;
+  const plan = plainText(typeArg.plan);
+  return `${plan.charAt(0).toUpperCase()}${plan.slice(1)}${typeArg.source === 'stored' ? `, ${STORED_PLAN_MARK}` : ''}`;
 };
+export const accountPlan = (rowArg: IAccountRow): string =>
+  accountTypeText(rowArg.status?.summary?.subscription) ?? (rowArg.status ? 'Unavailable' : 'Loading');
 type TAccountStatusRow = Pick<IAccountRow, 'status'>;
 /**
  * How a single-value summary names a window among the windows it shows. An account window is named by
@@ -113,6 +127,88 @@ export const accountQuotaSummary = (rowArg: TAccountStatusRow, nowArg: number):
     ...windows.slice(1).filter(window => window.usedPercent >= 100).map(window => `${usageWindowName(window, windows)} exhausted\nResets in: ${until(window.resetAt, nowArg)}`),
   ] : [])].join('\n');
 };
+/** The badge's usage meters: the general account windows a switch decision weighs, never a feature quota. */
+const BADGE_WINDOWS = [['5h', 18000], ['w', 604800]] as const;
+/**
+ * The account window a badge part reads: the only account window of that period, or the provider's headline
+ * pick among several. Any other choice would be a guess, so the part is left out and no meter reads as another's.
+ */
+const badgeWindow = (windowsArg: readonly IHarnessUsageWindow[], secondsArg: number): IHarnessUsageWindow | undefined => {
+  const matches = windowsArg.filter(window => window.scope !== 'feature' && window.durationSeconds === secondsArg);
+  const candidates = matches.length > 1 ? matches.filter(window => window.headline === true) : matches;
+  return candidates.length === 1 ? candidates[0] : undefined;
+};
+/**
+ * What a switch activates, in one line: ` (type:Max) (5h:63%) (w:88%)`, appended to the account label.
+ *
+ * Each part is the provider's own reading, rounded to a whole percent, and is omitted when it was not
+ * reported; with no part known the badge is empty, so a missing reading never reads as zero usage.
+ */
+export const accountBadge = (statusArg: IHarnessAccountStatus | undefined): string => {
+  const type = accountTypeText(statusArg?.summary?.subscription);
+  const windows = statusArg?.summary?.usageWindows ?? [];
+  return [
+    ...(type === null ? [] : [`type:${type}`]),
+    ...BADGE_WINDOWS.flatMap(([name, seconds]) => {
+      const window = badgeWindow(windows, seconds);
+      return window === undefined ? [] : [`${name}:${Math.round(window.usedPercent)}%`];
+    }),
+  ].map(part => ` (${part})`).join('');
+};
+/** How many accounts' statuses are read at once, so a long account list never floods a provider. */
+const STATUS_LOOKUP_CONCURRENCY = 4;
+/**
+ * Read-only, bounded status lookups: at most four accounts at a time, started in order, each handed the
+ * caller's signal. A lookup that fails reports undefined; once the signal aborts, no further lookup starts.
+ * A callback that throws rejects the call, and no other lookup starts after it.
+ */
+const lookupStatuses = async (
+  harnessArg: IAuthHarness,
+  accountIdsArg: readonly string[],
+  optionsArg: { signal?: AbortSignal; onStatus: (indexArg: number, statusArg: IHarnessAccountStatus | undefined) => void | Promise<void> },
+): Promise<void> => {
+  let next = 0;
+  let failed = false;
+  const worker = async (): Promise<void> => {
+    while (!failed && next < accountIdsArg.length && !optionsArg.signal?.aborted) {
+      const index = next++;
+      let status: IHarnessAccountStatus | undefined;
+      try { status = await harnessArg.readAccountStatus(accountIdsArg[index], { signal: optionsArg.signal }); }
+      catch { status = undefined; }
+      try { await optionsArg.onStatus(index, status); }
+      catch (error) { failed = true; throw error; }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(STATUS_LOOKUP_CONCURRENCY, accountIdsArg.length) }, worker));
+};
+/** How long a switch waits for the badges of the accounts it offers or activates. */
+const ACCOUNT_BADGE_TIMEOUT_MS = 2500;
+/**
+ * The badge of every named account whose status answered before one shared deadline.
+ *
+ * Read-only and never fatal: a switch must not wait on a provider past this deadline, nor fail because
+ * usage could not be read, so a lookup that fails or misses the deadline contributes no badge and the
+ * caller shows the label alone. At the deadline every lookup still running is cancelled, so no request
+ * outlives the call and keeps the command from exiting.
+ */
+export const readAccountBadges = async (
+  harnessArg: IAuthHarness,
+  accountIdsArg: readonly string[],
+  timeoutMsArg = ACCOUNT_BADGE_TIMEOUT_MS,
+): Promise<Map<string, string>> => {
+  const badges = new Map<string, string>();
+  if (!accountIdsArg.length) return badges;
+  const cancel = new AbortController();
+  const lookups = lookupStatuses(harnessArg, accountIdsArg, { signal: cancel.signal, onStatus: (index, status) => {
+    if (status !== undefined && !cancel.signal.aborted) badges.set(accountIdsArg[index], accountBadge(status));
+  } });
+  // A referenced timer: the command must stay alive until the deadline even when a stalled lookup holds nothing open.
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const deadline = new Promise<void>(resolve => { timer = setTimeout(resolve, timeoutMsArg); });
+  try { await Promise.race([lookups, deadline]); }
+  finally { clearTimeout(timer); cancel.abort(); }
+  return badges;
+};
 export const accountState = (rowArg: IAccountRow): string => `${rowArg.account.isActive ? '* active, ' : ''}${rowArg.account.isStashed ? 'saved' : 'not saved'}`;
 export const accountDetails = (rowArg: IAccountRow): string => [
   plainText(rowArg.account.label), accountState(rowArg),
@@ -122,7 +218,7 @@ export const accountDetails = (rowArg: IAccountRow): string => [
   ...(rowArg.status?.problems.map(problemArg => `Unavailable: ${plainText(problemArg)}`) ?? []),
 ].join('\n');
 
-/** Read-only, bounded parallel status lookup. No account is switched to inspect it. */
+/** Read-only, bounded parallel status lookup. No account is switched to inspect it; the signal cancels lookups in flight. */
 export const readAccountRows = async (
   harnessArg: IAuthHarness,
   optionsArg: { signal?: AbortSignal; onUpdate?: (rowsArg: IAccountRow[], stateArg: IHarnessState) => void | Promise<void> } = {},
@@ -130,12 +226,9 @@ export const readAccountRows = async (
   const state = await harnessArg.readState();
   const rows = state.accounts.map(account => ({ harness: harnessArg, account } as IAccountRow));
   await optionsArg.onUpdate?.(rows, state);
-  for (let index = 0; index < rows.length && !optionsArg.signal?.aborted; index += 4) {
-    await Promise.all(rows.slice(index, index + 4).map(async row => {
-      try { row.status = await harnessArg.readAccountStatus(row.account.id); }
-      catch { row.status = { facts: [], problems: ['Could not read account status.'] }; }
-      if (!optionsArg.signal?.aborted) await optionsArg.onUpdate?.(rows, state);
-    }));
-  }
+  await lookupStatuses(harnessArg, rows.map(row => row.account.id), { signal: optionsArg.signal, onStatus: async (index, status) => {
+    rows[index].status = status ?? { facts: [], problems: ['Could not read account status.'] };
+    if (!optionsArg.signal?.aborted) await optionsArg.onUpdate?.(rows, state);
+  } });
   return { rows, state };
 };