@modelprofile.com/authswitch 2.2.0 → 2.3.0

package/dist_ts/classes.limits.js

@@ -0,0 +1,178 @@
+import * as plugins from './plugins.js';
+import { compactSince, compactUntil, orderedUsageWindows } from './accounts.js';
+import { consoleHeading, consoleTable } from './classes.accountlist.js';
+import { dim, plainText } from './formatting.js';
+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, accountArg) => {
+    const slots = new Set(harnessArg.accounts.map(account => account.slotId).filter((slot) => 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) => {
+    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, accountArg) => ({
+    harnessId: harnessArg.id,
+    provider: providerName(harnessArg, accountArg),
+    account: plainText(accountArg.label),
+    accountId: accountArg.id,
+    ...(accountArg.slotId === undefined ? {} : { slotId: plainText(accountArg.slotId) }),
+});
+const harnessProblem = (harnessArg) => 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 = (rowsArg) => [...rowsArg].sort((left, right) => left.provider.localeCompare(right.provider)
+    || (left.account ?? '').localeCompare(right.account ?? ''));
+const noteFor = (rowArg) => rowArg.unavailableReason === null ? null
+    : `${rowArg.provider}${rowArg.account === null ? '' : ` · ${rowArg.account}`}: ${rowArg.unavailableReason}`;
+const collectNotes = (rowsArg) => [...new Set(rowsArg.map(noteFor).filter((note) => 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) => {
+    const now = Date.parse(listArg.generatedAt);
+    const rows = [];
+    for (const harness of listArg.harnesses) {
+        const problem = harnessProblem(harness);
+        const empty = {
+            limitType: null, scope: null, windowSeconds: null, usedPercent: null, resetAt: null, resetsIn: UNAVAILABLE,
+        };
+        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) => {
+    const now = Date.parse(listArg.generatedAt);
+    const rows = [];
+    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) => rowArg.usedPercent === null ? UNAVAILABLE : `${rowArg.usedPercent}%`;
+/** Condensed presentation for `authswitch limits` and `authswitch active`. */
+export class CondensedRenderer {
+    out;
+    constructor(out) {
+        this.out = out;
+    }
+    notes(notesArg, prefixArg) {
+        if (!notesArg.length)
+            return;
+        process.stdout.write('\n');
+        for (const note of notesArg)
+            process.stdout.write(`${dim(`${prefixArg}${note}`)}\n`);
+    }
+    async renderLimits(limitsArg) {
+        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 — ');
+    }
+    async renderActive(activeArg) {
+        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 — ');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.limits.js","sourceRoot":"","sources":["../ts/classes.limits.ts"],"names":[],"mappings":"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"}

package/dist_ts/interfaces.list.d.ts

@@ -17,3 +17,54 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@git.zone/tsbuild": "^4.4.3",
     "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^6.0.0",
+    "@git.zone/tstest": "^6.1.1",
     "@types/node": "26.5.0"
   },
   "dependencies": {

package/readme.md

@@ -16,11 +16,7 @@ Remote control makes that worse. A ChatGPT client pairs with the local Codex app
 
 ## Install
 
-This package is published to the private Verdaccio registry, not to npmjs, so the scope has to be mapped first:
-
-```bash
-pnpm config set @modelprofile.com:registry https://verdaccio.lossless.digital
-```
+The package is published to npmjs:
 
 ```bash
 pnpm install -g @modelprofile.com/authswitch
@@ -57,6 +53,8 @@ authswitch --tui                  # full-screen account management
 authswitch codex --tui            # start the dashboard on Codex
 authswitch list                   # all known accounts across registered harnesses, with live status
 authswitch list --json            # complete account/status document for scripts
+authswitch limits                 # every account and limit type: used % and reset countdown
+authswitch active                 # which account each provider is using right now
 authswitch codex stash            # save the active credential under its account email
 authswitch codex list             # Codex accounts, including an unsaved active login, with live status
 authswitch codex use [email]      # activate one; prompts when no email is given
@@ -310,12 +308,87 @@ 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.
 
+### 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 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 │
+└──────────────────────┴─────────────────────────┴───────────────────────┴────────┴───────────────┘
+
+n/a — Codex · bob@example.com: Subscription and limits: Login expired or was rejected.
+n/a — OpenCode / anthropic · anthropic API key 20e751c3b707: This provider login does not expose a supported subscription or quota API.
+```
+
+A number is never invented. An account whose provider exposes no quota API, whose
+lookup failed, or whose login cannot be read shows `n/a` in **Used %** and
+**Resets in**, and the footnote under the table says why — one line per distinct
+reason. A provider is never dropped from the table for lacking data, and one failed
+account never blanks another's numbers. `not scheduled` means the provider reported
+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
+the credential slot when a harness owns several (`OpenCode / openai`).
+
+`authswitch active` answers "what am I logged in as" for every harness at once:
+
+```
+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 │
+└──────────────────────┴────────────────────────────────┴────────────┴─────────────────┘
+
+note — OpenCode / openai · alice@example.com: This active login is not saved yet; authswitch cannot restore it after a switch.
+```
+
+**Source** is where the shown login comes from: `credential file` is the harness's
+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.
+
+Both commands accept a harness qualifier (`authswitch claude limits`) and `--json`.
+Both are read-only: they never activate, save or clear a login, they need no harness
+stopped, and every provider lookup is bounded by the same 10-second timeout and
+isolated per account as `authswitch list`.
+
 ### JSON output
 
 `authswitch list --json`, `authswitch codex list --json`, and the `ls` alias write
 one JSON document to stdout, with no color, tables or progress messages. `--json`
-may appear before or after the command and requires `list` or `ls`. It cannot be
-combined with a mutation or interactive mode. Unknown list arguments exit with 2.
+may appear before or after the command and requires `list`, `ls`, `limits` or
+`active`. It cannot be combined with a mutation or interactive mode. Unknown
+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`, and the per-row
+`unavailableReason` that the footnotes summarise. Both carry `schemaVersion: 1`, the
+shared `generatedAt` snapshot every countdown is relative to, and `complete`, which
+is false when any account or harness could not be read.
 
 The exported `IAccountList` contract contains:
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '2.2.0',
+  version: '2.3.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/accounts.ts

@@ -19,6 +19,35 @@ export const until = (timestampArg: string | null, nowArg: number): string => {
   const hours = Math.floor(minutes % 1440 / 60);
   return [days ? `${days}d` : '', hours ? `${hours}h` : '', minutes % 60 ? `${minutes % 60}min` : ''].filter(Boolean).join(' ');
 };
+/**
+ * A two-unit countdown for condensed tables: `2h 13m`, `3d 4h`, `45m`.
+ *
+ * `until` stays the long form used by the list view and the TUI. This one trades the third unit for
+ * a column that never wraps, and it never invents a deadline: an unknown or unparseable timestamp is
+ * reported as such rather than as zero time remaining.
+ */
+const twoUnits = (millisecondsArg: number): string => {
+  const minutes = Math.floor(millisecondsArg / 60000);
+  const days = Math.floor(minutes / 1440);
+  const hours = Math.floor(minutes % 1440 / 60);
+  if (days) return hours ? `${days}d ${hours}h` : `${days}d`;
+  if (hours) return minutes % 60 ? `${hours}h ${minutes % 60}m` : `${hours}h`;
+  return `${minutes}m`;
+};
+export const compactUntil = (timestampArg: string | null, nowArg: number, unavailableArg = 'n/a'): string => {
+  if (timestampArg === null) return 'not scheduled';
+  const remaining = Date.parse(timestampArg) - nowArg;
+  if (!Number.isFinite(remaining)) return unavailableArg;
+  if (remaining <= 0) return 'due';
+  return remaining < 60000 ? '<1m' : twoUnits(remaining);
+};
+/** The same two-unit form for a past timestamp, for "saved 3d 4h ago". */
+export const compactSince = (timestampArg: string | null, nowArg: number, unavailableArg = 'n/a'): string => {
+  if (timestampArg === null) return unavailableArg;
+  const elapsed = nowArg - Date.parse(timestampArg);
+  if (!Number.isFinite(elapsed)) return unavailableArg;
+  return elapsed < 60000 ? 'just now' : twoUnits(elapsed);
+};
 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';

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.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`);