@modelprofile.com/authswitch 3.2.0 → 3.3.0

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.2.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.2.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:
@@ -368,8 +396,9 @@ the later ones (`alice@example.com (2)`), so each account keeps its own column i
 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. Stored plans are
-marked unverified. Renewal/cancellation dates are shown only when an adapter can
+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.
 
@@ -394,19 +423,22 @@ 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 │
+┃                      │ Max                     │ Claude five-hour      │    12% │         1h 2m │
+┃                      │                         │ 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 │
+┃                      │ 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.
@@ -427,6 +459,14 @@ 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
@@ -435,7 +475,8 @@ 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. A line along the left edge (`┃`) marks the harness:
+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
@@ -443,8 +484,9 @@ 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; a rule line separates the accounts there, and no
-colour line is drawn.
+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:
 
@@ -502,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
@@ -595,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.2.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 };
 };

package/ts/classes.accountlist.ts

@@ -1,5 +1,5 @@
 import * as plugins from './plugins.js';
-import { accountQuotaSummary, orderedUsageWindows, readAccountRows, duration, until } from './accounts.js';
+import { accountQuotaSummary, accountTypeText, orderedUsageWindows, readAccountRows, duration, until } from './accounts.js';
 import type { IAuthHarness, IHarnessAccountStatus, IHarnessStatusFact } from './interfaces.harness.js';
 import type { IAccountList, IHarnessAccountList } from './interfaces.list.js';
 import { bold, dim, orange, plainText } from './formatting.js';
@@ -60,7 +60,8 @@ export const consoleHeading = (textArg: string): void => { process.stdout.write(
  * `groupsArg` is smartconsole's optional visual grouping: a divider between runs of consecutive rows with
  * different keys, and a colour line along the left edge per run. Keys are identities, never display labels,
  * and the caller orders the rows so that every group is one run. Below 40 columns the fallback separates
- * divider runs with one dim rule line; it has no left edge, so it draws no colour line.
+ * divider runs with one dim rule line; it has no left edge, so it draws no colour line, and it repeats a
+ * spanning cell on every row it covers. A column's `render` content is what both layouts show.
  */
 export const consoleTable = async <TRow>(
   outArg: plugins.smartconsole.SmartConsole,
@@ -74,9 +75,11 @@ export const consoleTable = async <TRow>(
     // smartconsole's run semantics: null and undefined are the same key.
     const dividerKeys = rowsArg.map(row => groupsArg?.divider?.(row) ?? null);
     const rule = `  ${dim('─'.repeat(Math.max(1, width - 4)))}\n\n`;
+    const content = (column: plugins.smartconsole.IBackendTableColumn<TRow>, row: TRow): string => column.render
+      ? plugins.smartconsole.color.plain(column.render(row)) : String(column.value(row) ?? 'Unavailable');
     rowsArg.forEach((row, index) => {
       if (index > 0 && dividerKeys[index] !== dividerKeys[index - 1]) process.stdout.write(rule);
-      process.stdout.write(columnsArg.map(column => `  ${column.title}: ${String(column.value(row) ?? 'Unavailable').replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
+      process.stdout.write(columnsArg.map(column => `  ${column.title}: ${content(column, row).replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
     });
     return;
   }
@@ -179,7 +182,7 @@ export class AccountListRenderer {
   private async overview(accountsArg: TNamedAccount[], nowArg: number): Promise<void> {
     const rows = accountsArg;
     const state = (account: TListedAccount) => `${account.isActive ? '* active\n' : ''}${account.isStashed ? 'saved' : 'not saved'}${account.status.problems.length ? '\n! partial status' : ''}`;
-    const plan = (account: TListedAccount) => account.status.summary?.subscription ? `${plainText(account.status.summary.subscription.plan)} (${account.status.summary.subscription.source})${account.status.summary.subscription.source === 'stored' ? '\nunverified' : ''}` : 'Unavailable';
+    const plan = (account: TListedAccount) => accountTypeText(account.status.summary?.subscription) ?? 'Unavailable';
     const billing = (account: TListedAccount) => {
       const info = account.status.summary?.billing;
       if (!info) return 'Unavailable';

package/ts/classes.claudecodeharness.ts

@@ -4,7 +4,7 @@ import { CredentialStore, credentialRecord, credentialText, readCredentialDocume
 import { HarnessProcesses } from './classes.harnessprocesses.js';
 import { ClaudeAccountStatus } from './classes.claudestatus.js';
 import { writeSecretFileAtomically } from './helpers.js';
-import type { IHarnessAccountStatus, IHarnessProcessControl } from './interfaces.harness.js';
+import type { IHarnessAccountStatus, IHarnessProcessControl, IHarnessStatusOptions } from './interfaces.harness.js';
 
 export interface IClaudeCodeHarnessOptions {
   configDir?: string;
@@ -107,8 +107,8 @@ export class ClaudeCodeHarness extends FileHarness {
       throw new Error('Claude Code switch failed while updating account metadata. The outgoing login remains saved; check doctor before restarting.');
     }
   }
-  public async readAccountStatus(id: string): Promise<IHarnessAccountStatus> {
+  public async readAccountStatus(id: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus> {
     const account = this.readCredential(id);
-    return this.status.read(credentialRecord(account.credential.claudeAiOauth), credentialRecord(account.credential.oauthAccount));
+    return this.status.read(credentialRecord(account.credential.claudeAiOauth), credentialRecord(account.credential.oauthAccount), optionsArg);
   }
 }

package/ts/classes.claudestatus.ts

@@ -1,6 +1,6 @@
 import { credentialRecord, credentialText } from './classes.credentialstore.js';
 import { plainText } from './formatting.js';
-import type { IHarnessAccountStatus, IHarnessUsageWindow, TUsageSeverity } from './interfaces.harness.js';
+import type { IHarnessAccountStatus, IHarnessStatusOptions, IHarnessUsageWindow, TUsageSeverity } from './interfaces.harness.js';
 
 class ClaudeStatusError extends Error {}
 
@@ -105,8 +105,9 @@ const claudeUsageWindows = (usage: Record<string, unknown>): IClaudeUsageWindows
 /** Read-only Claude Code OAuth account endpoints. No refresh, inference, or browser session is used. */
 export class ClaudeAccountStatus {
   constructor(private readonly fetcher: typeof fetch = globalThis.fetch) {}
-  private async get(route: 'usage' | 'profile', accessToken: string): Promise<Record<string, unknown>> {
-    const signal = AbortSignal.timeout(10_000);
+  private async get(route: 'usage' | 'profile', accessToken: string, cancelArg?: AbortSignal): Promise<Record<string, unknown>> {
+    const timeout = AbortSignal.timeout(10_000);
+    const signal = cancelArg ? AbortSignal.any([cancelArg, timeout]) : timeout;
     try {
       const response = await this.fetcher(`https://api.anthropic.com/api/oauth/${route}`, {
         method: 'GET', redirect: 'error', signal,
@@ -133,12 +134,12 @@ export class ClaudeAccountStatus {
       try { return credentialRecord(JSON.parse(Buffer.concat(chunks).toString('utf8'))); }
       catch { throw new ClaudeStatusError('The Claude account service returned invalid data.'); }
     } catch (error) {
-      if (signal.aborted) throw new ClaudeStatusError('The Claude account request timed out.');
+      if (signal.aborted) throw new ClaudeStatusError(timeout.aborted ? 'The Claude account request timed out.' : 'The Claude account request was cancelled.');
       if (error instanceof ClaudeStatusError) throw error;
       throw new ClaudeStatusError('The Claude account service could not be reached.');
     }
   }
-  public async read(oauth: Record<string, unknown>, account: Record<string, unknown>): Promise<IHarnessAccountStatus> {
+  public async read(oauth: Record<string, unknown>, account: Record<string, unknown>, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
     const result: IHarnessAccountStatus = { facts: [], problems: [] };
     const storedPlan = credentialText(oauth.subscriptionType);
     if (storedPlan) result.summary = { subscription: { plan: storedPlan, source: 'stored' } };
@@ -148,7 +149,7 @@ export class ClaudeAccountStatus {
     }
     const token = credentialText(oauth.accessToken);
     if (!token) return { facts: [], problems: ['No usable Claude Code access token is available.'] };
-    const [profile, usage] = await Promise.allSettled([this.get('profile', token), this.get('usage', token)]);
+    const [profile, usage] = await Promise.allSettled([this.get('profile', token, optionsArg.signal), this.get('usage', token, optionsArg.signal)]);
     if (profile.status === 'fulfilled') {
       try {
         const user = credentialRecord(profile.value.account);

package/ts/classes.cli.ts

@@ -7,7 +7,7 @@ import { AuthSwitchTui } from './classes.tui.js';
 import { AglAuthSwitchCoordinator, AuthSwitchOperations, type TAuthSwitchCoordinator, type TAuthSwitchMutation } from './classes.operations.js';
 import { AccountListRenderer, readAccountList } from './classes.accountlist.js';
 import { accountLimits, activeAccounts, CondensedRenderer } from './classes.limits.js';
-import { credentialDriftNote, duration, orderedUsageWindows, until } from './accounts.js';
+import { credentialDriftNote, duration, orderedUsageWindows, readAccountBadges, until } from './accounts.js';
 import { describeHarnessProcesses, describeStopOutcome } from './classes.harnessprocesses.js';
 import { defaultPreusePrompt, PreuseError, validatePreuseOptions } from './preuse.js';
 import type { CodexSwitcher } from './classes.codexswitcher.js';
@@ -25,6 +25,18 @@ const STOP_COMMANDS = ['use', 'stash'];
 /** Read-only overviews that work across every registered harness and support --json. */
 const OVERVIEW_COMMANDS = ['list', 'ls', 'limits', 'active'];
 
+/** An account as prompts and reports name it: its label, qualified by its credential slot when it has one. */
+const accountName = (accountArg: IHarnessAccount): string =>
+  `${plainText(accountArg.label)}${accountArg.slotId ? ` (${plainText(accountArg.slotId)})` : ''}`;
+
+/** The account a command acts on, named as it was offered, with the badge it was offered with. */
+interface IChosenAccount {
+  id: string;
+  name: string;
+  /** ` (type:Max) (5h:63%) (w:88%)`, empty when no part is known, or null when it was not read. */
+  badge: string | null;
+}
+
 /** Harness-independent command routing and interactive account management. */
 export class AuthSwitchCli {
   private readonly harnesses = new Map<string, IAuthHarness>();
@@ -406,7 +418,7 @@ ${bold('Environment')}
     for (const current of state.accounts.filter(account => account.isActive && !account.isStashed)) {
       const answer = await this.out.prompts.ask({
         name: 'saveCurrent', type: 'confirm',
-        message: `${plainText(current.label)}${current.slotId ? ` (${plainText(current.slotId)})` : ''} is not saved in ${harnessArg.label}. Save this login before switching?`, default: true,
+        message: `${accountName(current)} is not saved in ${harnessArg.label}. Save this login before switching?`, default: true,
       });
       if (answer !== true) return 'declined';
       if (this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'save', keepActive: true, accountId: current.id })) !== 0) return 'failed';
@@ -457,12 +469,12 @@ ${bold('Environment')}
         case 'list': code = await this.commandList([harnessArg]); break;
         case 'doctor': code = this.reportOutcome(await harnessArg.diagnose()); break;
         case 'drop': {
-          const id = await this.promptForAccount(harnessArg, `Which saved ${harnessArg.label} account should be removed?`, true, true);
-          if (!id) break;
+          const target = await this.promptForAccount(harnessArg, `Which saved ${harnessArg.label} account should be removed?`, { allowBack: true, includeIncomplete: true });
+          if (!target) break;
           const confirmation = await this.out.prompts.ask({
-            name: 'confirmDrop', type: 'confirm', message: `Remove the saved login for ${plainText(id)}? The active login stays as it is.`, default: false,
+            name: 'confirmDrop', type: 'confirm', message: `Remove the saved login for ${plainText(target.id)}? The active login stays as it is.`, default: false,
           });
-          if (confirmation === true) code = this.reportOutcome(await harnessArg.removeAccount(id));
+          if (confirmation === true) code = this.reportOutcome(await harnessArg.removeAccount(target.id));
           break;
         }
         case 'harness': return null;
@@ -492,7 +504,7 @@ ${bold('Environment')}
     if (accounts.length === 1) return accounts[0];
     if (!accounts.length) { process.stderr.write('No matching active login to save.\n'); return undefined; }
     if (!canPrompt()) { process.stderr.write(`Several logins are active. Use authswitch ${harness.id} stash <account/provider> [--keep].\n`); return undefined; }
-    const id = await this.out.prompts.ask({ name: 'activeAccount', type: 'list', message: 'Which active login should be saved?', choices: accounts.map(account => ({ name: `${plainText(account.label)}${account.slotId ? ` (${plainText(account.slotId)})` : ''}`, value: account.id })) });
+    const id = await this.out.prompts.ask({ name: 'activeAccount', type: 'list', message: 'Which active login should be saved?', choices: accounts.map(account => ({ name: accountName(account), value: account.id })) });
     return accounts.find(account => account.id === id);
   }
 
@@ -538,6 +550,14 @@ ${bold('Environment')}
     return null;
   }
 
+  /**
+   * Activate a saved account and report what is now active with its badge.
+   *
+   * The badge is read once per command through the bounded status read: the chooser reads it before it
+   * offers the accounts and the report repeats it, while a target named on the command line is read only
+   * after its switch, so nothing waits on it. A read that fails or does not answer in time leaves the name
+   * alone and never decides the outcome.
+   */
   private async commandUse(harnessArg: IAuthHarness, referenceArg?: string, allowBackArg = false, stopModeArg?: TStopMode): Promise<number> {
     let id: string | null = null;
     if (referenceArg) {
@@ -548,21 +568,42 @@ ${bold('Environment')}
       const offered = await this.offerToSave(harnessArg);
       if (offered !== 'ready') return offered === 'failed' ? 1 : 0;
     }
-    id ??= await this.promptForAccount(harnessArg, `Which ${harnessArg.label} account should be active?`, allowBackArg);
-    if (id === null) return allowBackArg ? 0 : 1;
-    return this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'switch', accountId: id }, stopModeArg));
+    const target = id === null
+      ? await this.promptForAccount(harnessArg, `Which ${harnessArg.label} account should be active?`, { allowBack: allowBackArg, withBadges: true })
+      : await this.namedAccount(harnessArg, id);
+    if (target === null) return allowBackArg ? 0 : 1;
+    const code = this.reportOutcome(await this.mutate(harnessArg, { harnessId: harnessArg.id, action: 'switch', accountId: target.id }, stopModeArg));
+    if (code !== 0) return code;
+    const badge = target.badge ?? (await readAccountBadges(harnessArg, [target.id])).get(target.id) ?? '';
+    process.stdout.write(`Now active: ${bold(target.name)}${badge}\n`);
+    return code;
+  }
+
+  /**
+   * A switch target named on the command line; its badge is not read here, so the switch never waits on it.
+   *
+   * The reference already resolved to this id, so the name is presentation only: a state read that fails
+   * names the account by its id and leaves the switch, which reports any real credential problem, to run.
+   */
+  private async namedAccount(harnessArg: IAuthHarness, idArg: string): Promise<IChosenAccount> {
+    let account: IHarnessAccount | undefined;
+    try { account = (await harnessArg.readState()).accounts.find(item => item.id === idArg); }
+    catch { account = undefined; }
+    return { id: idArg, name: account ? accountName(account) : plainText(idArg), badge: null };
   }
 
-  private async promptForAccount(harnessArg: IAuthHarness, messageArg: string, allowBackArg: boolean, includeIncompleteArg = false): Promise<string | null> {
-    const accounts = (await harnessArg.readState()).accounts.filter((accountArg) => accountArg.isStashed || (includeIncompleteArg && accountArg.savedAt !== null));
+  private async promptForAccount(harnessArg: IAuthHarness, messageArg: string, optionsArg: { allowBack?: boolean; includeIncomplete?: boolean; withBadges?: boolean } = {}): Promise<IChosenAccount | null> {
+    const accounts = (await harnessArg.readState()).accounts.filter((accountArg) => accountArg.isStashed || (optionsArg.includeIncomplete === true && accountArg.savedAt !== null));
     if (accounts.length === 0) { process.stderr.write(`${red('no stashed accounts')} - run \`authswitch ${harnessArg.id} stash\` first\n`); return null; }
     if (!canPrompt()) { process.stderr.write(`${red('an account is required')} without an interactive terminal: authswitch ${harnessArg.id} use <account>\n`); return null; }
+    const badges = optionsArg.withBadges ? await readAccountBadges(harnessArg, accounts.map((accountArg) => accountArg.id)) : null;
+    const offered = accounts.map((accountArg): IChosenAccount => ({ id: accountArg.id, name: accountName(accountArg), badge: badges === null ? null : badges.get(accountArg.id) ?? '' }));
     const answer = await this.out.prompts.ask({
       name: 'account', type: 'list', message: messageArg,
       default: accounts.find((accountArg) => accountArg.isActive)?.id ?? accounts[0].id,
-      choices: [...accounts.map((accountArg) => ({ name: `${plainText(accountArg.label)}${accountArg.slotId ? ` (${plainText(accountArg.slotId)})` : ''}${accountArg.isActive ? ' (active)' : ''}`, value: accountArg.id })),
-        ...(allowBackArg ? [{ name: 'Back', value: null }] : [])],
+      choices: [...accounts.map((accountArg, index) => ({ name: `${offered[index].name}${accountArg.isActive ? ' (active)' : ''}${offered[index].badge ?? ''}`, value: accountArg.id })),
+        ...(optionsArg.allowBack ? [{ name: 'Back', value: null }] : [])],
     });
-    return typeof answer === 'string' ? answer : null;
+    return offered.find((accountArg) => accountArg.id === answer) ?? null;
   }
 }

package/ts/classes.codexharness.ts

@@ -2,7 +2,7 @@ import { CodexSwitcher } from './classes.codexswitcher.js';
 import { CodexAccountStatus } from './classes.codexstatus.js';
 import { CodexPreuse } from './classes.codexpreuse.js';
 import { PreuseError } from './preuse.js';
-import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessOutcome, IHarnessState, IHarnessPreuseOptions, IHarnessPreuseResult } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessOutcome, IHarnessState, IHarnessPreuseOptions, IHarnessPreuseResult, IHarnessStatusOptions } from './interfaces.harness.js';
 import type { IStashListing } from './interfaces.js';
 import { countPaired, enrollmentState } from './helpers.js';
 import { beginSavedOpenAiLogin } from './classes.login.js';
@@ -70,10 +70,10 @@ export class CodexHarness implements IAuthHarness {
     };
   }
 
-  public async readAccountStatus(accountIdArg: string): Promise<IHarnessAccountStatus> {
+  public async readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus> {
     const credential = this.readAccountCredential(accountIdArg);
     if (!credential) return { facts: [], problems: ['No matching credential is available for status lookup.'] };
-    return this.accountStatus.read(credential.raw, credential.identity);
+    return this.accountStatus.read(credential.raw, credential.identity, optionsArg);
   }
 
   public async preuseAccount(accountIdArg: string, optionsArg: IHarnessPreuseOptions): Promise<IHarnessPreuseResult> {