@modelprofile.com/authswitch 3.1.0 → 3.3.0

package/ts/classes.accountlist.ts

@@ -1,10 +1,11 @@
 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';
 
 type TListedAccount = IHarnessAccountList['accounts'][number];
+type TNamedAccount = TListedAccount & { name: string };
 interface IDisplayFact { account: number; label: string; value: string; }
 
 /** Allowlist the public data contract: never serialize a harness or its credential-bearing internals. */
@@ -53,20 +54,60 @@ export const readAccountList = async (harnessesArg: IAuthHarness[]): Promise<IAc
 export const consoleWidth = (): number => process.stdout.columns ?? 100;
 export const consoleHeading = (textArg: string): void => { process.stdout.write(`\n${bold(textArg)}\n`); };
 
-/** One table implementation for every command, including the label-per-line fallback on narrow terminals. */
+/**
+ * One table implementation for every command, including the label-per-line fallback on narrow terminals.
+ *
+ * `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, 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,
   rowsArg: TRow[],
   columnsArg: plugins.smartconsole.IBackendTableColumn<TRow>[],
+  groupsArg?: NoInfer<plugins.smartconsole.IBackendTableGroups<TRow>>,
 ): Promise<void> => {
   if (!rowsArg.length) return;
-  if (consoleWidth() < 40) {
-    for (const row of rowsArg) {
-      process.stdout.write(columnsArg.map(column => `  ${column.title}: ${String(column.value(row) ?? 'Unavailable').replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
-    }
+  const width = consoleWidth();
+  if (width < 40) {
+    // 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}: ${content(column, row).replace(/\n/g, '\n    ')}`).join('\n') + '\n\n');
+    });
     return;
   }
-  await outArg.table(rowsArg, { columns: columnsArg, overflow: 'wrap', theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } } });
+  await outArg.table(rowsArg, {
+    columns: columnsArg, overflow: 'wrap', groups: groupsArg,
+    theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } },
+  });
+};
+
+/** List tables that repeat one account across rows divide it from the next account by its id. */
+const accountDividers: plugins.smartconsole.IBackendTableGroups<{ accountId: string | null }> = { divider: row => row.accountId };
+
+/**
+ * Names every account of one harness by its label, numbering each later account that repeats a label
+ * (`alice@example.com (2)`), so all tables name an account alike and the metric columns stay distinct.
+ */
+const nameAccounts = (accountsArg: TListedAccount[]): TNamedAccount[] => {
+  const labels = accountsArg.map(account => plainText(account.label));
+  const taken = new Set(labels);
+  return accountsArg.map((account, index) => {
+    const label = labels[index];
+    let name = label;
+    if (labels.indexOf(label) < index) {
+      for (let ordinal = 2; taken.has(name); ordinal++) name = `${label} (${ordinal})`;
+      taken.add(name);
+    }
+    return { ...account, name };
+  });
 };
 
 /** Shared, provider-independent list presentation. Adapters supply grouping metadata. */
@@ -75,10 +116,6 @@ export class AccountListRenderer {
   private get width(): number { return consoleWidth(); }
   private heading(textArg: string): void { consoleHeading(textArg); }
 
-  private async table<TRow>(rowsArg: TRow[], columnsArg: plugins.smartconsole.IBackendTableColumn<TRow>[]): Promise<void> {
-    await consoleTable(this.out, rowsArg, columnsArg);
-  }
-
   public async render(listArg: IAccountList): Promise<void> {
     const now = Date.parse(listArg.generatedAt);
     if (!listArg.harnesses.length) process.stdout.write('No harnesses registered.\n');
@@ -92,58 +129,60 @@ export class AccountListRenderer {
         process.stdout.write(`${dim(plainText(harness.saveUnavailableReason ?? 'No known accounts. ' + harness.loginHint))}\n`);
         continue;
       }
-      await this.overview(harness.accounts, now);
-      const schedules = harness.accounts.flatMap(account => orderedUsageWindows(account.status.summary?.usageWindows).map(window => ({ account: plainText(account.label), window })));
+      const accounts = nameAccounts(harness.accounts);
+      await this.overview(accounts, now);
+      const schedules = accounts.flatMap(account => orderedUsageWindows(account.status.summary?.usageWindows).map(window => ({ accountId: account.id, account: account.name, window })));
       for (const feature of [false, true]) {
         const scopedSchedules = schedules.filter(row => (row.window.scope === 'feature') === feature);
         if (!scopedSchedules.length) continue;
         this.heading(feature ? 'Feature-specific limits' : 'Usage & reset schedule');
-        await this.table(scopedSchedules, [
+        await consoleTable(this.out, scopedSchedules, [
           { key: 'account', title: 'Account', value: row => row.account },
           { key: 'window', title: 'Window', value: row => `${plainText(row.window.label)} (${duration(row.window.durationSeconds)})` },
           { key: 'usage', title: 'Usage', value: row => `${row.window.usedPercent}% used\n${Math.max(0, 100 - row.window.usedPercent)}% left` },
           { key: 'reset', title: 'Reset in', value: row => until(row.window.resetAt, now) },
-        ]);
+        ], accountDividers);
       }
-      const resets = harness.accounts.flatMap(account => (account.status.summary?.resets?.details ?? []).map(reset => ({ account: plainText(account.label), reset })));
+      const resets = accounts.flatMap(account => (account.status.summary?.resets?.details ?? []).map(reset => ({ accountId: account.id, account: account.name, reset })));
       if (resets.length) {
         this.heading('Earned reset details');
-        await this.table(resets, [
+        await consoleTable(this.out, resets, [
           { key: 'account', title: 'Account', value: row => row.account },
           { key: 'kind', title: 'Type', value: row => plainText(row.reset.kind) },
           { key: 'status', title: 'Status', value: row => plainText(row.reset.status) },
           { key: 'expiry', title: 'Expires (UTC)', value: row => row.reset.expiresAt === null ? 'Not reported' : plainText(row.reset.expiresAt).replace('T', '\n').replace('.000Z', '').replace(/Z$/, '') },
-        ]);
+        ], accountDividers);
       }
       const groups = new Map<string, IDisplayFact[]>();
       const add = (section: string, fact: IDisplayFact) => { const group = groups.get(section) ?? []; group.push(fact); groups.set(section, group); };
-      harness.accounts.forEach((account, index) => {
+      accounts.forEach((account, index) => {
         for (const fact of account.status.facts) {
           if (!this.covered(fact, account.status)) add(plainText(fact.section ?? 'Additional information'), { account: index, label: plainText(fact.label), value: plainText(fact.value) });
         }
       });
-      for (const [section, facts] of groups) await this.facts(section, facts, harness.accounts);
-      const saved = harness.accounts.flatMap((account, index) => [
+      for (const [section, facts] of groups) await this.facts(section, facts, accounts);
+      const saved = accounts.flatMap((account, index) => [
         ...(account.savedAt ? [{ account: index, label: 'Saved (UTC)', value: plainText(account.savedAt) }] : []),
         ...account.details.map((detail, detailIndex) => ({ account: index, label: `Note ${detailIndex + 1}`, value: plainText(detail) })),
       ]);
-      await this.facts('Saved logins', saved, harness.accounts);
-      const issues = harness.accounts.flatMap(account => account.status.problems.map(problem => ({ account: plainText(account.label), issue: plainText(problem) })));
-      if (harness.saveUnavailableReason) issues.push({ account: 'Harness', issue: plainText(harness.saveUnavailableReason) });
+      await this.facts('Saved logins', saved, accounts);
+      const issues: { accountId: string | null; account: string; issue: string }[] = accounts.flatMap(account =>
+        account.status.problems.map(problem => ({ accountId: account.id, account: account.name, issue: plainText(problem) })));
+      if (harness.saveUnavailableReason) issues.push({ accountId: null, account: 'Harness', issue: plainText(harness.saveUnavailableReason) });
       if (issues.length) {
         this.heading('Availability & actions');
-        await this.table(issues, [
+        await consoleTable(this.out, issues, [
           { key: 'account', title: 'Account', value: row => row.account },
           { key: 'issue', title: 'Unavailable / action needed', value: row => row.issue },
-        ]);
+        ], accountDividers);
       }
     }
   }
 
-  private async overview(accountsArg: TListedAccount[], nowArg: number): Promise<void> {
+  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';
@@ -159,7 +198,7 @@ export class AccountListRenderer {
     const resets = (account: TListedAccount) => account.status.summary?.resets === undefined ? 'Unavailable' : String(account.status.summary.resets.available);
     const usage = (account: TListedAccount) => accountQuotaSummary(account, nowArg);
     const columns: plugins.smartconsole.IBackendTableColumn<typeof rows[number]>[] = [
-      { key: 'account', title: 'Account', value: row => plainText(row.label), style: row => ({ bold: row.isActive }) },
+      { key: 'account', title: 'Account', value: row => row.name, style: row => ({ bold: row.isActive }) },
     ];
     if (this.width >= 100) columns.push(
       { key: 'state', title: 'Login', value: state, style: row => ({ foreground: row.isStashed ? 'green' : 'orange' }) },
@@ -174,7 +213,7 @@ export class AccountListRenderer {
       { key: 'usage', title: 'Usage / resets', value: row => `${usage(row)}\nEarned resets: ${resets(row)}` },
     );
     else columns.push({ key: 'status', title: 'Status', value: row => `${state(row)}\nPlan: ${plan(row)}\nBilling: ${billing(row)}\nUsage: ${usage(row)}\nEarned resets: ${resets(row)}` });
-    await this.table(rows, columns);
+    await consoleTable(this.out, rows, columns);
   }
 
   private covered(factArg: IHarnessStatusFact, statusArg: IHarnessAccountStatus): boolean {
@@ -191,10 +230,10 @@ export class AccountListRenderer {
   }
 
   /** Compare like metrics across accounts, keeping duplicate labels as separate rows. */
-  private async facts(titleArg: string, factsArg: IDisplayFact[], accountsArg: TListedAccount[]): Promise<void> {
+  private async facts(titleArg: string, factsArg: IDisplayFact[], accountsArg: TNamedAccount[]): Promise<void> {
     if (!factsArg.length) return;
     this.heading(titleArg);
-    const valueBudget = Math.max(10, Math.min(40, Math.max(...factsArg.map(fact => Math.max(fact.value.length, plainText(accountsArg[fact.account].label).length))) + 3));
+    const valueBudget = Math.max(10, Math.min(40, Math.max(...factsArg.map(fact => Math.max(fact.value.length, accountsArg[fact.account].name.length))) + 3));
     const perPage = Math.max(1, Math.min(6, Math.floor((this.width - 30) / valueBudget)));
     const accountIndices = accountsArg.map((_, index) => index).filter(index => factsArg.some(fact => fact.account === index));
     for (let start = 0; start < accountIndices.length; start += perPage) {
@@ -212,12 +251,12 @@ export class AccountListRenderer {
       }
       if (this.width < 40) {
         for (const index of indices) {
-          process.stdout.write(`  Account: ${plainText(accountsArg[index].label)}\n`);
+          process.stdout.write(`  Account: ${accountsArg[index].name}\n`);
           for (const metric of metrics.values()) if (metric.values.has(index)) process.stdout.write(`  - ${metric.label}: ${metric.values.get(index)}\n`);
         }
-      } else await this.table([...metrics.values()], [
+      } else await consoleTable(this.out, [...metrics.values()], [
         { key: 'metric', title: 'Metric', value: row => row.label },
-        ...indices.map(index => ({ key: String(index), title: plainText(accountsArg[index].label), value: (row: { values: Map<number, string> }) => row.values.get(index) ?? 'Not reported' })),
+        ...indices.map(index => ({ key: String(index), title: accountsArg[index].name, value: (row: { values: Map<number, string> }) => row.values.get(index) ?? 'Not reported' })),
       ]);
     }
   }

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> {

package/ts/classes.codexstatus.ts

@@ -1,5 +1,5 @@
 import type { ICodexIdentity } from './interfaces.js';
-import type { IHarnessAccountStatus, IHarnessStatusSummary } from './interfaces.harness.js';
+import type { IHarnessAccountStatus, IHarnessStatusOptions, IHarnessStatusSummary } from './interfaces.harness.js';
 import { commitinfo } from './00_commitinfo_data.js';
 
 // Verified Chromium-compatible billing request profile, independent of any locally installed browser.
@@ -39,7 +39,7 @@ class StatusRequestError extends Error {}
 export class CodexAccountStatus {
   constructor(private readonly fetcher: typeof fetch = globalThis.fetch) {}
 
-  public async read(rawArg: string, identityArg: ICodexIdentity): Promise<IHarnessAccountStatus> {
+  public async read(rawArg: string, identityArg: ICodexIdentity, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
     if (identityArg.kind !== 'chatgpt') return {
       facts: [{ label: 'Authentication', value: 'API key' }, { label: 'Subscription and usage', value: 'Not exposed by Codex for API-key logins' }], problems: [],
     };
@@ -47,18 +47,18 @@ export class CodexAccountStatus {
     try { accessToken = text(record(record(JSON.parse(rawArg)).tokens).access_token); }
     catch { return { facts: [], problems: ['The login has no usable access token. Log in again with Codex, then save the account.'] }; }
     if (!identityArg.accountId) return { facts: [], problems: ['The login has no account ID for a status lookup.'] };
-    return this.readCredential(accessToken, identityArg.accountId, identityArg.planType);
+    return this.readCredential(accessToken, identityArg.accountId, identityArg.planType, optionsArg);
   }
 
   /** Read the ChatGPT account directly, independent of a harness's on-disk format. */
-  public async readCredential(accessToken: string, accountId: string, planType?: string | null): Promise<IHarnessAccountStatus> {
+  public async readCredential(accessToken: string, accountId: string, planType?: string | null, optionsArg: IHarnessStatusOptions = {}): Promise<IHarnessAccountStatus> {
     const result: IHarnessAccountStatus = { facts: [], problems: [] };
     const identityArg = { accountId, planType };
     const sections = await Promise.allSettled([
-      this.get('wham/usage', accessToken, identityArg.accountId),
-      this.get('wham/rate-limit-reset-credits', accessToken, identityArg.accountId),
-      this.get('wham/profiles/me', accessToken, identityArg.accountId),
-      this.get('accounts/check/v4-2023-04-27', accessToken, identityArg.accountId),
+      this.get('wham/usage', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('wham/rate-limit-reset-credits', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('wham/profiles/me', accessToken, identityArg.accountId, optionsArg.signal),
+      this.get('accounts/check/v4-2023-04-27', accessToken, identityArg.accountId, optionsArg.signal),
     ]);
     const usage = sections[0];
     if (usage.status === 'fulfilled' && usage.value.account_id != null && usage.value.account_id !== identityArg.accountId) {
@@ -92,8 +92,9 @@ export class CodexAccountStatus {
     return result;
   }
 
-  private async get(pathArg: string, tokenArg: string, accountIdArg: string): Promise<Record<string, unknown>> {
-    const signal = AbortSignal.timeout(10_000);
+  private async get(pathArg: string, tokenArg: string, accountIdArg: 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://chatgpt.com/backend-api/${pathArg}`, {
         method: 'GET', redirect: 'error', signal,
@@ -125,7 +126,7 @@ export class CodexAccountStatus {
       catch { throw new StatusRequestError('The service returned invalid status data.'); }
     } catch (errorArg) {
       // Never surface remote bodies, request headers, token strings or arbitrary fetch errors.
-      if (signal.aborted) throw new Error('The status request timed out.');
+      if (signal.aborted) throw new Error(timeout.aborted ? 'The status request timed out.' : 'The status request was cancelled.');
       if (errorArg instanceof StatusRequestError) throw errorArg;
       throw new Error('The status service could not be reached.');
     }

package/ts/classes.fileharness.ts

@@ -1,4 +1,4 @@
-import type { IAuthHarness, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessOutcome, IHarnessProcessControl, IHarnessState } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessOutcome, IHarnessProcessControl, IHarnessState, IHarnessStatusOptions } from './interfaces.harness.js';
 import { credentialHash, CredentialStore, type IStoredCredential, type ISwitchRecord } from './classes.credentialstore.js';
 import { pauseSynchronously } from './helpers.js';
 import { plainText } from './formatting.js';
@@ -28,7 +28,7 @@ export abstract class FileHarness implements IAuthHarness {
   /** Raw bytes of the native files a snapshot's credentials are taken from, in a fixed order. */
   protected abstract nativeSources(): (string | null)[];
   protected abstract inspect(credential: Record<string, unknown>, slotId: string): IFileAccount;
-  public abstract readAccountStatus(id: string): Promise<IHarnessAccountStatus>;
+  public abstract readAccountStatus(id: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
 
   /**
    * A snapshot proven not to have been taken across a native write.