@modelprofile.com/authswitch 3.0.0 → 3.2.0

package/readme.md

@@ -188,7 +188,21 @@ the local file login, so launch-time flags, managed policies and credentials sup
 by embedding applications remain under Claude Code's control.
 
 Claude's direct OAuth profile and usage lookups report the plan, weekly and five-hour
-usage, model-specific windows, and available extra-usage budget information.
+usage, per-model and per-surface windows, and available extra-usage budget information.
+The usage response's `limits[]` rows are the authoritative window list: which
+meters apply, their scope, the service's `severity` (`normal`, `warning`,
+`critical`) and its headline pick are Claude's, so a new per-model weekly limit
+such as **Fable weekly** appears without an authswitch release. `list --json` keeps
+the rows in the service's order; the tables and `limits --json` order them as
+described under **Condensed views**. Rows are classified on their
+kind and reset group exactly as sent. Labels combine the service's model or surface
+name with the window period, and such a scoped row is treated as a feature limit.
+Rows in a reset group authswitch cannot represent (anything but the five-hour
+session and the weekly window) are not shown; one **Unsupported limits**
+availability fact names them. A malformed row, or a `limits` value that is not a
+list, makes the whole usage lookup unavailable rather than partially guessed.
+Responses without `limits[]` rows fall back to the older keyed weekly, five-hour
+and model windows.
 These endpoints require the `user:profile` scope and may reject expired or restricted
 logins. A null reset timestamp is shown as **Not scheduled**. Billing renewal and
 cancellation dates and earned reset credits are unavailable from these endpoints;
@@ -240,7 +254,8 @@ an uncertain request. `--json` remains a list-only option.
 ### Management dashboard
 
 `authswitch --tui` opens a resizable account table with subscription, usage and
-reset availability, usage bars, scrollable account details and an activity log.
+reset availability, usage bars for the lead window and the next general window,
+scrollable account details and an activity log.
 With multiple registered adapters, a harness selector switches the view; account
 selection and mutations always belong to the displayed harness. Status loads
 incrementally through each account's read-only API, without activating it.
@@ -322,17 +337,25 @@ output to Codex. Each section includes saved accounts and an identifiable active
 login even if it has never been saved. `*` marks the active account, and the saved
 marker checks the credential itself rather than just the existence of metadata.
 
-The overview compares login state, plan provenance, weekly usage, earned resets and
-the weekly reset countdown. Countdowns use days, hours and minutes, such as
+The overview compares login state, plan provenance, lead-window usage (the
+provider's headline window, otherwise weekly), earned resets and that window's
+reset countdown. Countdowns use days, hours and minutes, such as
 `7d 5h 6min`;
 `<1min` means less than a minute remains and `due` means the reported deadline has
 passed, without claiming the service has refreshed the quota. All countdowns share
 the same snapshot time.
-Usage and countdown refer to the same general account window, preferring weekly.
-If no weekly window is reported, the longest general window is shown with its
-actual duration. Other exhausted general windows retain their own reset warning.
-Feature limits such as Spark and code review have a separate table and never
-determine the general summary. The TUI uses the same weekly-first selection.
+Usage and countdown refer to the same window. When the provider picks a headline
+window (Claude does, for example its Fable weekly limit), that window leads.
+Otherwise the
+general account window leads, preferring weekly; if no weekly window is reported,
+the longest general window is shown with its actual duration. Other exhausted
+general windows retain their own reset warning. A general window is named by its
+period (`Weekly`, `5h`) unless another shown general window has the same period; a
+feature limit, or a general window sharing its period, is named by its label
+(`Fable weekly: 100% used`, `Claude weekly (weekly_oauth) exhausted`). Feature
+limits such as Spark and code review have a separate table and determine the
+summary only when the provider picks one as its headline. The TUI uses the same
+selection and names.
 Window durations come from the provider, not from the plan name or
 primary/secondary position; a Pro account with only a general weekly window gets
 no invented 5-hour limit.
@@ -340,34 +363,50 @@ 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
+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. Stored plans are
 marked 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         │    88% │         4d 3h │
-│ Claude Code          │ phil@example.com        │ Claude five-hour      │    63% │         1h 2m │
-│ Claude Code          │ phil@example.com        │ Opus weekly           │   100% │         4d 3h │
-│ 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 │
+┃ 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 │
 └──────────────────────┴─────────────────────────┴───────────────────────┴────────┴───────────────┘
 
 n/a — Codex · bob@example.com: Subscription and limits: Login expired or was rejected.
@@ -382,9 +421,31 @@ account never blanks another's numbers. `not scheduled` means the provider repor
 usage without a reset deadline; it is not the same as `n/a`.
 
 Limit types are the provider's own window names, ordered general-before-feature and
-weekly-first within an account. The provider column names the harness, qualified by
+weekly-first within an account. Claude's per-model and per-surface limits carry the
+service's name (`Fable weekly`); an unscoped Claude meter other than the five-hour
+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`).
 
+**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. 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; a rule line separates the accounts there, and no
+colour line is drawn.
+
 `authswitch active` answers "what am I logged in as" for every harness at once:
 
 ```
@@ -392,11 +453,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.
@@ -407,6 +468,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
@@ -440,7 +503,9 @@ 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
-`resetsIn`, the ISO `savedAt` beside the human `savedAgo`, the per-row
+`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
 `unavailableReason` that the footnotes summarise, and `drift`, which carries the
 expected and current account ids, their labels, whether the current one is saved,
 the ISO `switchedAt` of the switch that was undone, and the same sentence as `reason`. Both carry `schemaVersion: 1`, the
@@ -456,7 +521,9 @@ The exported `IAccountList` contract contains:
   empty list).
 - Each account's opaque `id`, `label`, `isActive`, verified `isStashed`, `savedAt`,
   `details`, and `status` containing all labelled `facts`, `problems`, and optional
-  typed `summary` fields. Missing fields remain omitted, not replaced by zero.
+  typed `summary` fields. Missing fields remain omitted, not replaced by zero;
+  `summary.usageWindows[]` carries `severity` and `headline` only when the provider
+  reported them.
 
 JSON retains full fact strings and absolute ISO reset/expiry timestamps. It exports
 the credential-free adapter contract, never credentials, raw HTTP responses or
@@ -561,11 +628,18 @@ explicit zeroes remain zero. A successful reset-detail lookup supplies the summa
 count; if it fails, the limits response can still supply availability.
 
 Each usage window may set `scope: 'account' | 'feature'` (default `account`).
-Adapters mark model-specific or feature-specific quotas as `feature` so those
-quotas remain available in JSON and details without distorting the general
-account summary. Weekly windows are identified by `durationSeconds: 604800`;
+Adapters mark model-specific or feature-specific quotas as `feature`; those quotas
+appear in the feature tables, JSON and details and lead the account summary only
+when the provider marks one as its headline (see below). Weekly windows are identified by `durationSeconds: 604800`;
 neither window labels nor plan names are parsed to infer limits.
 
+A window may also carry the provider's own reading: `severity?: TUsageSeverity`
+(`'normal' | 'warning' | 'critical'`) and `headline?: true` for the window the
+provider picks for a single-value summary. Adapters set them only when the provider
+reports them, never from local thresholds. A headline window leads the account
+summary whatever its scope; the first one in the adapter's order wins if several are
+marked.
+
 Optional `summary.billing` contains provider-reported `hasActiveSubscription`,
 `autoRenew`, `renewsAt`, `cancelsAt`, and `expiresAt`, independent of the plan name.
 Dates are ISO UTC and omitted

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '3.0.0',
+  version: '3.2.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, IHarnessStatusSummary } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccount, IHarnessAccountStatus, IHarnessCredentialDrift, IHarnessState, IHarnessUsageWindow } from './interfaces.harness.js';
 import { plainText } from './formatting.js';
 
 export interface IAccountRow {
@@ -72,20 +72,34 @@ 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';
 };
-type TUsageWindow = NonNullable<IHarnessStatusSummary['usageWindows']>[number];
 type TAccountStatusRow = Pick<IAccountRow, 'status'>;
-export const usagePeriod = (windowArg: TUsageWindow): string => windowArg.durationSeconds === 604800 ? 'Weekly' : duration(windowArg.durationSeconds);
+/**
+ * How a single-value summary names a window among the windows it shows. An account window is named by
+ * its period while it is the only shown account window of that period; a feature window, or an account
+ * window sharing its period with another, is named by its own label, so no meter reads as another's.
+ */
+export const usageWindowName = (windowArg: IHarnessUsageWindow, shownArg: readonly IHarnessUsageWindow[]): string =>
+  windowArg.scope === 'feature' || shownArg.some(other => other !== windowArg && other.scope !== 'feature' && other.durationSeconds === windowArg.durationSeconds)
+    ? plainText(windowArg.label)
+    : windowArg.durationSeconds === 604800 ? 'Weekly' : duration(windowArg.durationSeconds);
 /** Order by scope and actual duration: a provider's primary slot need not be five hours. */
-export const orderedUsageWindows = (windowsArg: readonly TUsageWindow[] = []): TUsageWindow[] => [...windowsArg].sort((left, right) =>
+export const orderedUsageWindows = (windowsArg: readonly IHarnessUsageWindow[] = []): IHarnessUsageWindow[] => [...windowsArg].sort((left, right) =>
   Number(left.scope === 'feature') - Number(right.scope === 'feature') ||
   Number(left.durationSeconds !== 604800) - Number(right.durationSeconds !== 604800) || right.durationSeconds - left.durationSeconds);
-export const accountUsageWindows = (rowArg: TAccountStatusRow): TUsageWindow[] | undefined => {
+/**
+ * The windows a single-value summary shows, lead window first: the provider's headline pick, whatever
+ * its scope, then the account windows in display order. Other feature quotas never lead a summary.
+ */
+export const accountUsageWindows = (rowArg: TAccountStatusRow): IHarnessUsageWindow[] | undefined => {
   const windows = rowArg.status?.summary?.usageWindows;
-  return windows === undefined ? undefined : orderedUsageWindows(windows.filter(window => window.scope !== 'feature'));
+  if (windows === undefined) return undefined;
+  const headline = windows.find(window => window.headline === true);
+  const accountWindows = orderedUsageWindows(windows.filter(window => window !== headline && window.scope !== 'feature'));
+  return headline === undefined ? accountWindows : [headline, ...accountWindows];
 };
 export const accountUsage = (rowArg: TAccountStatusRow): string => {
   const windows = accountUsageWindows(rowArg);
-  return windows?.length ? `${usagePeriod(windows[0])}: ${windows[0].usedPercent}% used` : windows ? 'None reported' : rowArg.status ? 'Unavailable' : 'Loading';
+  return windows?.length ? `${usageWindowName(windows[0], windows)}: ${windows[0].usedPercent}% used` : windows ? 'None reported' : rowArg.status ? 'Unavailable' : 'Loading';
 };
 export const accountResets = (rowArg: IAccountRow): string => rowArg.status?.summary?.resets === undefined ? rowArg.status ? 'Unavailable' : 'Loading' : String(rowArg.status.summary.resets.available);
 export const accountNextReset = (rowArg: TAccountStatusRow, nowArg = Date.now()): string => {
@@ -96,7 +110,7 @@ export const accountQuotaSummary = (rowArg: TAccountStatusRow, nowArg: number):
   const windows = accountUsageWindows(rowArg);
   return [accountUsage(rowArg), ...(windows?.length ? [
     `Reset in: ${accountNextReset(rowArg, nowArg)}`,
-    ...windows.slice(1).filter(window => window.usedPercent >= 100).map(window => `${usagePeriod(window)} exhausted\nResets in: ${until(window.resetAt, nowArg)}`),
+    ...windows.slice(1).filter(window => window.usedPercent >= 100).map(window => `${usageWindowName(window, windows)} exhausted\nResets in: ${until(window.resetAt, nowArg)}`),
   ] : [])].join('\n');
 };
 export const accountState = (rowArg: IAccountRow): string => `${rowArg.account.isActive ? '* active, ' : ''}${rowArg.account.isStashed ? 'saved' : 'not saved'}`;

package/ts/classes.accountlist.ts

@@ -5,6 +5,7 @@ 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. */
@@ -16,7 +17,7 @@ const publicStatus = (statusArg: IHarnessAccountStatus): IHarnessAccountStatus =
     ...(summary === undefined ? {} : { summary: {
       ...(summary.subscription === undefined ? {} : { subscription: { plan: summary.subscription.plan, source: summary.subscription.source } }),
       ...(summary.billing === undefined ? {} : { billing: { hasActiveSubscription: summary.billing.hasActiveSubscription, autoRenew: summary.billing.autoRenew, renewsAt: summary.billing.renewsAt, cancelsAt: summary.billing.cancelsAt, expiresAt: summary.billing.expiresAt } }),
-      ...(summary.usageWindows === undefined ? {} : { usageWindows: summary.usageWindows.map(({ label, scope, durationSeconds, usedPercent, resetAt }) => ({ label, scope, durationSeconds, usedPercent, resetAt })) }),
+      ...(summary.usageWindows === undefined ? {} : { usageWindows: summary.usageWindows.map(({ label, scope, durationSeconds, usedPercent, resetAt, severity, headline }) => ({ label, scope, durationSeconds, usedPercent, resetAt, severity, headline })) }),
       ...(summary.resets === undefined ? {} : { resets: {
         available: summary.resets.available,
         ...(summary.resets.details === undefined ? {} : { details: summary.resets.details.map(({ status, kind, expiresAt }) => ({ status, kind, expiresAt })) }),
@@ -53,20 +54,57 @@ 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.
+ */
 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) {
+  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`;
+    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');
-    }
+    });
     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 +113,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,55 +126,57 @@ 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';
@@ -159,7 +195,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 +210,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 +227,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 +248,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' })),
       ]);
     }
   }