@modelprofile.com/authswitch 6.1.0 → 6.3.0

package/dist_ts/classes.tui.js

@@ -1,8 +1,13 @@
 import * as plugins from './plugins.js';
 import { accountBadge, accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usageWindowName, until, readAccountRows } from './accounts.js';
+import { defaultPreusePrompt, preuseAccounts, preuseCountsText, preuseTargets } from './preuse.js';
 import { plainText } from './formatting.js';
 import { AuthSwitchOperations, authSwitchMutationReplacesLogin } from './classes.operations.js';
 import { describeHarnessProcesses, describeStopOutcome } from './classes.harnessprocesses.js';
+/** One account's preuse result, as the dashboard's activity log and footer report it. */
+const preuseResultLine = (resultArg) => resultArg.outcome === 'completed'
+    ? `${plainText(resultArg.account.label)}: completed with ${plainText(resultArg.result.model)}, ${resultArg.result.totalTokens ?? 'unreported'} tokens.`
+    : `${plainText(resultArg.account.label)}: ${resultArg.reason}`;
 /** Owns account-management actions; terminal rendering and interaction belong to smartconsole. */
 export class AuthSwitchTui {
     harnesses;
@@ -189,6 +194,43 @@ export class AuthSwitchTui {
             if (showOutcome(outcome))
                 ui.logs.append(`Now active: ${plainText(target.label)}${badge}`);
         };
+        /**
+         * Send one preuse prompt through each of these accounts, after one confirmation that names the cost.
+         *
+         * The prompt consumes the account's own quota, so nothing is sent before consent, the accounts run
+         * one at a time through the shared runner, and the footer follows the run account by account. Closing
+         * the dashboard aborts it before the next account starts. Nothing is switched, saved or written.
+         */
+        const preuse = async (screen, accountsArg) => {
+            if (!harness.preuseAccount) {
+                footer.setText(`${plainText(harness.label)} does not support preuse.`);
+                return;
+            }
+            if (!accountsArg.length) {
+                footer.setText('Select an account to preuse.');
+                return;
+            }
+            const message = accountsArg.length === 1
+                ? `Send one preuse prompt through ${plainText(accountsArg[0].label)}? This consumes its quota.`
+                : `Send one preuse prompt through each of these ${accountsArg.length} ${plainText(harness.label)} accounts? This consumes quota on every one of them.`;
+            if (!await screen.confirm(message, { confirmLabel: 'Preuse' }))
+                return;
+            if (screen.signal.aborted)
+                return;
+            const summary = await preuseAccounts(harness, accountsArg, { prompt: defaultPreusePrompt, signal: screen.signal }, event => {
+                if (event.kind === 'started')
+                    footer.setText(`Preusing ${plainText(event.account.label)} (${event.index + 1}/${event.total})…`);
+                else {
+                    const line = preuseResultLine(event.result);
+                    ui.logs.append(line);
+                    footer.setText(line);
+                }
+                void screen.invalidate();
+            });
+            // The prompts moved usage and reset deadlines, so the table is read again before the counts are shown.
+            await refresh(screen);
+            footer.setText(`Preuse: ${preuseCountsText(summary)}.`);
+        };
         const remove = async (screen) => {
             const selected = table.selected;
             if (!selected || (!selected.account.isStashed && selected.account.savedAt === null)) {
@@ -226,7 +268,7 @@ export class AuthSwitchTui {
                 return ui.column([
                     ui.text('authswitch · account management', { height: 1 }),
                     this.harnesses.length > 1 ? ui.row([ui.panel('Harnesses', harnessTable, { width: 23 }), accountView]) : accountView,
-                    ui.text('Enter switch · a save · c save+clear · d remove · r refresh · g diagnose · Tab focus · q quit', { height: 2 }),
+                    ui.text(`Enter switch · a save · c save+clear · d remove${harness.preuseAccount ? ' · p preuse · P preuse all' : ''} · r refresh · g diagnose · Tab focus · q quit`, { height: 2 }),
                     footer,
                 ]);
             },
@@ -237,10 +279,17 @@ export class AuthSwitchTui {
                 a: screen => perform(screen, () => save(screen, true)),
                 c: screen => perform(screen, () => save(screen, false)),
                 d: screen => perform(screen, () => remove(screen)),
+                // The key map is fixed for the session while the harness selector can change the harness, so both
+                // preuse keys are always bound and the action itself reports a harness that does not support it.
+                p: screen => perform(screen, async () => {
+                    const selected = table.selected?.account.id;
+                    await preuse(screen, preuseTargets((await harness.readState()).accounts).filter(account => account.id === selected));
+                }),
+                P: screen => perform(screen, async () => { await preuse(screen, preuseTargets((await harness.readState()).accounts)); }),
                 g: screen => perform(screen, async () => { showOutcome(await harness.diagnose()); }),
             },
         });
         return 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}

package/dist_ts/preuse.d.ts

@@ -1,6 +1,93 @@
-import type { IHarnessPreuseOptions } from './interfaces.harness.js';
+import type { IAuthHarness, IHarnessAccount, IHarnessPreuseOptions, IHarnessPreuseResult, IHarnessUsageWindow } from './interfaces.harness.js';
 export declare const defaultPreusePrompt = "Write 2000 words about strawberries.";
-/** Only fixed local messages may cross the inference error boundary. */
+/**
+ * Only fixed local messages may cross the inference error boundary.
+ *
+ * `requestStarted` says whether the prompt may already have reached the provider. False is a refusal that
+ * sent nothing -- an unsupported login, a missing credential, a model catalog that could not be read before
+ * the prompt -- so the account's quota is untouched. True, and any error that is not a `PreuseError` at all,
+ * means tokens may have been consumed, and such a request is never repeated automatically.
+ */
 export declare class PreuseError extends Error {
+    readonly requestStarted: boolean;
+    constructor(messageArg: string, requestStarted?: boolean);
 }
 export declare const validatePreuseOptions: (optionsArg: IHarnessPreuseOptions) => void;
+/**
+ * What one account's turn in a run did.
+ *
+ * `skipped` is a refusal that sent nothing and consumed nothing, with the reason the adapter stated.
+ * `failed` and `interrupted` may both have consumed tokens, so neither is ever retried by the runner.
+ */
+export type TPreuseOutcome = 'completed' | 'skipped' | 'failed' | 'interrupted';
+/**
+ * The reset schedule read after a prompt completed.
+ *
+ * `reported` carries what the provider answered, which may be no window at all; `unavailable` is a lookup
+ * that failed, and `notRead` is a run the user interrupted before it asked. None of them says anything
+ * about the completed prompt, which is never repeated because its schedule could not be confirmed.
+ */
+export type TPreuseSchedule = {
+    kind: 'reported';
+    windows: readonly IHarnessUsageWindow[];
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'notRead';
+};
+export type TPreuseAccountResult = {
+    account: IHarnessAccount;
+    outcome: 'completed';
+    result: IHarnessPreuseResult;
+    schedule: TPreuseSchedule;
+} | {
+    account: IHarnessAccount;
+    outcome: Exclude<TPreuseOutcome, 'completed'>;
+    reason: string;
+};
+/** One account starting, and that account's result. A run reports nothing else, and never the generated prose. */
+export type TPreuseRunEvent = {
+    kind: 'started';
+    index: number;
+    total: number;
+    account: IHarnessAccount;
+} | {
+    kind: 'finished';
+    index: number;
+    total: number;
+    result: TPreuseAccountResult;
+};
+export interface IPreuseRunSummary {
+    results: readonly TPreuseAccountResult[];
+    counts: Readonly<Record<TPreuseOutcome, number>>;
+    /** Accounts an abort kept the run from reaching. Nothing was sent for them. */
+    notRun: readonly IHarnessAccount[];
+}
+/**
+ * Every account a run may preuse, in the order the harness lists them, each at most once.
+ *
+ * A harness reports an active login and that login's saved record as one account -- Codex keys both by
+ * email, the file harness merges the active login into its saved record by account id -- so the walk is
+ * the account list itself. The seen set keeps a repeated id from being charged twice regardless.
+ */
+export declare const preuseTargets: (accountsArg: readonly IHarnessAccount[]) => IHarnessAccount[];
+/**
+ * A run's counts in one line, for a command's closing line and for the dashboard footer.
+ *
+ * Completed accounts are always named, including none of them; every other count appears only when it
+ * happened, so a clean run reads as one fact rather than as four.
+ */
+export declare const preuseCountsText: (summaryArg: IPreuseRunSummary) => string;
+/**
+ * Send one preuse prompt through each account in turn, and report what each one did.
+ *
+ * Accounts run strictly one after another, each with exactly one inference request and no retry, because
+ * every request costs the account's own quota. An aborted signal stops the run before the next account
+ * starts, and an account already in flight is reported as interrupted: its tokens may be gone either way,
+ * which is why nothing is repeated. Nothing is switched, refreshed, stopped or written anywhere.
+ */
+export declare const preuseAccounts: (harnessArg: IAuthHarness, accountsArg: readonly IHarnessAccount[], optionsArg: {
+    prompt: string;
+    model?: string;
+    signal: AbortSignal;
+}, reportArg: (eventArg: TPreuseRunEvent) => void) => Promise<IPreuseRunSummary>;

package/dist_ts/preuse.js

@@ -1,6 +1,19 @@
+import { orderedUsageWindows } from './accounts.js';
 export const defaultPreusePrompt = 'Write 2000 words about strawberries.';
-/** Only fixed local messages may cross the inference error boundary. */
+/**
+ * Only fixed local messages may cross the inference error boundary.
+ *
+ * `requestStarted` says whether the prompt may already have reached the provider. False is a refusal that
+ * sent nothing -- an unsupported login, a missing credential, a model catalog that could not be read before
+ * the prompt -- so the account's quota is untouched. True, and any error that is not a `PreuseError` at all,
+ * means tokens may have been consumed, and such a request is never repeated automatically.
+ */
 export class PreuseError extends Error {
+    requestStarted;
+    constructor(messageArg, requestStarted = false) {
+        super(messageArg);
+        this.requestStarted = requestStarted;
+    }
 }
 export const validatePreuseOptions = (optionsArg) => {
     if (typeof optionsArg.prompt !== 'string' || !optionsArg.prompt.trim() || Buffer.byteLength(optionsArg.prompt, 'utf8') > 16_384) {
@@ -10,4 +23,96 @@ export const validatePreuseOptions = (optionsArg) => {
         throw new PreuseError('The preuse model must be a valid model identifier of at most 128 characters.');
     }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldXNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcHJldXNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLHNDQUFzQyxDQUFDO0FBRTFFLHdFQUF3RTtBQUN4RSxNQUFNLE9BQU8sV0FBWSxTQUFRLEtBQUs7Q0FBRztBQUV6QyxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxDQUFDLFVBQWlDLEVBQVEsRUFBRTtJQUMvRSxJQUFJLE9BQU8sVUFBVSxDQUFDLE1BQU0sS0FBSyxRQUFRLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxJQUFJLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsR0FBRyxNQUFNLEVBQUUsQ0FBQztRQUNoSSxNQUFNLElBQUksV0FBVyxDQUFDLGlFQUFpRSxDQUFDLENBQUM7SUFDM0YsQ0FBQztJQUNELElBQUksVUFBVSxDQUFDLEtBQUssS0FBSyxTQUFTLElBQUksQ0FBQyxPQUFPLFVBQVUsQ0FBQyxLQUFLLEtBQUssUUFBUSxJQUFJLENBQUMsc0NBQXNDLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDL0ksTUFBTSxJQUFJLFdBQVcsQ0FBQyw4RUFBOEUsQ0FBQyxDQUFDO0lBQ3hHLENBQUM7QUFDSCxDQUFDLENBQUMifQ==
+/**
+ * Every account a run may preuse, in the order the harness lists them, each at most once.
+ *
+ * A harness reports an active login and that login's saved record as one account -- Codex keys both by
+ * email, the file harness merges the active login into its saved record by account id -- so the walk is
+ * the account list itself. The seen set keeps a repeated id from being charged twice regardless.
+ */
+export const preuseTargets = (accountsArg) => {
+    const seen = new Set();
+    const targets = [];
+    for (const account of accountsArg) {
+        if (seen.has(account.id))
+            continue;
+        seen.add(account.id);
+        targets.push(account);
+    }
+    return targets;
+};
+/**
+ * A run's counts in one line, for a command's closing line and for the dashboard footer.
+ *
+ * Completed accounts are always named, including none of them; every other count appears only when it
+ * happened, so a clean run reads as one fact rather than as four.
+ */
+export const preuseCountsText = (summaryArg) => [
+    `${summaryArg.counts.completed} completed`,
+    ...(summaryArg.counts.skipped ? [`${summaryArg.counts.skipped} skipped`] : []),
+    ...(summaryArg.counts.failed ? [`${summaryArg.counts.failed} failed`] : []),
+    ...(summaryArg.counts.interrupted ? [`${summaryArg.counts.interrupted} interrupted`] : []),
+    ...(summaryArg.notRun.length ? [`${summaryArg.notRun.length} not run`] : []),
+].join(', ');
+/** An adapter's own fixed message, or the fixed local text for an error that crossed the boundary unnamed. */
+const preuseReason = (errorArg) => errorArg instanceof PreuseError
+    ? errorArg.message
+    : 'Preuse failed. Tokens may already have been consumed; check account status before trying again.';
+/**
+ * The account's reset schedule, read after its prompt completed, exactly as the single-account command reads it.
+ *
+ * The read never activates or writes a login, and its failure never turns a completed prompt into a failed
+ * one: there is nothing to undo and nothing worth repeating. An interrupted run does not ask at all.
+ */
+const readPreuseSchedule = async (harnessArg, accountArg, signalArg) => {
+    if (signalArg.aborted)
+        return { kind: 'notRead' };
+    try {
+        const status = await harnessArg.readAccountStatus(accountArg.id, { signal: signalArg });
+        return { kind: 'reported', windows: orderedUsageWindows(status.summary?.usageWindows) };
+    }
+    catch {
+        return { kind: 'unavailable' };
+    }
+};
+/**
+ * Send one preuse prompt through each account in turn, and report what each one did.
+ *
+ * Accounts run strictly one after another, each with exactly one inference request and no retry, because
+ * every request costs the account's own quota. An aborted signal stops the run before the next account
+ * starts, and an account already in flight is reported as interrupted: its tokens may be gone either way,
+ * which is why nothing is repeated. Nothing is switched, refreshed, stopped or written anywhere.
+ */
+export const preuseAccounts = async (harnessArg, accountsArg, optionsArg, reportArg) => {
+    const preuseAccount = harnessArg.preuseAccount?.bind(harnessArg);
+    if (!preuseAccount)
+        throw new PreuseError('This harness does not support preuse.');
+    validatePreuseOptions(optionsArg);
+    const results = [];
+    const counts = { completed: 0, skipped: 0, failed: 0, interrupted: 0 };
+    const notRun = [];
+    const total = accountsArg.length;
+    for (const [index, account] of accountsArg.entries()) {
+        if (optionsArg.signal.aborted) {
+            notRun.push(account);
+            continue;
+        }
+        reportArg({ kind: 'started', index, total, account });
+        let result;
+        try {
+            const completed = await preuseAccount(account.id, { prompt: optionsArg.prompt, model: optionsArg.model, signal: optionsArg.signal });
+            result = { account, outcome: 'completed', result: completed, schedule: await readPreuseSchedule(harnessArg, account, optionsArg.signal) };
+        }
+        catch (error) {
+            // A cancelled account is interrupted whether or not its prompt went out; its reason says which.
+            const outcome = optionsArg.signal.aborted ? 'interrupted'
+                : error instanceof PreuseError && !error.requestStarted ? 'skipped' : 'failed';
+            result = { account, outcome, reason: preuseReason(error) };
+        }
+        results.push(result);
+        counts[result.outcome]++;
+        reportArg({ kind: 'finished', index, total, result });
+    }
+    return { results, counts, notRun };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "6.1.0",
+  "version": "6.3.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",

package/readme.md

@@ -28,14 +28,16 @@ Node.js 24 or newer is required.
 
 Run `authswitch`, `authswitch -i`, or `authswitch --interactive` for an interactive guide. Use the arrow keys and
 Enter to switch accounts, save the current login, list accounts and live status, check remote
-control, or remove a saved account. The guide shows the current account and returns
-to the menu after each successful action; choose **Back** in a submenu or **Exit** to finish.
+control, preuse one or all accounts, or remove a saved account. The guide shows the current
+account and returns to the menu after each successful action; choose **Back** in a submenu or
+**Exit** to finish.
 
 Before showing the actions, the guide checks whether the current credential has a
-matching, readable saved copy. A new or refreshed login gets an offer to save it
-while keeping it active. The switch action checks again before offering targets;
-declining that save cancels the switch. Scripts still preserve the outgoing login
-automatically through the harness adapter.
+readable saved copy of its own account. A login without one gets an offer to save it
+while keeping it active; a login its harness merely refreshed is already saved. The
+switch action checks again before offering targets; declining that save cancels the
+switch. Scripts still preserve the outgoing login automatically through the harness
+adapter.
 
 When saving, choose whether to keep the account active or clear the active login so
 you can run `codex login` for another account. Removing a saved account requires
@@ -61,6 +63,7 @@ authswitch codex use [email]      # activate one; prompts when no email is given
 authswitch opencode use [email] --stop        # stop running OpenCode instances first
 authswitch opencode use [email] --keep-running  # switch without stopping anything
 authswitch codex preuse <email>   # send the default prompt without activating the account
+authswitch codex preuse --all     # the same for every Codex account, one account at a time
 authswitch watch                  # check usage every 2 minutes and switch when an account runs out
 authswitch claude watch --threshold 90 --dry-run  # report what it would switch, for one harness
 authswitch codex current          # print the account currently in use
@@ -302,6 +305,19 @@ saved implicitly; `stash` is what saves a login. An installation whose native lo
 authswitch cannot read mirrors nothing, and a read waits at most a second for a lock a
 switch or Claude Code holds before leaving the saved copy to the next read.
 
+Codex is mirrored the same way, for the same reason: its app-server refreshes the login it
+runs on its own schedule, so the saved copy of that login held older tokens between
+switches -- and, because a saved login used to mean the *exact* credential in
+`~/.codex/auth.json`, an account read as unsaved from its first refresh on and the guide
+offered to save what was already saved. A saved Codex login is now one whose stored
+credential belongs to the account its record names, and reading the accounts writes the
+refreshed credential into that record. Only the saved copy is written: `~/.codex/auth.json`
+is read, no app-server is stopped or signalled for it, and the record keeps its account,
+its remote-control enrollments and its save time. A login with no saved record of its own,
+a record whose credential is missing, and a record that belongs to another Codex account
+with the same email are all left alone; `stash` is what saves or repairs those. A copy that
+could not be written says so beside the account and is tried again on the next read.
+
 An account the service has put **on hold** is not a dead login: the hold refuses the grant
 while it lasts and the same login works again once it is lifted, so such an account keeps
 its stored plan, says that it is on hold and where to appeal, and is asked again on the
@@ -367,12 +383,58 @@ to make the first token-consuming request for the next usage window:
 authswitch codex preuse alice@example.com
 authswitch codex preuse alice@example.com --prompt "Write 2000 words about strawberries."
 authswitch codex preuse alice@example.com --model gpt-5.5 --prompt "Describe a strawberry in one sentence."
+authswitch codex preuse --all
+authswitch codex preuse --all --model gpt-5.5
 ```
 
 The default prompt is `Write 2000 words about strawberries.` Without an account,
-an interactive terminal shows an account picker. Scripts must specify an account
-and, when multiple harnesses are registered, the harness. Active and saved
-accounts are supported, including an active login that has not been stashed.
+an interactive terminal shows a picker of the harness's accounts, plus **All
+accounts** when it has more than one and **Back**. Choosing one account runs it
+exactly as naming it would; choosing **All accounts** confirms once and then runs
+as `--all` does, table and exit status included. Scripts must specify an account
+or `--all` and, when multiple harnesses are registered, the harness. Active and
+saved accounts are supported, including an active login that has not been stashed.
+
+`--all` preuses every account the harness lists, active and saved, each exactly
+once -- an active login and its own saved record are one account -- and it cannot
+be combined with an account reference. The accounts run strictly one after
+another, never in parallel, each with one request and no retry, and each one is
+reported as it goes. The run ends with a table and a counts line:
+
+```
+[1/3] Preusing alice@example.com (Codex)…
+Prompt completed with gpt-5.5. Tokens: 19 input, 2711 output, 2730 total.
+[2/3] Preusing bob@example.com (Codex)…
+Prompt completed with gpt-5.5. Tokens: 19 input, 2711 output, 2730 total.
+[3/3] Preusing apikey:9f2 (Codex)…
+Codex preuse requires a ChatGPT subscription login; API-key logins have no subscription reset window.
+
+Preuse results
+┌────────────────────┬───────────┬─────────┬─────────────────────┬──────────────┐
+│ Account            │ Outcome   │ Model   │ Tokens in/out/total │ Next reset   │
+├────────────────────┼───────────┼─────────┼─────────────────────┼──────────────┤
+│ alice@example.com  │ Completed │ gpt-5.5 │ 19/2711/2730        │ 5d 18h 53min │
+│ bob@example.com    │ Completed │ gpt-5.5 │ 19/2711/2730        │ 5d 18h 53min │
+│ apikey:9f2         │ Skipped   │ -       │ -                   │ -            │
+└────────────────────┴───────────┴─────────┴─────────────────────┴──────────────┘
+2 completed, 1 skipped.
+```
+
+`Next reset` is the lead window of the reset schedule read after that account's
+prompt, the same window the single-account reset table lists first. An account
+that sent no prompt has no model, token count or deadline of its own, and says so
+rather than showing a zero. `Skipped` is a refusal the adapter stated before any
+request -- an API-key login, a missing or expired credential, a model catalog
+that could not be read -- so nothing was consumed for it. `Failed` and
+`Interrupted` may both have consumed tokens and are never retried; `Not run` is
+an account the interruption never reached.
+
+The guide (`authswitch`, `authswitch -i`) offers **Preuse an account or all
+accounts (consumes quota)** for a harness that supports it. It asks which account
+or **All accounts**, confirms once and names what the prompt will be sent to, then
+reports exactly as the command line does: one account's reset schedule, or the
+results table for all of them. **Back** or a declined confirmation sends nothing,
+and an account the adapter refuses returns to the menu rather than ending the guide.
 
 Codex inference uses the published FlexHarness models/providers packages and the
 selected ChatGPT login's access token and account ID. It selects the account's
@@ -381,21 +443,25 @@ low reasoning setting when the catalog provides one. API-key logins are rejected
 because they do not have ChatGPT subscription reset windows. Expired credentials
 must be renewed through Codex and saved again.
 
-Each invocation consumes quota and sends at most one inference request. It does
-not watch for resets or schedule future requests. No active login is switched,
+Each invocation consumes quota and sends one inference request per account. It
+does not watch for resets or schedule future requests. No active login is switched,
 credential refreshed or written, app-server restarted, or earned reset consumed.
 The prompt has no tools, files or conversation history. The generated prose is
 drained without being printed or stored; the command reports provider token
 counts and then reads the account's reset schedule. It does not infer that a
 timer started merely from a zero-percent usage reading or a successful response.
 
-Ctrl-C cancels the request. Codex preuse has a three-minute deadline, with a
-ten-second model-catalog limit. Failed or interrupted requests can have consumed
-tokens and are never retried automatically. A completed prompt exits with 0 even
-if the subsequent reset lookup fails, reporting that uncertainty separately;
-inference failure exits with 1, invalid arguments or unsupported harnesses with
-2, and an interrupted prompt with 130. Check `authswitch list` before repeating
-an uncertain request. `--json` remains a list-only option.
+Ctrl-C cancels the request, and in a `--all` run it stops the run before the next
+account starts. Codex preuse has a three-minute deadline, with a ten-second
+model-catalog limit. Failed or interrupted requests can have consumed tokens and
+are never retried automatically. A completed prompt exits with 0 even if the
+subsequent reset lookup fails, reporting that uncertainty separately; inference
+failure exits with 1, invalid arguments or unsupported harnesses with 2, and an
+interrupted prompt with 130. A named single account also exits 1 when it was
+refused, because it is the account the command was asked to preuse; `--all` exits
+0 when every account either completed or was skipped for a stated reason. Check
+`authswitch list` before repeating an uncertain request. `--json` remains a
+list-only option.
 
 ### Watching usage and switching automatically
 
@@ -478,10 +544,18 @@ incrementally through each account's status API, without activating it.
 | `/`, `s`, `S` | Filter the table, cycle its sort column, reverse sorting |
 | `a` / `c` | Save the current login and keep it active / save and clear it |
 | `d` | Remove the selected saved copy, preserving the active login |
+| `p` / `P` | Preuse the selected account / every account of this harness (consumes quota) |
 | `r` / `g` | Refresh status / run harness diagnostics |
 | `q` / Ctrl-C | Close and restore the terminal |
 
-Save, switch and removal actions require confirmation. Confirmations start on
+The preuse keys appear in the key line only for a harness that supports preuse,
+and each run states how many accounts it will consume quota on before it starts.
+The footer follows the run account by account, the activity log keeps each
+account's result, and the table is read again afterwards because the prompts
+moved the usage it shows. Closing the dashboard stops the run before its next
+account.
+
+Save, switch, preuse and removal actions require confirmation. Confirmations start on
 Cancel; use Left/Right or Tab to select the action, then Enter. Switching first
 checks the current credential and offers to save an unsaved login. A declined,
 failed or unverified save prevents switching. Plain character shortcuts remain
@@ -820,9 +894,10 @@ unsaved current login adds how to keep it (`authswitch <harness> stash --keep sa
 it`).
 
 `authswitch <harness> current` prints the same sentence. The same account with a
-rotated token is that account refreshing itself and is not reported; for Claude Code the
-rotation is copied into that account's saved record, and re-running the switch re-arms the
-check against the file's current contents.
+rotated token is that account refreshing itself and is not reported; for Claude Code and
+Codex the rotation is copied into that account's saved record. Re-running the switch
+re-arms the Claude Code and OpenCode check against the file's current contents; Codex has
+no such check.
 
 Both commands accept a harness qualifier (`authswitch claude limits`) and `--json`.
 Neither changes which account is in use: they never activate, switch or clear a login and
@@ -895,7 +970,9 @@ another workspace's default entry cannot supply its billing information.
 Each request uses that account's access token and account ID. For the active
 account it reads the current credential, which may be newer than the stash.
 Listing never switches accounts, starts or stops an app-server, refreshes tokens,
-writes credentials, stores status results, or consumes an earned reset.
+writes `~/.codex/auth.json`, stores status results, or consumes an earned reset. The one
+write it makes is the saved copy of the active login, brought onto the credential Codex is
+running on as described above.
 
 These backend contracts come from Codex's source and can change. Missing fields,
 expired logins, denied requests, timeouts, and unsupported responses are shown
@@ -940,6 +1017,9 @@ process.exitCode = await cli.run(process.argv.slice(2));
 Each adapter owns discovery, identity matching, save verification, credential
 storage, switching and process lifecycle, live status APIs, and diagnostics.
 `readState()` and `readAccountStatus()` must never activate, switch or clear a login.
+`readState()` may bring the saved copy of the active login onto the credential that login's
+harness last wrote -- the Claude Code and Codex adapters do, because both harnesses rotate
+the login they run -- and must write nothing else.
 `readAccountStatus()` may renew the tokens of the saved copy it is reading, when the provider
 gives it no other way to answer (the Claude Code adapter does, under the store's lock, for
 saved and inactive logins only); it must never touch the active login's credential. `readAccountStatus(accountId,
@@ -973,7 +1053,15 @@ model identifier and cancellation signal; `IHarnessPreuseResult` returns the
 selected model and optional input/output/total token counts. The adapter owns
 credential selection and inference and must leave the active login unchanged.
 Unsupported adapters reject the command before account selection. Prompt results
-never contain credentials or raw provider responses.
+never contain credentials or raw provider responses. A refusal that sent no
+request must be a `PreuseError` with `requestStarted` false, which is what a run
+over several accounts reports as skipped rather than failed; every other error,
+`PreuseError` or not, is treated as a request that may have consumed tokens.
+`preuseAccounts(harness, accounts, options, report)` is that run: it sends one
+prompt per account in turn, reports a `started` and a `finished` event for each,
+reads the account's reset schedule after a completed prompt, stops before the
+next account once the signal aborts, and returns the per-account results with
+their counts.
 
 Adapters can also return an optional `IHarnessAccountStatus.summary` with a
 subscription plan and its live/stored provenance, labelled usage windows with

package/ts/00_commitinfo_data.ts

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