@modelprofile.com/authswitch 3.3.0 → 5.0.0

package/ts/classes.limits.ts

@@ -1,15 +1,25 @@
 import * as plugins from './plugins.js';
-import { accountTypeText, compactSince, compactUntil, credentialDriftNote, orderedUsageWindows } from './accounts.js';
-import { consoleHeading, consoleTable } from './classes.accountlist.js';
+import { accountTypeText, compactSince, compactUntil, credentialDriftNote, localDate, orderedUsageWindows, usagePercentText } from './accounts.js';
+import { consoleHeading, consoleNote, consoleTable } from './consoletable.js';
 import type { IAccountList, IAccountLimitRow, IAccountLimits, IActiveAccountDrift, IActiveAccountRow, IActiveAccounts, IHarnessAccountList } from './interfaces.list.js';
-import type { IAccountType, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
+import type { IAccountType, IAuthHarness, IHarnessBilling, IHarnessCredentialDrift, TUsageSeverity } from './interfaces.harness.js';
 import { dim, plainText } from './formatting.js';
 
 type TListedAccount = IHarnessAccountList['accounts'][number];
 
-const UNAVAILABLE = 'n/a';
+export const UNAVAILABLE = 'n/a';
 const NONE = 'none';
 
+/** What the projections need to know about a harness beyond its account list. */
+export type THarnessTraits = Pick<IAuthHarness, 'id' | 'liveSwap' | 'renewalUnavailableReason'>;
+
+/** The declared traits of a listed harness; a list is always projected with the harnesses it was read from. */
+const traitsOf = (harnessesArg: readonly THarnessTraits[], harnessArg: IHarnessAccountList): THarnessTraits => {
+  const traits = harnessesArg.find(harness => harness.id === harnessArg.id);
+  if (traits === undefined) throw new Error(`The account list names harness ${plainText(harnessArg.id)}, which was not passed with it.`);
+  return traits;
+};
+
 /**
  * Provider naming stays data-driven.
  *
@@ -47,11 +57,46 @@ const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount
 });
 
 /** The account's plan, sanitised like every other label and copied so that no two rows share one object. */
-const accountType = (accountArg: TListedAccount): IAccountType | null => {
+export const accountType = (accountArg: TListedAccount): IAccountType | null => {
   const subscription = accountArg.status.summary?.subscription;
   return subscription === undefined ? null : { plan: plainText(subscription.plan), source: subscription.source };
 };
 
+/** The account's reported billing fields, sanitised and copied per row; null when the provider reported none. */
+export const accountBilling = (accountArg: TListedAccount): IHarnessBilling | null => {
+  const billing = accountArg.status.summary?.billing;
+  if (billing === undefined) return null;
+  const date = (valueArg: string | undefined) => valueArg === undefined ? undefined : plainText(valueArg);
+  return Object.fromEntries(Object.entries({
+    hasActiveSubscription: billing.hasActiveSubscription, autoRenew: billing.autoRenew,
+    renewsAt: date(billing.renewsAt), cancelsAt: date(billing.cancelsAt), expiresAt: date(billing.expiresAt),
+  }).filter(([, value]) => value !== undefined)) as IHarnessBilling;
+};
+
+/** The next billing event a provider reported: a renewal it will charge, or the end of a subscription it will not renew. */
+export interface IRenewal {
+  at: string;
+  kind: 'auto-renews' | 'cancels';
+}
+
+/** Read from the reported fields only; a missing or unparseable date is no event, never an inferred one. */
+export const nextRenewal = (billingArg: IHarnessBilling | null): IRenewal | null => {
+  if (billingArg === null) return null;
+  const known = (valueArg: string | undefined): valueArg is string => valueArg !== undefined && Number.isFinite(Date.parse(valueArg));
+  if (billingArg.autoRenew === true && known(billingArg.renewsAt)) return { at: billingArg.renewsAt, kind: 'auto-renews' };
+  if (known(billingArg.cancelsAt)) return { at: billingArg.cancelsAt, kind: 'cancels' };
+  if (billingArg.autoRenew === false && known(billingArg.expiresAt)) return { at: billingArg.expiresAt, kind: 'cancels' };
+  return null;
+};
+
+/** The Renewal cell: the local date, and beneath it whether the subscription renews or ends then; a dim `n/a` otherwise. */
+export const renewalCell = (billingArg: IHarnessBilling | null): plugins.smartconsole.TText => {
+  const renewal = nextRenewal(billingArg);
+  return renewal === null ? plugins.smartconsole.color.text(UNAVAILABLE, { dim: true })
+    : plugins.smartconsole.color.concat(`${localDate(renewal.at)}\n`,
+      plugins.smartconsole.color.text(renewal.kind, renewal.kind === 'cancels' ? { foreground: 'orange' } : { dim: true }));
+};
+
 const harnessProblem = (harnessArg: IHarnessAccountList): string | null =>
   harnessArg.problems.length ? harnessArg.problems.map(plainText).join(' ') : null;
 
@@ -96,44 +141,49 @@ const collectNotes = (rowsArg: { provider: string; account: string | null; unava
   [...new Set(rowsArg.map(noteFor).filter((note): note is string => note !== null))];
 
 /** The drift a switch record proves, carried into the row document with both accounts named. */
-const activeDrift = (harnessArg: IHarnessAccountList, driftArg: IHarnessCredentialDrift): IActiveAccountDrift => ({
+const activeDrift = (traitsArg: THarnessTraits, driftArg: IHarnessCredentialDrift): IActiveAccountDrift => ({
   expectedAccountId: driftArg.expectedAccountId, expectedAccount: driftArg.expectedLabel === null ? null : plainText(driftArg.expectedLabel),
   currentAccountId: driftArg.currentAccountId, currentAccount: driftArg.currentLabel === null ? null : plainText(driftArg.currentLabel),
-  currentIsSaved: driftArg.currentIsSaved, switchedAt: driftArg.switchedAt, reason: credentialDriftNote(harnessArg.id, driftArg),
+  currentIsSaved: driftArg.currentIsSaved, switchedAt: driftArg.switchedAt, reason: credentialDriftNote(traitsArg, driftArg),
 });
 
 /**
- * One row per account and limit type, projected from the account list.
+ * One row per account and limit type, projected from the account list and the harnesses it was read from.
  *
- * Nothing here talks to a provider: the list is already the read-only, per-account-isolated lookup,
- * so a single failing account costs its own rows a number and nothing else.
+ * Nothing here talks to a provider: the list is already the per-account-isolated lookup, so a single
+ * failing account costs its own rows a number and nothing else. A harness that declares its provider
+ * never reports renewal dates gets one note instead of an unexplained `n/a` per account.
  */
-export const accountLimits = (listArg: IAccountList): IAccountLimits => {
+export const accountLimits = (listArg: IAccountList, harnessesArg: readonly THarnessTraits[]): IAccountLimits => {
   const now = Date.parse(listArg.generatedAt);
   const rows: IAccountLimitRow[] = [];
+  const renewalNotes: string[] = [];
   for (const harness of listArg.harnesses) {
     const problem = harnessProblem(harness);
     const empty = {
       limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE, severity: null, headline: false,
     } as const;
     if (problem !== null) {
-      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, ...empty, unavailableReason: problem });
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, billing: null, ...empty, unavailableReason: problem });
       continue;
     }
     if (!harness.accounts.length) {
-      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, ...empty,
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, accountType: null, billing: null, ...empty,
         unavailableReason: harness.saveUnavailableReason === null ? 'No accounts are known for this harness.' : plainText(harness.saveUnavailableReason) });
       continue;
     }
+    const renewalUnavailable = traitsOf(harnessesArg, harness).renewalUnavailableReason;
+    if (renewalUnavailable !== undefined) renewalNotes.push(`${plainText(harness.label)}: ${plainText(renewalUnavailable)}`);
     for (const account of harness.accounts) {
+      const identity = () => ({ ...accountKeys(harness, account), isActive: account.isActive, accountType: accountType(account), billing: accountBilling(account) });
       const windows = orderedUsageWindows(account.status.summary?.usageWindows);
       if (!windows.length) {
-        rows.push({ ...accountKeys(harness, account), isActive: account.isActive, accountType: accountType(account), ...empty, unavailableReason: missingLimitReason(account) });
+        rows.push({ ...identity(), ...empty, unavailableReason: missingLimitReason(account) });
         continue;
       }
       for (const window of windows) {
         rows.push({
-          ...accountKeys(harness, account), isActive: account.isActive, accountType: accountType(account),
+          ...identity(),
           limitType: plainText(window.label), scope: window.scope ?? 'account', windowSeconds: window.durationSeconds,
           usedPercent: window.usedPercent, resetAt: window.resetAt, resetsIn: compactUntil(window.resetAt, now, UNAVAILABLE),
           severity: window.severity ?? null, headline: window.headline === true, unavailableReason: null,
@@ -142,7 +192,7 @@ export const accountLimits = (listArg: IAccountList): IAccountLimits => {
     }
   }
   const limits = byProviderThenAccount(rows);
-  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, limits, notes: collectNotes(limits) };
+  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, limits, notes: [...collectNotes(limits), ...renewalNotes] };
 };
 
 /**
@@ -151,16 +201,17 @@ export const accountLimits = (listArg: IAccountList): IAccountLimits => {
  * A harness with no active login still gets a row: "nothing is active here" is an answer, and
  * silently dropping the provider would read as "this provider does not exist".
  */
-export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
+export const activeAccounts = (listArg: IAccountList, harnessesArg: readonly THarnessTraits[]): IActiveAccounts => {
   const now = Date.parse(listArg.generatedAt);
   const rows: IActiveAccountRow[] = [];
   const unattached: string[] = [];
   for (const harness of listArg.harnesses) {
+    const traits = traitsOf(harnessesArg, harness);
     const problem = harnessProblem(harness);
     const drifts = [...harness.credentialDrift];
     const driftFor = (slotIdArg?: string): IActiveAccountDrift | null => {
       const index = drifts.findIndex(item => item.slotId === slotIdArg);
-      return index < 0 ? null : activeDrift(harness, drifts.splice(index, 1)[0]);
+      return index < 0 ? null : activeDrift(traits, drifts.splice(index, 1)[0]);
     };
     if (problem !== null) {
       rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, accountType: null, savedAt: null, savedAgo: UNAVAILABLE, source: 'none', unavailableReason: problem, drift: null });
@@ -175,7 +226,7 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
         unavailableReason: harness.saveUnavailableReason !== null ? plainText(harness.saveUnavailableReason)
           : stashed.length ? `No login is active; ${stashed.length} saved account(s) can be activated with authswitch ${plainText(harness.id)} use.`
             : `No login is active and none is saved. ${plainText(harness.loginHint)}`,
-        drift: drifts.length ? activeDrift(harness, drifts.shift()!) : null,
+        drift: drifts.length ? activeDrift(traits, drifts.shift()!) : null,
       });
     } else {
       for (const account of active) {
@@ -189,7 +240,7 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
       }
     }
     // A drifted slot with no row of its own still has to be reported, not dropped.
-    for (const drift of drifts) unattached.push(`${providerName(harness)}${drift.slotId === undefined ? '' : ` / ${plainText(drift.slotId)}`}: ${credentialDriftNote(harness.id, drift)}`);
+    for (const drift of drifts) unattached.push(`${providerName(harness)}${drift.slotId === undefined ? '' : ` / ${plainText(drift.slotId)}`}: ${credentialDriftNote(traits, drift)}`);
   }
   const active = byProviderThenAccount(rows);
   const driftNotes = active.filter(row => row.drift !== null)
@@ -200,44 +251,67 @@ export const activeAccounts = (listArg: IAccountList): IActiveAccounts => {
 /**
  * The Account cell: the label, and the account type beneath it, dim. An unknown type keeps its line as
  * `n/a`, so every account cell has the same shape; a provider row without an account has no type to name.
+ * A view without a Provider column names the credential slot in the type line (`openai · Pro`) when the
+ * harness owns several.
  */
-const accountCell = (rowArg: IAccountLimitRow): plugins.smartconsole.TText => rowArg.account === null ? UNAVAILABLE
-  : plugins.smartconsole.color.concat(`${rowArg.account}\n`, plugins.smartconsole.color.text(accountTypeText(rowArg.accountType) ?? UNAVAILABLE, { dim: true, bold: false }));
+export const accountCell = (rowArg: Pick<IAccountLimitRow, 'account' | 'accountType' | 'slotId'>, slotsArg: boolean): plugins.smartconsole.TText => {
+  if (rowArg.account === null) return UNAVAILABLE;
+  const type = [slotsArg ? rowArg.slotId : undefined, accountTypeText(rowArg.accountType) ?? undefined].filter(part => part !== undefined).join(' · ');
+  return plugins.smartconsole.color.concat(`${rowArg.account}\n`, plugins.smartconsole.color.text(type || UNAVAILABLE, { dim: true, bold: false }));
+};
 
-const percent = (rowArg: IAccountLimitRow): string => rowArg.usedPercent === null ? UNAVAILABLE : `${rowArg.usedPercent}%`;
+const percent = (rowArg: IAccountLimitRow): string => rowArg.usedPercent === null ? UNAVAILABLE : usagePercentText(rowArg.usedPercent);
 
 const SEVERITY_COLORS: Record<TUsageSeverity, plugins.smartconsole.TColorName | undefined> = { normal: undefined, warning: 'orange', critical: 'red' };
 
 /** The provider's own reading colours a window; without one, n/a and exhausted windows stand out. */
-const percentColor = (rowArg: IAccountLimitRow): plugins.smartconsole.TColorName | undefined =>
-  rowArg.severity !== null ? SEVERITY_COLORS[rowArg.severity]
-    : rowArg.usedPercent === null ? 'orange' : rowArg.usedPercent >= 100 ? 'red' : undefined;
+export const usageColor = (severityArg: TUsageSeverity | null, usedPercentArg: number | null): plugins.smartconsole.TColorName | undefined =>
+  severityArg !== null ? SEVERITY_COLORS[severityArg]
+    : usedPercentArg === null ? 'orange' : usedPercentArg >= 100 ? 'red' : undefined;
+const percentColor = (rowArg: IAccountLimitRow): plugins.smartconsole.TColorName | undefined => usageColor(rowArg.severity, rowArg.usedPercent);
+
+/** Which parts of the limits table a view shows. */
+export interface ILimitsTableOptions {
+  /** The Provider column and the per-harness colour line, for a view across harnesses. */
+  provider: boolean;
+  renewal: boolean;
+  /** Whether the harness owns several credential slots, named in the account cell when there is no Provider column. */
+  slots: boolean;
+}
 
-/** Condensed presentation for `authswitch limits` and `authswitch active`. */
+/** Condensed presentation for `authswitch limits` and `authswitch active`, and the limits table other views embed. */
 export class CondensedRenderer {
   constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
 
   private notes(notesArg: string[], prefixArg: string): void {
     if (!notesArg.length) return;
     process.stdout.write('\n');
-    for (const note of notesArg) process.stdout.write(`${dim(`${prefixArg}${note}`)}\n`);
+    for (const note of notesArg) consoleNote(note, prefixArg);
   }
 
   public async renderLimits(limitsArg: IAccountLimits): Promise<void> {
     consoleHeading('Account limits');
+    if (!limitsArg.limits.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await this.limitsTable(limitsArg.limits, { provider: true, renewal: true, slots: false });
+    this.notes(limitsArg.notes, 'n/a — ');
+  }
+
+  /** One row per account and limit type; `rowsArg` must be ordered by `byProviderThenAccount` and is rendered as it is. */
+  public async limitsTable(rowsArg: IAccountLimitRow[], optionsArg: ILimitsTableOptions): Promise<void> {
     // The span callbacks record these exact rows, so the table renders this array as it is.
-    const rows = limitsArg.limits;
-    if (!rows.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
-    await consoleTable(this.out, rows, [
-      { key: 'provider', title: 'Provider', value: row => row.provider, rowSpan: plugins.smartconsole.rowSpansBy(rows, providerRuns) },
-      { key: 'account', title: 'Account', value: row => row.account ?? UNAVAILABLE, render: accountCell,
-        style: row => ({ bold: row.isActive }), rowSpan: plugins.smartconsole.rowSpansBy(rows, accountRuns) },
+    const accountSpan = plugins.smartconsole.rowSpansBy(rowsArg, accountRuns);
+    const columns: plugins.smartconsole.IBackendTableColumn<IAccountLimitRow>[] = [
+      ...(optionsArg.provider ? [{ key: 'provider', title: 'Provider', value: (row: IAccountLimitRow) => row.provider, rowSpan: plugins.smartconsole.rowSpansBy(rowsArg, providerRuns) }] : []),
+      { key: 'account', title: 'Account', value: row => row.account ?? UNAVAILABLE, render: row => accountCell(row, optionsArg.slots),
+        style: row => ({ bold: row.isActive }), rowSpan: accountSpan },
       { key: 'limit', title: 'Limit type', value: row => row.limitType ?? UNAVAILABLE },
       { key: 'used', title: 'Used %', value: percent, align: 'right',
         style: row => ({ foreground: percentColor(row) }) },
       { key: 'reset', title: 'Resets in', value: row => row.resetsIn, align: 'right' },
-    ], { divider: accountRuns, colorLine: harnessRuns });
-    this.notes(limitsArg.notes, 'n/a — ');
+      ...(optionsArg.renewal ? [{ key: 'renewal', title: 'Renewal', value: (row: IAccountLimitRow) => nextRenewal(row.billing)?.at ?? UNAVAILABLE,
+        render: (row: IAccountLimitRow) => renewalCell(row.billing), rowSpan: accountSpan }] : []),
+    ];
+    await consoleTable(this.out, rowsArg, columns, optionsArg.provider ? { divider: accountRuns, colorLine: harnessRuns } : { divider: accountRuns });
   }
 
   public async renderActive(activeArg: IActiveAccounts): Promise<void> {

package/ts/classes.listrenderer.ts

@@ -0,0 +1,328 @@
+import * as plugins from './plugins.js';
+import { accountUsageWindows, compactUsageLine, credentialDriftProblem, localDate, localDateTime, localiseTimestamps } from './accounts.js';
+import { accountBilling, accountCell, accountLimits, accountType, CondensedRenderer, nextRenewal, renewalCell, UNAVAILABLE, usageColor, type THarnessTraits } from './classes.limits.js';
+import { consoleHeading, consoleNote, consoleTable, consoleWidth } from './consoletable.js';
+import type { IHarnessStatusFact, IHarnessStatusSummary } from './interfaces.harness.js';
+import type { IAccountList, IAccountLimitRow, IHarnessAccountList } from './interfaces.list.js';
+import { orange, plainText } from './formatting.js';
+
+type TListedAccount = IHarnessAccountList['accounts'][number];
+type TNamedAccount = TListedAccount & { name: string };
+type TText = plugins.smartconsole.TText;
+
+const { color } = plugins.smartconsole;
+const dimText = (textArg: string): TText => color.text(textArg, { dim: true });
+/** Cell lines, one per part; parts that are null are left out. */
+const stack = (...partsArg: (TText | null)[]): TText =>
+  color.concat(...partsArg.filter((part): part is TText => part !== null).flatMap((part, index) => index ? ['\n', part] : [part]));
+
+/** How many dated rows a date series keeps: the newest week, as the providers report daily totals. */
+const DATED_ROWS = 7;
+const DATED_LABEL = /\d{4}-\d{2}-\d{2}$/;
+/** A problem that names what failed before its message: `Usage: Claude account service returned HTTP 429.` */
+const TOPIC_PROBLEM = /^([^:.]{1,40}): (.+)$/s;
+/** A saved-login note of the form `name: value` or `name:value`. */
+const NOTE_PAIR = /^([^:]{1,40}):\s*(.+)$/s;
+
+/**
+ * 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 };
+  });
+};
+
+/** Whether a fact restates a structured field that the Accounts or Limits table shows. */
+const shownSummaryField = (factArg: IHarnessStatusFact, summaryArg: IHarnessStatusSummary): boolean => {
+  switch (factArg.summaryKey) {
+    case 'subscription': return summaryArg.subscription !== undefined;
+    case 'billing': return summaryArg.billing !== undefined;
+    case 'usageWindows': return summaryArg.usageWindows !== undefined;
+    case 'resets': return summaryArg.resets !== undefined;
+    case 'resetDetails': return summaryArg.resets?.details !== undefined;
+    default: return false;
+  }
+};
+/** Facts the other tables already show: a displayed structured field, or the account's own label (a profile's email). */
+const covered = (factArg: IHarnessStatusFact, accountArg: TNamedAccount): boolean =>
+  (accountArg.status.summary !== undefined && shownSummaryField(factArg, accountArg.status.summary))
+  || plainText(factArg.value).toLowerCase() === plainText(accountArg.label).toLowerCase();
+
+const isSentence = (valueArg: string): boolean => /\s/.test(valueArg) && /[.!?]$/.test(valueArg);
+/** A topic continuing a list starts in lower case, unless its first word is a name (`OpenAI`). */
+const lowerFirst = (textArg: string): string => /^[A-Z][a-z]*(\s|$)/.test(textArg) ? `${textArg.charAt(0).toLowerCase()}${textArg.slice(1)}` : textArg;
+
+interface IDetailRow {
+  section: string;
+  label: string;
+  /** Value per account index. */
+  values: Map<number, string>;
+}
+type TDetailLine = IDetailRow | { section: string };
+
+interface IDetails {
+  /** Rows grouped by section, sections in first-seen order. */
+  sections: Map<string, IDetailRow[]>;
+  /** Sentences stated once instead of per account. */
+  notes: string[];
+}
+
+/**
+ * One comparison of everything the Accounts and Limits tables do not show, by section.
+ *
+ * A metric keeps one row across accounts, and a label an account repeats keeps a row per occurrence. A section of
+ * dated rows (daily totals) is merged across accounts and keeps the newest week. A sentence that every account in its
+ * section states identically is said once, as a note. Saved-login notes form their own section; a note that only
+ * restates the account's credential slot is left out, since the Accounts table names the slot.
+ */
+const collectDetails = (accountsArg: TNamedAccount[]): IDetails => {
+  const sections = new Map<string, Map<string, IDetailRow>>();
+  accountsArg.forEach((account, index) => {
+    const occurrences = new Map<string, number>();
+    const put = (sectionArg: string, labelArg: string, valueArg: string): void => {
+      const occurrenceKey = JSON.stringify([sectionArg, labelArg]);
+      const occurrence = occurrences.get(occurrenceKey) ?? 0;
+      occurrences.set(occurrenceKey, occurrence + 1);
+      const rows = sections.get(sectionArg) ?? new Map<string, IDetailRow>();
+      sections.set(sectionArg, rows);
+      const key = JSON.stringify([labelArg, occurrence]);
+      const row = rows.get(key) ?? { section: sectionArg, label: labelArg, values: new Map<number, string>() };
+      row.values.set(index, valueArg);
+      rows.set(key, row);
+    };
+    for (const fact of account.status.facts) {
+      if (!covered(fact, account)) put(plainText(fact.section ?? 'Additional information'), plainText(fact.label), localiseTimestamps(plainText(fact.value)));
+    }
+    for (const detail of account.details.map(plainText)) {
+      if (account.slotId !== undefined && detail === `Provider: ${plainText(account.slotId)}`) continue;
+      const pair = NOTE_PAIR.exec(detail);
+      put('Saved login', pair ? pair[1].trim() : 'Note', pair ? pair[2] : detail);
+    }
+  });
+  const notes: string[] = [];
+  const result = new Map<string, IDetailRow[]>();
+  for (const [section, keyed] of sections) {
+    const rows = [...keyed.values()];
+    const inSection = new Set(rows.flatMap(row => [...row.values.keys()]));
+    const dated = rows.filter(row => DATED_LABEL.test(row.label)).sort((left, right) => right.label.localeCompare(left.label)).slice(0, DATED_ROWS);
+    const kept: IDetailRow[] = [];
+    for (const row of [...dated, ...rows.filter(row => !DATED_LABEL.test(row.label))]) {
+      const values = [...new Set(row.values.values())];
+      if (values.length === 1 && isSentence(values[0]) && row.values.size === inSection.size) {
+        const names = row.values.size === accountsArg.length ? '' : `${[...row.values.keys()].map(index => accountsArg[index].name).join(', ')} — `;
+        notes.push(`${names}${row.label}: ${values[0]}`);
+      } else kept.push(row);
+    }
+    if (kept.length) result.set(section, kept);
+  }
+  return { sections: result, notes };
+};
+
+/**
+ * Problems with one message are merged, their topics joined: `Profile, usage: Login expired …`. Several topics take a
+ * line of their own and the message follows one sentence per line, so its words stay together in a narrow cell.
+ */
+const mergeProblems = (problemsArg: string[]): string[] => {
+  const topics = new Map<string, string[]>();
+  for (const problem of problemsArg.map(plainText)) {
+    const match = TOPIC_PROBLEM.exec(problem);
+    const message = match ? match[2] : problem;
+    const known = topics.get(message) ?? [];
+    if (match && !known.includes(match[1])) known.push(match[1]);
+    topics.set(message, known);
+  }
+  return [...topics].map(([message, names]) => !names.length ? message
+    : names.length === 1 ? `${names[0]}: ${message}`
+      : `${names.map((name, index) => index ? lowerFirst(name) : name).join(', ')}:\n${message.replace(/(?<=[.!?]) +(?=\S)/g, '\n')}`);
+};
+
+interface IProblemRow {
+  group: string;
+  accounts: string;
+  problem: string;
+}
+
+/** Shared, provider-independent list presentation: per harness an Accounts, a Limits, a Details and a Problems table. */
+export class AccountListRenderer {
+  constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
+  private get width(): number { return consoleWidth(); }
+
+  public async render(listArg: IAccountList, harnessesArg: readonly THarnessTraits[]): Promise<void> {
+    const now = Date.parse(listArg.generatedAt);
+    if (!listArg.harnesses.length) process.stdout.write('No harnesses registered.\n');
+    const limits = accountLimits(listArg, harnessesArg).limits;
+    // The same harness order as `limits`: by provider name.
+    const order = [...new Set(limits.map(row => row.harnessId))];
+    const harnesses = [...listArg.harnesses].sort((left, right) => order.indexOf(left.id) - order.indexOf(right.id));
+    for (const harness of harnesses) {
+      consoleHeading(plainText(harness.label));
+      if (harness.problems.length) {
+        for (const problem of harness.problems) process.stdout.write(`${orange('Unavailable')}: ${plainText(problem)}\n`);
+        continue;
+      }
+      if (!harness.accounts.length) {
+        consoleNote(plainText(harness.saveUnavailableReason ?? 'No known accounts. ' + harness.loginHint));
+        continue;
+      }
+      const accounts = nameAccounts(harness.accounts);
+      const slots = new Set(harness.accounts.map(account => account.slotId)).size > 1;
+      await this.accounts(accounts, slots, now);
+      // The Renewal cell can only read `n/a` for such a provider, so the declaration explains it here as it does in `limits`.
+      const renewalUnavailable = harnessesArg.find(traits => traits.id === harness.id)?.renewalUnavailableReason;
+      if (renewalUnavailable !== undefined) consoleNote(`${plainText(harness.label)}: ${plainText(renewalUnavailable)}`, `Renewal ${UNAVAILABLE} — `);
+      const names = new Map(accounts.map(account => [account.id, account.name]));
+      const limitRows: IAccountLimitRow[] = limits
+        .filter(row => row.harnessId === harness.id && row.limitType !== null)
+        .map(row => ({ ...row, account: row.accountId === null ? row.account : names.get(row.accountId) ?? row.account }));
+      if (limitRows.length) {
+        process.stdout.write('\n');
+        await new CondensedRenderer(this.out).limitsTable(limitRows, { provider: false, renewal: false, slots });
+      }
+      await this.details(accounts);
+      await this.problems(harness, accounts);
+    }
+  }
+
+  private async accounts(accountsArg: TNamedAccount[], slotsArg: boolean, nowArg: number): Promise<void> {
+    /** Whether the account is active and saved, then when it was saved; an active login without a save says so instead. */
+    const status = (account: TNamedAccount): TText => stack(
+      account.isActive ? color.text(account.isStashed ? 'active, saved' : 'active', { foreground: 'green', bold: false })
+        : color.text(account.isStashed ? 'saved' : 'not saved', { foreground: account.isStashed ? undefined : 'orange', bold: false }),
+      account.savedAt !== null ? dimText(localDateTime(account.savedAt))
+        : account.isActive && !account.isStashed ? color.text('not saved', { foreground: 'orange', bold: false }) : null,
+    );
+    const usage = (account: TNamedAccount): TText => {
+      const windows = accountUsageWindows(account);
+      if (windows === undefined) return dimText(`usage ${UNAVAILABLE}`);
+      if (!windows.length) return dimText('no usage reported');
+      return stack(...windows.map(window => color.text(compactUsageLine(window, windows, nowArg), { foreground: usageColor(window.severity ?? null, window.usedPercent) })));
+    };
+    const reportsResets = accountsArg.some(account => account.status.summary?.resets !== undefined);
+    const resetsCell = (account: TNamedAccount): TText => {
+      const summary = account.status.summary?.resets;
+      if (summary === undefined) return dimText(UNAVAILABLE);
+      return stack(String(summary.available), ...(summary.details ?? []).map(detail =>
+        dimText(`${plainText(detail.kind)} ${plainText(detail.status)}${detail.expiresAt === null ? '' : ` · until ${localDate(detail.expiresAt)}`}`)));
+    };
+    /** Earned resets as extra cell lines, for the layouts without their own column; only where the harness reports any. */
+    const resets = (account: TNamedAccount): TText | null => reportsResets ? color.concat(dimText('earned resets: '), resetsCell(account)) : null;
+    const renewalLine = (account: TNamedAccount): TText => {
+      const renewal = nextRenewal(accountBilling(account));
+      return renewal === null ? dimText(`renewal ${UNAVAILABLE}`) : `renewal ${localDate(renewal.at)} · ${renewal.kind}`;
+    };
+    const account = (row: TNamedAccount): TText => accountCell({ account: row.name, accountType: accountType(row), slotId: row.slotId }, slotsArg);
+    type TColumn = plugins.smartconsole.IBackendTableColumn<TNamedAccount>;
+    const accountColumn = (render: (row: TNamedAccount) => TText): TColumn =>
+      ({ key: 'account', title: 'Account', value: row => row.name, render, style: row => ({ bold: row.isActive }) });
+    const statusColumn: TColumn = { key: 'status', title: 'Status', value: row => color.plain(status(row)), render: status };
+    const renewalColumn: TColumn = { key: 'renewal', title: 'Renewal', value: row => nextRenewal(accountBilling(row))?.at ?? UNAVAILABLE, render: row => renewalCell(accountBilling(row)) };
+    const usageValue = (row: TNamedAccount): string => color.plain(usage(row));
+    let columns: TColumn[];
+    if (this.width >= 120) {
+      columns = [accountColumn(account), statusColumn, { key: 'usage', title: 'Usage', value: usageValue, render: usage }, renewalColumn,
+        ...(reportsResets ? [{ key: 'resets', title: 'Earned resets', value: (row: TNamedAccount) => row.status.summary?.resets?.available, render: resetsCell }] : [])];
+    } else if (this.width >= 100) {
+      columns = [accountColumn(account), statusColumn, { key: 'usage', title: 'Usage', value: usageValue, render: row => stack(usage(row), resets(row)) }, renewalColumn];
+    } else if (this.width >= 60) {
+      columns = [accountColumn(row => stack(account(row), status(row))), { key: 'usage', title: 'Usage', value: usageValue, render: row => stack(usage(row), resets(row)) }, renewalColumn];
+    } else {
+      columns = [accountColumn(account), { ...statusColumn, render: row => stack(status(row), usage(row), renewalLine(row), resets(row)) }];
+    }
+    await consoleTable(this.out, accountsArg, columns, { divider: row => row.id });
+  }
+
+  /** The Details table, paged across as many account columns as the width holds, with its notes beneath. */
+  private async details(accountsArg: TNamedAccount[]): Promise<void> {
+    const { sections, notes } = collectDetails(accountsArg);
+    const rows = [...sections.values()].flat();
+    const withValues = accountsArg.map((_, index) => index).filter(index => rows.some(row => row.values.has(index)));
+    if (withValues.length) {
+      process.stdout.write('\n');
+      if (this.width < 40) this.narrowDetails(accountsArg, withValues, sections);
+      else {
+        // Section rows span the whole table, so only metric labels size the first column. A table is one edge plus, per
+        // column, its content, two spaces of padding and a rule; pages take accounts in order while they fit.
+        const labelWidth = Math.max('Metric'.length, ...rows.map(row => row.label.length));
+        const columnWidth = (indexArg: number): number => 3 + Math.min(40, Math.max(accountsArg[indexArg].name.length, ...rows.map(row => row.values.get(indexArg)?.length ?? 0)));
+        const pages: number[][] = [];
+        let used = 0;
+        for (const index of withValues) {
+          if (!pages.length || used + columnWidth(index) > this.width - 1) { pages.push([]); used = 1 + labelWidth + 3; }
+          pages[pages.length - 1].push(index);
+          used += columnWidth(index);
+        }
+        for (const page of pages) await this.detailsPage(accountsArg, page, sections);
+      }
+    }
+    if (notes.length) {
+      if (!withValues.length) process.stdout.write('\n');
+      for (const note of notes) consoleNote(note);
+    }
+  }
+
+  private async detailsPage(accountsArg: TNamedAccount[], indicesArg: number[], sectionsArg: Map<string, IDetailRow[]>): Promise<void> {
+    const lines: TDetailLine[] = [];
+    for (const [section, rows] of sectionsArg) {
+      const shown = rows.filter(row => indicesArg.some(index => row.values.has(index)));
+      if (shown.length) lines.push({ section }, ...shown);
+    }
+    const isRow = (lineArg: TDetailLine): lineArg is IDetailRow => 'values' in lineArg;
+    await consoleTable(this.out, lines, [
+      { key: 'metric', title: 'Metric', value: line => isRow(line) ? line.label : line.section,
+        colSpan: line => isRow(line) ? 1 : 1 + indicesArg.length, style: line => isRow(line) ? {} : { bold: true, foreground: 'cyan' } },
+      ...indicesArg.map((index): plugins.smartconsole.IBackendTableColumn<TDetailLine> => ({
+        key: `account-${index}`, title: accountsArg[index].name,
+        value: line => isRow(line) ? line.values.get(index) ?? UNAVAILABLE : line.section,
+        render: line => (isRow(line) ? line.values.get(index) : undefined) ?? dimText(UNAVAILABLE),
+      })),
+    ]);
+  }
+
+  private narrowDetails(accountsArg: TNamedAccount[], indicesArg: number[], sectionsArg: Map<string, IDetailRow[]>): void {
+    for (const index of indicesArg) {
+      process.stdout.write(`  Account: ${accountsArg[index].name}\n`);
+      for (const [section, rows] of sectionsArg) {
+        for (const row of rows) if (row.values.has(index)) process.stdout.write(`  - ${section} · ${row.label}: ${row.values.get(index)}\n`);
+      }
+    }
+  }
+
+  /** One Problems table: a changed active login first, then each account's merged problems, then the harness's own. */
+  private async problems(harnessArg: IHarnessAccountList, accountsArg: TNamedAccount[]): Promise<void> {
+    const rows: IProblemRow[] = harnessArg.credentialDrift.map((drift, index) => ({
+      group: `drift:${index}`,
+      accounts: accountsArg.find(account => account.id === drift.currentAccountId)?.name ?? (drift.currentLabel === null ? plainText(harnessArg.label) : plainText(drift.currentLabel)),
+      problem: credentialDriftProblem(harnessArg.id, drift),
+    }));
+    // Accounts with the same problems share one block.
+    const blocks = new Map<string, { names: string[]; problems: string[] }>();
+    for (const account of accountsArg) {
+      const problems = mergeProblems(account.status.problems);
+      if (!problems.length) continue;
+      const key = JSON.stringify(problems);
+      const block = blocks.get(key) ?? { names: [], problems };
+      block.names.push(account.name);
+      blocks.set(key, block);
+    }
+    // One line, not one name per line: a row-spanned cell lays its lines onto the rows it covers, which would read
+    // as "this account has this problem" for a block whose accounts all have all of them.
+    for (const [key, block] of blocks) rows.push(...block.problems.map(problem => ({ group: key, accounts: block.names.join(', '), problem })));
+    if (harnessArg.saveUnavailableReason !== null) rows.push({ group: 'harness', accounts: plainText(harnessArg.label), problem: plainText(harnessArg.saveUnavailableReason) });
+    if (!rows.length) return;
+    process.stdout.write('\n');
+    await consoleTable(this.out, rows, [
+      { key: 'account', title: 'Account', value: row => row.accounts, rowSpan: plugins.smartconsole.rowSpansBy(rows, row => row.group) },
+      { key: 'problem', title: 'Problem', value: row => row.problem, style: row => ({ foreground: row.group.startsWith('drift:') ? 'orange' : undefined }) },
+    ], { divider: row => row.group });
+  }
+}

package/ts/classes.login.ts

@@ -65,7 +65,7 @@ export class AuthSwitchLogin {
 
 /** A hosted or terminal UI sees only the prompt and saved-account outcome. */
 export const beginSavedOpenAiLogin = async (
-  save: (result: IAuthLoginResult) => IHarnessLoginResult,
+  save: (result: IAuthLoginResult) => IHarnessLoginResult | Promise<IHarnessLoginResult>,
   options: IHarnessLoginOptions,
   fetcher?: typeof fetch,
 ): Promise<IHarnessLoginHandle> => {

package/ts/classes.opencodeharness.ts

@@ -22,6 +22,10 @@ export class OpenCodeHarness extends FileHarness {
   public readonly id = 'opencode';
   public readonly label = 'OpenCode';
   public readonly loginHint = 'Use authswitch opencode login for OpenAI; use opencode auth login for other providers.';
+  /** OpenCode loads provider credentials at startup (1.18.28), so a running instance keeps its login until restarted. */
+  public readonly liveSwap = false;
+  /** Only its OpenAI login reports usage, and a supervisor (AGL) restarts it around a switch, so a watch leaves it alone. */
+  public readonly autoSwitch = false;
   public readonly loginProviders: IHarnessLoginProvider[] = [{ providerId: 'openai', label: 'OpenAI', flows: ['device'] }];
   protected readonly store: CredentialStore;
   private readonly file: string;
@@ -47,9 +51,9 @@ export class OpenCodeHarness extends FileHarness {
     return account ? this.openAiInfo(account.credential).accountId : undefined;
   }
   public beginLogin(options: IHarnessLoginOptions = { providerId: 'openai', flow: 'device' }) {
-    return beginSavedOpenAiLogin(result => {
-      const saved = this.importCredential('openai', openCodeCredentialFromLogin(result.credential));
-      const account = this.readState().accounts.find(account => account.id === saved.accountId)!;
+    return beginSavedOpenAiLogin(async result => {
+      const saved = await this.importCredential('openai', openCodeCredentialFromLogin(result.credential));
+      const account = (await this.readState()).accounts.find(account => account.id === saved.accountId)!;
       return { outcome: { lines: [`Saved OpenAI login for ${plainText(account.label)}. Select it to switch OpenCode.`], problems: [] }, account: { id: account.id, label: account.label, slotId: account.slotId } };
     }, options, this.fetcher);
   }