@modelprofile.com/authswitch 2.1.3 → 2.3.0

package/ts/classes.accountlist.ts

@@ -49,21 +49,33 @@ 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. */
+export const consoleTable = async <TRow>(
+  outArg: plugins.smartconsole.SmartConsole,
+  rowsArg: TRow[],
+  columnsArg: plugins.smartconsole.IBackendTableColumn<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');
+    }
+    return;
+  }
+  await outArg.table(rowsArg, { columns: columnsArg, overflow: 'wrap', theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } } });
+};
+
 /** Shared, provider-independent list presentation. Adapters supply grouping metadata. */
 export class AccountListRenderer {
   constructor(private readonly out: plugins.smartconsole.SmartConsole) {}
-  private get width(): number { return process.stdout.columns ?? 100; }
-  private heading(textArg: string): void { process.stdout.write(`\n${bold(textArg)}\n`); }
+  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> {
-    if (!rowsArg.length) return;
-    if (this.width < 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');
-      }
-      return;
-    }
-    await this.out.table(rowsArg, { columns: columnsArg, overflow: 'wrap', theme: { header: { bold: true, foreground: 'cyan' }, border: { dim: true } } });
+    await consoleTable(this.out, rowsArg, columnsArg);
   }
 
   public async render(listArg: IAccountList): Promise<void> {

package/ts/classes.claudecodeharness.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 import { FileHarness, type IFileAccount, type IFileHarnessSnapshot } from './classes.fileharness.js';
-import { CredentialStore, credentialRecord, credentialText, readCredentialDocument, requireHarnessStopped } from './classes.credentialstore.js';
+import { CredentialStore, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw, requireHarnessStopped } from './classes.credentialstore.js';
 import { ClaudeAccountStatus } from './classes.claudestatus.js';
 import { writeSecretFileAtomically } from './helpers.js';
 import type { IHarnessAccountStatus } from './interfaces.harness.js';
@@ -23,7 +23,7 @@ const accountCaches = ['additionalModelOptionsCache', 'additionalModelOptionsAns
 export class ClaudeCodeHarness extends FileHarness {
   public readonly id = 'claude';
   public readonly label = 'Claude Code';
-  public readonly loginHint = 'Log in using claude auth login, exit Claude Code, then authswitch claude stash --keep.';
+  public readonly loginHint = 'Log in using claude auth login, then authswitch claude stash --keep; Claude Code may stay running.';
   protected readonly store: CredentialStore;
   private readonly file: string;
   private readonly configFile: string;
@@ -48,6 +48,8 @@ export class ClaudeCodeHarness extends FileHarness {
       plugins.path.join(process.cwd(), '.claude/settings.json'), plugins.path.join(process.cwd(), '.claude/settings.local.json')];
   }
   protected beforeMutation(): void { this.checkStopped(); }
+  /** One record holds the credential and its matching metadata, so both files must be proven stable. */
+  protected nativeSources(): (string | null)[] { return [readCredentialRaw(this.file), readCredentialRaw(this.configFile)]; }
   protected inspect(credential: Record<string, unknown>, slotId: string): IFileAccount {
     if (slotId !== 'anthropic') throw new Error('Unsupported Claude Code credential slot.');
     const oauth = credentialRecord(credential.claudeAiOauth);

package/ts/classes.cli.ts

@@ -6,6 +6,7 @@ import { ClaudeCodeHarness } from './classes.claudecodeharness.js';
 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 { duration, orderedUsageWindows, until } from './accounts.js';
 import { defaultPreusePrompt, PreuseError, validatePreuseOptions } from './preuse.js';
 import type { CodexSwitcher } from './classes.codexswitcher.js';
@@ -14,7 +15,9 @@ import { bold, dim, green, orange, plainText, red } from './formatting.js';
 
 const canPrompt = (): boolean =>
   process.stdin.isTTY === true && process.stdout.isTTY === true && !process.env.CI;
-const COMMANDS = ['login', 'stash', 'list', 'ls', 'use', 'preuse', 'current', 'drop', 'rm', 'doctor'];
+const COMMANDS = ['login', 'stash', 'list', 'ls', 'limits', 'active', 'use', 'preuse', 'current', 'drop', 'rm', 'doctor'];
+/** Read-only overviews that work across every registered harness and support --json. */
+const OVERVIEW_COMMANDS = ['list', 'ls', 'limits', 'active'];
 
 /** Harness-independent command routing and interactive account management. */
 export class AuthSwitchCli {
@@ -48,6 +51,8 @@ ${bold('Usage')}
   authswitch list                    list all accounts with live subscription, usage and resets
   authswitch <harness> list           list accounts for one harness
   authswitch list --json             print all account information as JSON
+  authswitch limits                  one row per account and limit type: used % and reset countdown
+  authswitch active                  one row per provider: which account is in use, and since when
   authswitch <harness> preuse <account> [--prompt <text>] [--model <id>]
                                     send one prompt through that account without switching
   authswitch <harness> stash [account/provider] [--keep]
@@ -68,7 +73,7 @@ ${bold('Options')}
   -v, --version                      show the version
   -i, --interactive                  open the guided account manager
   --tui                             open the terminal management dashboard
-  --json                            JSON output for list / ls only
+  --json                            JSON output for list / ls / limits / active only
 
 Preuse consumes the selected account's quota. Its default prompt is:
   "${defaultPreusePrompt}"
@@ -97,8 +102,8 @@ ${bold('Environment')}
         args.splice(args.indexOf('--json'), 1);
         const route = [...args];
         if (this.harnesses.has(route[0])) route.shift();
-        if (route.length !== 1 || !['list', 'ls'].includes(route[0])) {
-          process.stderr.write('--json requires list or ls, optionally qualified by a harness.\n');
+        if (route.length !== 1 || !OVERVIEW_COMMANDS.includes(route[0])) {
+          process.stderr.write(`--json requires ${OVERVIEW_COMMANDS.join(', ')}, optionally qualified by a harness.\n`);
           return 2;
         }
       }
@@ -130,9 +135,12 @@ ${bold('Environment')}
         process.stderr.write(`${red('unknown harness or command')} "${plainText(first)}"\n\n${this.usage()}\n`);
         return 2;
       }
-      if (['list', 'ls'].includes(command)) {
-        if (args.length) { process.stderr.write('list accepts only --json; optionally put a harness before list.\n'); return 2; }
-        return await this.commandList(harness ? [harness] : [...this.harnesses.values()], json);
+      if (OVERVIEW_COMMANDS.includes(command)) {
+        if (args.length) { process.stderr.write(`${command} accepts only --json; optionally put a harness before ${command}.\n`); return 2; }
+        const harnesses = harness ? [harness] : [...this.harnesses.values()];
+        return command === 'limits' || command === 'active'
+          ? await this.commandCondensed(command, harnesses, json)
+          : await this.commandList(harnesses, json);
       }
       if (!harness) {
         harness = await this.selectHarness();
@@ -426,6 +434,19 @@ ${bold('Environment')}
     return outcomeArg.problems.length === 0 ? 0 : 1;
   }
 
+  /**
+   * The condensed views are projections of the same read-only account list, so a provider is queried
+   * once, per account, with the same bounded timeouts and per-account failure isolation as `list`.
+   */
+  private async commandCondensed(commandArg: 'limits' | 'active', harnessesArg: IAuthHarness[], jsonArg: boolean): Promise<number> {
+    const list = await readAccountList(harnessesArg);
+    const document = commandArg === 'limits' ? accountLimits(list) : activeAccounts(list);
+    if (jsonArg) process.stdout.write(`${JSON.stringify(document, null, 2)}\n`);
+    else if ('limits' in document) await new CondensedRenderer(this.out).renderLimits(document);
+    else await new CondensedRenderer(this.out).renderActive(document);
+    return document.complete ? 0 : 1;
+  }
+
   private async commandList(harnessesArg: IAuthHarness[], jsonArg = false): Promise<number> {
     const list = await readAccountList(harnessesArg);
     if (jsonArg) process.stdout.write(`${JSON.stringify(list, null, 2)}\n`);

package/ts/classes.credentialstore.ts

@@ -8,8 +8,8 @@ export const credentialRecord = (value: unknown): Record<string, unknown> => {
 export const credentialText = (value: unknown): string | undefined => typeof value === 'string' && value.length > 0 ? value : undefined;
 export const credentialHash = (value: string): string => plugins.crypto.createHash('sha256').update(value).digest('hex');
 
-/** A bounded file read; malformed secrets never become parser diagnostics in the CLI. */
-export const readCredentialDocument = (file: string): { raw: string | null; data: Record<string, unknown> } => {
+/** A bounded raw read. Callers that only compare bytes must not have to parse a file another process owns. */
+export const readCredentialRaw = (file: string): string | null => {
   let fd: number | undefined;
   try {
     fd = plugins.fs.openSync(file, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NONBLOCK);
@@ -23,14 +23,21 @@ export const readCredentialDocument = (file: string): { raw: string | null; data
       size += count;
     }
     if (size === buffer.length) throw new Error();
-    const raw = buffer.subarray(0, size).toString('utf8');
-    return { raw, data: credentialRecord(JSON.parse(raw)) };
+    return buffer.subarray(0, size).toString('utf8');
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { raw: null, data: {} };
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
     throw new Error('Credential file is unreadable, malformed, or too large; no changes were made.');
   } finally { if (fd !== undefined) plugins.fs.closeSync(fd); }
 };
 
+/** A bounded file read; malformed secrets never become parser diagnostics in the CLI. */
+export const readCredentialDocument = (file: string): { raw: string | null; data: Record<string, unknown> } => {
+  const raw = readCredentialRaw(file);
+  if (raw === null) return { raw: null, data: {} };
+  try { return { raw, data: credentialRecord(JSON.parse(raw)) }; }
+  catch { throw new Error('Credential file is unreadable, malformed, or too large; no changes were made.'); }
+};
+
 export interface IStoredCredential {
   schemaVersion: 1;
   id: string;
@@ -87,7 +94,12 @@ export class CredentialStore {
   }
 }
 
-/** Native harnesses retain credentials and may refresh them. Refuse writes while one is running. */
+/**
+ * Native harnesses hold their login in memory and rewrite it on their own refresh schedule, so a
+ * credential written underneath a running one is destroyed by the next refresh. Operations that
+ * replace a native login therefore require it stopped. Reading for a save that keeps the login in
+ * place writes nothing native and is guarded by content stability instead (see FileHarness).
+ */
 export const requireHarnessStopped = (binary: 'opencode' | 'claude'): void => {
   let names: string[];
   try {
@@ -97,5 +109,5 @@ export const requireHarnessStopped = (binary: 'opencode' | 'claude'): void => {
       names = plugins.childProcess.execFileSync('ps', ['-u', String(process.getuid!()), '-o', 'comm='], { encoding: 'utf8', timeout: 5000 }).split('\n').map(line => plugins.path.basename(line.trim()));
     }
   } catch { throw new Error(`Could not verify that ${binary} is stopped. No login was changed.`); }
-  if (names.some(name => name === binary || name === `${binary}.exe`)) throw new Error(`Exit running ${binary} processes before saving or switching credentials, then start ${binary} again.`);
+  if (names.some(name => name === binary || name === `${binary}.exe`)) throw new Error(`Exit running ${binary} processes before replacing or clearing its login, then start ${binary} again. Saving with --keep does not need this.`);
 };

package/ts/classes.fileharness.ts

@@ -1,5 +1,6 @@
 import type { IAuthHarness, IHarnessAccountStatus, IHarnessOutcome, IHarnessState } from './interfaces.harness.js';
 import { CredentialStore, type IStoredCredential } from './classes.credentialstore.js';
+import { pauseSynchronously } from './helpers.js';
 import { plainText } from './formatting.js';
 
 export interface IFileAccount {
@@ -22,10 +23,38 @@ export abstract class FileHarness implements IAuthHarness {
   protected abstract readonly store: CredentialStore;
   protected abstract snapshot(): IFileHarnessSnapshot;
   protected abstract apply(slotId: string, previous: IFileAccount | undefined, target: IFileAccount | undefined): void;
+  /** Guards the operations that write a native credential file. Reads must not depend on it. */
   protected abstract beforeMutation(): void;
+  /** 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>;
 
+  /**
+   * A snapshot proven not to have been taken across a native write.
+   *
+   * Saving a login without replacing it writes no native file, so it must not require the harness
+   * to be stopped. A running harness does rotate its tokens on its own schedule, and its fallback
+   * writer truncates the file in place, so reading the same sources before and after the snapshot
+   * and requiring identical bytes is what keeps a torn or half-rotated credential out of the stash.
+   * Both the retry count and the pause between attempts are bounded; an unstable file is reported,
+   * never guessed at.
+   */
+  private stableSnapshot(): IFileHarnessSnapshot {
+    let failure: unknown;
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (attempt) pauseSynchronously(20);
+      try {
+        const before = JSON.stringify(this.nativeSources());
+        const snapshot = this.snapshot();
+        if (JSON.stringify(this.nativeSources()) === before) return snapshot;
+        failure = undefined;
+      } catch (error) { failure = error; }
+    }
+    if (failure) throw failure;
+    throw new Error(`${this.label} kept rewriting its credential files while they were being read; nothing was saved. Try again in a moment.`);
+  }
+
   private saved(entry: IStoredCredential): IFileAccount {
     const account = this.inspect(entry.credential, entry.slotId);
     if (account.identity !== entry.identity) throw new Error('Saved credential does not match its account identity.');
@@ -83,8 +112,9 @@ export abstract class FileHarness implements IAuthHarness {
   }
   public saveCurrent(options: { keepActive: boolean; accountId?: string }): IHarnessOutcome {
     return this.outcome(() => {
-      this.beforeMutation();
-      const snapshot = this.snapshot();
+      // Keeping the login in place only reads the native files, so a running harness is no reason to refuse.
+      if (!options.keepActive) this.beforeMutation();
+      const snapshot = this.stableSnapshot();
       if (snapshot.unavailable) throw new Error(snapshot.unavailable);
       const matches = snapshot.accounts.filter(account => !options.accountId || this.store.id(account.slotId, account.identity) === options.accountId || account.slotId === options.accountId || account.label === options.accountId);
       if (matches.length !== 1) throw new Error(matches.length ? 'Several logins are active. Select the account or provider to save.' : 'No matching active login to save.');

package/ts/classes.limits.ts

@@ -0,0 +1,187 @@
+import * as plugins from './plugins.js';
+import { compactSince, compactUntil, orderedUsageWindows } from './accounts.js';
+import { consoleHeading, consoleTable } from './classes.accountlist.js';
+import type { IAccountList, IAccountLimitRow, IAccountLimits, IActiveAccountRow, IActiveAccounts, IHarnessAccountList } from './interfaces.list.js';
+import { dim, plainText } from './formatting.js';
+
+type TListedAccount = IHarnessAccountList['accounts'][number];
+
+const UNAVAILABLE = 'n/a';
+const NONE = 'none';
+
+/**
+ * Provider naming stays data-driven.
+ *
+ * A harness that owns exactly one credential slot is its own provider; one that owns several (an
+ * OpenCode installation with an OpenAI and an Anthropic login) has to say which slot a row is about.
+ */
+const providerName = (harnessArg: IHarnessAccountList, accountArg?: TListedAccount): string => {
+  const slots = new Set(harnessArg.accounts.map(account => account.slotId).filter((slot): slot is string => slot !== undefined));
+  return accountArg?.slotId !== undefined && slots.size > 1
+    ? `${plainText(harnessArg.label)} / ${plainText(accountArg.slotId)}`
+    : plainText(harnessArg.label);
+};
+
+/**
+ * Why an account contributes no numbers.
+ *
+ * The provider's own explanation is preferred over ours, and a failed lookup is never presented as a
+ * missing capability: the two have different fixes.
+ */
+const missingLimitReason = (accountArg: TListedAccount): string => {
+  if (accountArg.status.problems.length) return accountArg.status.problems.map(plainText).join(' ');
+  const availability = accountArg.status.facts.filter(fact => fact.section === 'Availability').map(fact => plainText(fact.value));
+  if (accountArg.status.summary?.usageWindows === undefined) {
+    return availability[0] ?? 'This login does not expose a usage or quota API.';
+  }
+  return 'The provider reported no usage window for this account.';
+};
+
+const accountKeys = (harnessArg: IHarnessAccountList, accountArg: TListedAccount) => ({
+  harnessId: harnessArg.id,
+  provider: providerName(harnessArg, accountArg),
+  account: plainText(accountArg.label),
+  accountId: accountArg.id,
+  ...(accountArg.slotId === undefined ? {} : { slotId: plainText(accountArg.slotId) }),
+});
+
+const harnessProblem = (harnessArg: IHarnessAccountList): string | null =>
+  harnessArg.problems.length ? harnessArg.problems.map(plainText).join(' ') : null;
+
+/** Provider then account, keeping each account's windows in the order the adapter ranked them. */
+const byProviderThenAccount = <TRow extends { provider: string; account: string | null }>(rowsArg: TRow[]): TRow[] =>
+  [...rowsArg].sort((left, right) => left.provider.localeCompare(right.provider)
+    || (left.account ?? '').localeCompare(right.account ?? ''));
+
+const noteFor = (rowArg: { provider: string; account: string | null; unavailableReason: string | null }): string | null =>
+  rowArg.unavailableReason === null ? null
+    : `${rowArg.provider}${rowArg.account === null ? '' : ` · ${rowArg.account}`}: ${rowArg.unavailableReason}`;
+
+const collectNotes = (rowsArg: { provider: string; account: string | null; unavailableReason: string | null }[]): string[] =>
+  [...new Set(rowsArg.map(noteFor).filter((note): note is string => note !== null))];
+
+/**
+ * One row per account and limit type, projected from the account list.
+ *
+ * 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.
+ */
+export const accountLimits = (listArg: IAccountList): IAccountLimits => {
+  const now = Date.parse(listArg.generatedAt);
+  const rows: IAccountLimitRow[] = [];
+  for (const harness of listArg.harnesses) {
+    const problem = harnessProblem(harness);
+    const empty = {
+      limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE,
+    } as const;
+    if (problem !== null) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty, unavailableReason: problem });
+      continue;
+    }
+    if (!harness.accounts.length) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, isActive: false, ...empty,
+        unavailableReason: harness.saveUnavailableReason === null ? 'No accounts are known for this harness.' : plainText(harness.saveUnavailableReason) });
+      continue;
+    }
+    for (const account of harness.accounts) {
+      const windows = orderedUsageWindows(account.status.summary?.usageWindows);
+      if (!windows.length) {
+        rows.push({ ...accountKeys(harness, account), isActive: account.isActive, ...empty, unavailableReason: missingLimitReason(account) });
+        continue;
+      }
+      for (const window of windows) {
+        rows.push({
+          ...accountKeys(harness, account), isActive: account.isActive,
+          limitType: plainText(window.label), scope: window.scope ?? 'account', windowSeconds: window.durationSeconds,
+          usedPercent: window.usedPercent, resetAt: window.resetAt, resetsIn: compactUntil(window.resetAt, now, UNAVAILABLE),
+          unavailableReason: null,
+        });
+      }
+    }
+  }
+  const limits = byProviderThenAccount(rows);
+  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, limits, notes: collectNotes(limits) };
+};
+
+/**
+ * One row per active credential slot.
+ *
+ * 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 => {
+  const now = Date.parse(listArg.generatedAt);
+  const rows: IActiveAccountRow[] = [];
+  for (const harness of listArg.harnesses) {
+    const problem = harnessProblem(harness);
+    if (problem !== null) {
+      rows.push({ harnessId: harness.id, provider: providerName(harness), account: null, accountId: null, savedAt: null, savedAgo: UNAVAILABLE, source: 'none', unavailableReason: problem });
+      continue;
+    }
+    const active = harness.accounts.filter(account => account.isActive);
+    if (!active.length) {
+      const stashed = harness.accounts.filter(account => account.isStashed);
+      rows.push({
+        harnessId: harness.id, provider: providerName(harness), account: null, accountId: null,
+        savedAt: null, savedAgo: UNAVAILABLE, source: stashed.length ? 'stash only' : 'none',
+        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)}`,
+      });
+      continue;
+    }
+    for (const account of active) {
+      rows.push({
+        ...accountKeys(harness, account),
+        savedAt: account.savedAt, savedAgo: compactSince(account.savedAt, now, UNAVAILABLE),
+        source: 'credential file',
+        unavailableReason: account.isStashed ? null : 'This active login is not saved yet; authswitch cannot restore it after a switch.',
+      });
+    }
+  }
+  const active = byProviderThenAccount(rows);
+  return { schemaVersion: 1, generatedAt: listArg.generatedAt, complete: listArg.complete, active, notes: collectNotes(active) };
+};
+
+const percent = (rowArg: IAccountLimitRow): string => rowArg.usedPercent === null ? UNAVAILABLE : `${rowArg.usedPercent}%`;
+
+/** Condensed presentation for `authswitch limits` and `authswitch active`. */
+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`);
+  }
+
+  public async renderLimits(limitsArg: IAccountLimits): Promise<void> {
+    consoleHeading('Account limits');
+    if (!limitsArg.limits.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await consoleTable(this.out, limitsArg.limits, [
+      { key: 'provider', title: 'Provider', value: row => row.provider },
+      { key: 'account', title: 'Account', value: row => row.account ?? UNAVAILABLE, style: row => ({ bold: row.isActive }) },
+      { key: 'limit', title: 'Limit type', value: row => row.limitType ?? UNAVAILABLE },
+      { key: 'used', title: 'Used %', value: percent, align: 'right',
+        style: row => ({ foreground: row.usedPercent === null ? 'orange' : row.usedPercent >= 100 ? 'red' : undefined }) },
+      { key: 'reset', title: 'Resets in', value: row => row.resetsIn, align: 'right' },
+    ]);
+    this.notes(limitsArg.notes, 'n/a — ');
+  }
+
+  public async renderActive(activeArg: IActiveAccounts): Promise<void> {
+    consoleHeading('Active accounts');
+    if (!activeArg.active.length) { process.stdout.write(`${dim('No harnesses registered.')}\n`); return; }
+    await consoleTable(this.out, activeArg.active, [
+      { key: 'provider', title: 'Provider', value: row => row.provider },
+      { key: 'account', title: 'Account', value: row => row.account ?? NONE,
+        style: row => ({ bold: row.account !== null, foreground: row.account === null ? 'orange' : undefined }) },
+      // The absolute timestamp stays in --json; one screen is worth more here than one more column.
+      { key: 'saved', title: 'Saved', value: row => row.savedAt === null ? (row.account === null ? UNAVAILABLE : 'not saved') : `${row.savedAgo} ago`, align: 'right',
+        style: row => ({ foreground: row.savedAt === null && row.account !== null ? 'orange' : undefined }) },
+      { key: 'source', title: 'Source', value: row => row.source,
+        style: row => ({ foreground: row.source === 'credential file' ? 'green' : 'orange' }) },
+    ]);
+    this.notes(activeArg.notes, 'note — ');
+  }
+}

package/ts/classes.opencodeharness.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 import { FileHarness, type IFileAccount, type IFileHarnessSnapshot } from './classes.fileharness.js';
-import { CredentialStore, credentialHash, credentialRecord, credentialText, readCredentialDocument, requireHarnessStopped } from './classes.credentialstore.js';
+import { CredentialStore, credentialHash, credentialRecord, credentialText, readCredentialDocument, readCredentialRaw, requireHarnessStopped } from './classes.credentialstore.js';
 import { CodexAccountStatus } from './classes.codexstatus.js';
 import { writeSecretFileAtomically } from './helpers.js';
 import type { IHarnessAccountStatus, IHarnessLoginOptions, IHarnessLoginProvider } from './interfaces.harness.js';
@@ -39,6 +39,8 @@ export class OpenCodeHarness extends FileHarness {
     this.checkStopped = options.checkStopped ?? (() => requireHarnessStopped('opencode'));
   }
   protected beforeMutation(): void { this.checkStopped(); }
+  /** Every provider entry lives in one file, so its bytes are the whole stability proof. */
+  protected nativeSources(): (string | null)[] { return [readCredentialRaw(this.file)]; }
   /** Public identity only, for reconciling a host's OpenAI association after native refresh/restart. */
   public activeOpenAiAccountId(): string | undefined {
     const account = this.snapshot().accounts.find(item => item.slotId === 'openai');

package/ts/helpers.ts

@@ -53,6 +53,18 @@ export const writeSecretFileAtomically = (
   plugins.fs.chmodSync(destinationPathArg, 0o600);
 };
 
+/**
+ * Blocks the calling thread for `millisecondsArg`.
+ *
+ * Credential reads are synchronous all the way down, so a retry that re-reads
+ * immediately can land inside the very same in-flight write it is retrying past.
+ * `Atomics.wait` on a private buffer is the only synchronous pause Node offers,
+ * and the callers bound both the count and the duration.
+ */
+export const pauseSynchronously = (millisecondsArg: number): void => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, millisecondsArg);
+};
+
 /**
  * Trims third-party process output down to something safe to put in an error
  * message: one line, length-capped, and never empty.

package/ts/interfaces.list.ts

@@ -17,3 +17,58 @@ export interface IHarnessAccountList {
   /** A state lookup failure is distinct from an empty account list. */
   problems: string[];
 }
+
+/** Credential-free, versioned output of limits --json. One entry per account and limit type. */
+export interface IAccountLimits {
+  schemaVersion: 1;
+  generatedAt: string;
+  complete: boolean;
+  limits: IAccountLimitRow[];
+  /** Why a row has no numbers. Never a substitute for a value. */
+  notes: string[];
+}
+
+export interface IAccountLimitRow {
+  harnessId: string;
+  /** Harness label, qualified by the credential slot when the harness owns several. */
+  provider: string;
+  /** The account's public label, which is its email wherever the provider reports one. */
+  account: string | null;
+  accountId: string | null;
+  slotId?: string;
+  isActive: boolean;
+  /** The provider's own window name, or null when no limit data is available. */
+  limitType: string | null;
+  scope: 'account' | 'feature' | null;
+  windowSeconds: number | null;
+  /** Never inferred: null means the provider reported no percentage, not zero usage. */
+  usedPercent: number | null;
+  resetAt: string | null;
+  /** Human countdown for the same `resetAt`, relative to `generatedAt`. */
+  resetsIn: string;
+  unavailableReason: string | null;
+}
+
+/** Credential-free, versioned output of active --json. One entry per active credential slot. */
+export interface IActiveAccounts {
+  schemaVersion: 1;
+  generatedAt: string;
+  complete: boolean;
+  active: IActiveAccountRow[];
+  notes: string[];
+}
+
+export interface IActiveAccountRow {
+  harnessId: string;
+  provider: string;
+  account: string | null;
+  accountId: string | null;
+  slotId?: string;
+  /** When authswitch last saved this login; null when it was never stashed. */
+  savedAt: string | null;
+  /** Human elapsed time for the same `savedAt`, relative to `generatedAt`. */
+  savedAgo: string;
+  /** Where the shown account comes from. Whether it is also saved is the `savedAt` field's answer. */
+  source: 'credential file' | 'stash only' | 'none';
+  unavailableReason: string | null;
+}

package/.smartconfig.json

@@ -1,34 +0,0 @@
-{
-  "@git.zone/cli": {
-    "schemaVersion": 2,
-    "projectType": "npm",
-    "module": {
-      "githost": "code.foss.global",
-      "gitscope": "modelprofile.com",
-      "gitrepo": "authswitch",
-      "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
-      "npmPackagename": "@modelprofile.com/authswitch",
-      "license": "MIT",
-      "projectDomain": "modelprofile.com"
-    },
-    "release": {
-      "targets": {
-        "git": {
-          "enabled": true,
-          "remote": "origin",
-          "pushBranch": true,
-          "pushTags": true
-        },
-        "npm": {
-          "enabled": true,
-          "registries": [
-            "https://verdaccio.lossless.digital",
-            "https://registry.npmjs.org"
-          ],
-          "accessLevel": "public",
-          "alreadyPublished": "success"
-        }
-      }
-    }
-  }
-}