@modelprofile.com/authswitch 6.0.0 → 6.2.0

package/dist_ts/classes.opencodeharness.js

@@ -4,10 +4,16 @@ import { CredentialStore, credentialHash, credentialRecord, credentialText, read
 import { HarnessProcesses } from './classes.harnessprocesses.js';
 import { ClaudeAccountStatus } from './classes.claudestatus.js';
 import { CLAUDE_REFRESH_MARGIN_MS } from './classes.claudetokenrefresh.js';
+import { ClaudeLoginRejectedError, ClaudeRateLimitError } from './claudehttp.js';
 import { CodexAccountStatus } from './classes.codexstatus.js';
+import { OpenCodeAnthropicRefresh } from './classes.opencodeanthropicrefresh.js';
 import { writeSecretFileAtomically } from './helpers.js';
 import { beginSavedOpenAiLogin, openCodeCredentialFromLogin } from './classes.login.js';
 import { plainText } from './formatting.js';
+/** Anthropic refused the grant OpenCode's entry holds; no retry and no other account changes that answer. */
+const ANTHROPIC_LOGIN_REJECTED = 'Login expired or was rejected. Log in again with opencode auth login.';
+/** A saved copy is not the login OpenCode uses, so renewing it would rotate a token OpenCode's own entry still holds. */
+const SAVED_ANTHROPIC_EXPIRED = 'This saved Anthropic login\'s access token has expired. authswitch renews the Anthropic login OpenCode has active; activate this one to have it renewed, or log in again with opencode auth login.';
 /** OpenCode owns one login per provider. Replacing a slot never replaces the whole provider set. */
 export class OpenCodeHarness extends FileHarness {
     id = 'opencode';
@@ -17,12 +23,17 @@ export class OpenCodeHarness extends FileHarness {
     liveSwap = false;
     /** Only its OpenAI login reports usage, and a supervisor (AGL) restarts it around a switch, so a watch leaves it alone. */
     autoSwitch = false;
+    /** OpenCode re-reads its credential file on every request; only a request already in flight still holds the previous login. */
+    runningRetention() {
+        return 'They re-read the credential file on every request, but a request already in flight still holds the previous login, and its token refresh can ';
+    }
     loginProviders = [{ providerId: 'openai', label: 'OpenAI', flows: ['device'] }];
     store;
     file;
     env;
     status;
     claudeStatus;
+    anthropicRefresh;
     processes;
     fetcher;
     now;
@@ -33,6 +44,7 @@ export class OpenCodeHarness extends FileHarness {
         this.store = new CredentialStore(this.id, options.stashRoot);
         this.status = new CodexAccountStatus(options.fetch);
         this.claudeStatus = new ClaudeAccountStatus(options.fetch, options.now);
+        this.anthropicRefresh = new OpenCodeAnthropicRefresh(options.fetch, options.now);
         this.fetcher = options.fetch;
         this.now = options.now ?? Date.now;
         this.processes = options.processes ?? new HarnessProcesses('opencode');
@@ -119,28 +131,85 @@ export class OpenCodeHarness extends FileHarness {
         if (readCredentialDocument(this.file).raw !== raw)
             throw new Error('Active login verification failed. The outgoing login remains saved.');
     }
+    /** The login OpenCode has in a provider slot, read from its file; undefined where the file holds none it can read. */
+    activeSlot(slotIdArg) {
+        return this.snapshot().accounts.find(account => account.slotId === slotIdArg);
+    }
+    /** Whether this login's access token is inside Claude Code's five-minute margin, the margin Claude's own logins use. */
+    renewalDue(credentialArg) {
+        const expires = credentialArg.expires;
+        return typeof expires === 'number' && Number.isFinite(expires) && this.now() + CLAUDE_REFRESH_MARGIN_MS >= expires;
+    }
+    /**
+     * Renews OpenCode's active Anthropic login and writes the rotated pair back into OpenCode's own credential file.
+     *
+     * Nothing is stranded by that write. OpenCode's auth service reads `auth.json` on every `Auth.all()`, `Auth.get()`
+     * is that read (1.18.15 @99100961, 1.18.31 @103733929), and its Anthropic provider -- `opencode-anthropic-auth`
+     * 0.0.13, since the binary carries no Anthropic OAuth code -- calls the `getAuth()` it was initialised with
+     * (@98017331) inside the `fetch` wrapper of every single request. A running OpenCode therefore holds no refresh
+     * token in memory and picks up this rotation on its next request, exactly as it picks up its own.
+     *
+     * The renewal is the only authswitch operation on the store while it runs, and the rotated pair replaces the
+     * entry only while OpenCode still holds the refresh token that was sent: a login OpenCode renewed meanwhile is
+     * returned as it now stands. The write itself is `apply`'s verified compare-and-swap, which preserves every other
+     * provider and replaces the file atomically -- OpenCode writes the same file in place. The slot's switch record
+     * follows that write, because an `anthropic` login's identity is its refresh token and this rotation is
+     * authswitch's own: without that, the next read would report this write as a different account.
+     */
+    renewAnthropic(accountArg, signalArg) {
+        return this.store.locked(async () => {
+            const current = this.activeSlot(accountArg.slotId) ?? accountArg;
+            if (!this.renewalDue(current.credential))
+                return current;
+            const refreshToken = credentialText(current.credential.refresh);
+            if (refreshToken === undefined)
+                throw new Error('This Anthropic login holds no refresh token; log in again with opencode auth login.');
+            signalArg?.throwIfAborted();
+            const tokens = await this.anthropicRefresh.refresh(refreshToken);
+            const latest = this.activeSlot(accountArg.slotId);
+            if (!latest || credentialText(latest.credential.refresh) !== refreshToken)
+                return latest ?? current;
+            const renewed = this.inspect({ ...latest.credential, access: tokens.access, refresh: tokens.refresh, expires: tokens.expires }, latest.slotId);
+            this.apply(latest.slotId, latest, renewed);
+            this.recordRenewal(latest.slotId);
+            return renewed;
+        }, { signal: signalArg });
+    }
     /**
      * The subscription and usage of an OpenCode `anthropic` OAuth login.
      *
      * That entry holds the same Claude subscriber grant Claude Code stores, so Claude's own account endpoints answer
      * for it and the account reports real windows instead of no quota API at all. OpenCode keeps no scopes and no
-     * account identity with it, so the service decides both; the token is used exactly as stored. Renewing it is
-     * OpenCode's, because the renewal rotates the refresh token a running OpenCode holds in memory, and authswitch
-     * cannot write that rotation into an instance it does not manage.
+     * account identity with it, so the service decides both. A due access token is renewed first, with OpenCode's own
+     * request; a refusal is reported and nothing is written, so the entry OpenCode owns is left exactly as it was.
+     *
+     * A saved copy is never renewed: OpenCode's entry holds the same refresh token, and rotating it here would leave
+     * the login OpenCode actually uses holding a token the service has replaced.
      */
-    anthropicStatus(credentialArg, optionsArg) {
-        const accessToken = credentialText(credentialArg.access);
-        const expires = credentialArg.expires;
-        if (accessToken === undefined || typeof expires !== 'number') {
-            return Promise.resolve(this.claudeStatus.unavailable({}, 'This Anthropic login holds no usable access token; log in again with opencode auth login.'));
-        }
-        if (this.now() + CLAUDE_REFRESH_MARGIN_MS >= expires) {
-            return Promise.resolve(this.claudeStatus.unavailable({}, 'This Anthropic login\'s access token has expired. OpenCode renews it while it runs; authswitch does not, because the renewal rotates the refresh token a running OpenCode keeps in memory. Start OpenCode, or log in again with opencode auth login.'));
+    async anthropicStatus(accountArg, isActiveArg, optionsArg) {
+        let account = accountArg;
+        if (this.renewalDue(account.credential)) {
+            if (!isActiveArg)
+                return this.claudeStatus.unavailable({}, SAVED_ANTHROPIC_EXPIRED);
+            try {
+                account = await this.renewAnthropic(account, optionsArg.signal);
+            }
+            catch (error) {
+                if (optionsArg.signal?.aborted)
+                    throw error;
+                const problem = error instanceof ClaudeLoginRejectedError ? ANTHROPIC_LOGIN_REJECTED
+                    : error instanceof Error ? error.message : 'the login could not be renewed.';
+                return this.claudeStatus.unavailable({}, `Login refresh: ${problem}`, error instanceof ClaudeRateLimitError ? { retryAt: error.retryAt } : undefined);
+            }
         }
+        const accessToken = credentialText(account.credential.access);
+        if (accessToken === undefined)
+            return this.claudeStatus.unavailable({}, 'This Anthropic login holds no usable access token; log in again with opencode auth login.');
         return this.claudeStatus.read({ accessToken, scopes: [] }, optionsArg);
     }
-    async readAccountStatus(id, optionsArg) {
-        const account = this.readCredential(id);
+    async readAccountStatus(id, optionsArg = {}) {
+        const active = this.activeCredential(id);
+        const account = active ?? this.savedCredential(id);
         if (account.slotId === 'openai' && account.credential.type === 'oauth') {
             const info = this.openAiInfo(account.credential);
             if (!info.accountId)
@@ -148,7 +217,7 @@ export class OpenCodeHarness extends FileHarness {
             return this.status.readCredential(credentialText(account.credential.access), info.accountId, info.plan, optionsArg);
         }
         if (account.slotId === 'anthropic' && account.credential.type === 'oauth')
-            return this.anthropicStatus(account.credential, optionsArg);
+            return this.anthropicStatus(account, active !== undefined, optionsArg);
         return { facts: [
                 { section: 'Authentication', label: 'Provider', value: account.slotId },
                 { section: 'Authentication', label: 'Login type', value: String(account.credential.type) },
@@ -156,4 +225,4 @@ export class OpenCodeHarness extends FileHarness {
             ], problems: [] };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.opencodeharness.js","sourceRoot":"","sources":["../ts/classes.opencodeharness.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.opencodeharness.js","sourceRoot":"","sources":["../ts/classes.opencodeharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.stashstore.d.ts

@@ -30,6 +30,16 @@ export declare class StashStore {
      * verify with `readBack()` before destroying the original.
      */
     write(identityArg: ICodexIdentity, rawAuthArg: string, enrollmentsArg: IRemoteControlEnrollment[], codexHomeArg: string): IStashEntry;
+    /**
+     * Replaces the credential of an existing stash and leaves its metadata exactly as it is.
+     *
+     * Codex refreshes the login it is running on its own schedule, so a saved copy of that login holds older
+     * tokens until something writes the rotation back. Doing so is an update of one account's credential, not a
+     * new save: the record keeps its account, its enrollments and the moment it was saved, which `write()` would
+     * stamp anew. The credential must belong to the account the metadata names -- the same guard `write()`
+     * applies -- so a mirror can never move one account's login into another account's record.
+     */
+    replaceAuth(emailArg: string, rawAuthArg: string): void;
     /**
      * Reads a stash back and confirms it matches what was meant to be written.
      * Callers use this before clearing the active credential, so a stash is only

package/dist_ts/classes.stashstore.js

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { writeSecretFileAtomically } from './helpers.js';
+import { codexIdentityFromRaw } from './classes.codexauth.js';
 const AUTH_FILE_NAME = 'auth.json';
 const META_FILE_NAME = 'stash.json';
 /**
@@ -80,6 +81,26 @@ export class StashStore {
         writeSecretFileAtomically(plugins.path.join(dir, META_FILE_NAME), `${JSON.stringify(entry, null, 2)}\n`);
         return entry;
     }
+    /**
+     * Replaces the credential of an existing stash and leaves its metadata exactly as it is.
+     *
+     * Codex refreshes the login it is running on its own schedule, so a saved copy of that login holds older
+     * tokens until something writes the rotation back. Doing so is an update of one account's credential, not a
+     * new save: the record keeps its account, its enrollments and the moment it was saved, which `write()` would
+     * stamp anew. The credential must belong to the account the metadata names -- the same guard `write()`
+     * applies -- so a mirror can never move one account's login into another account's record.
+     */
+    replaceAuth(emailArg, rawAuthArg) {
+        const meta = this.readMeta(emailArg);
+        if (!meta) {
+            throw new Error(`no stash for "${emailArg}" whose credential could be replaced`);
+        }
+        const identity = codexIdentityFromRaw(rawAuthArg);
+        if (!identity || identity.email !== meta.email || identity.accountId !== meta.accountId || identity.kind !== meta.kind) {
+            throw new Error('the credential does not belong to the account this stash holds; refusing to replace it');
+        }
+        writeSecretFileAtomically(plugins.path.join(this.entryDir(emailArg), AUTH_FILE_NAME), rawAuthArg);
+    }
     /**
      * Reads a stash back and confirms it matches what was meant to be written.
      * Callers use this before clearing the active credential, so a stash is only
@@ -189,4 +210,4 @@ export class StashStore {
         return true;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stashstore.js","sourceRoot":"","sources":["../ts/classes.stashstore.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stashstore.js","sourceRoot":"","sources":["../ts/classes.stashstore.ts"],"names":[],"mappings":"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"}

package/dist_ts/interfaces.harness.d.ts

@@ -236,9 +236,13 @@ export interface IAuthHarness {
      */
     readonly autoSwitch?: boolean;
     /**
-     * The account's live status. It must never activate, switch or clear a login. It may renew the tokens of the
-     * saved copy it reads when the provider leaves it no other way to answer -- the Claude Code adapter does, for
-     * saved and inactive logins only, under its store's lock -- and must leave the active login's credential alone.
+     * The account's live status. It must never activate, switch or clear a login.
+     *
+     * It may renew the tokens of the credential it reads when the provider leaves it no other way to answer, under
+     * its store's lock and with a compare-and-swap on the refresh token it sent. A saved copy is always its own to
+     * renew -- the Claude Code adapter renews one, because Claude Code's active login is Claude Code's. The active
+     * login may only be renewed where the owning harness re-reads its credential file on every request, so that the
+     * rotation strands nothing: OpenCode's Anthropic provider does, and authswitch renews that entry.
      */
     readAccountStatus(accountIdArg: string, optionsArg?: IHarnessStatusOptions): Promise<IHarnessAccountStatus>;
     readonly loginProviders?: IHarnessLoginProvider[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "6.0.0",
+  "version": "6.2.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

@@ -32,10 +32,11 @@ control, or remove a saved account. The guide shows the current account and retu
 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
@@ -109,8 +110,11 @@ never blocked by a waiting switch; after that the operation fails with nothing
 changed. A lock left behind by a Claude Code that died goes stale after its own
 threshold and is taken over, as Claude Code itself would.
 
-**OpenCode keeps the previous login until it restarts.** It holds that login in
-memory and can write it back at its next OAuth token refresh. So before `use` and
+**A running OpenCode can still overwrite a switch.** Not by holding the previous login:
+its auth service caches nothing and re-reads `auth.json` on every lookup. The window is a
+request already in flight, which read the previous login before the switch and can write
+that login's own rotation back afterwards -- and OpenCode replaces the whole provider map
+in place rather than atomically. So before `use` and
 before `stash` without `--keep`, authswitch lists OpenCode's own running instances --
 pid, start time and command line -- and offers to stop them:
 
@@ -217,11 +221,16 @@ ChatGPT OAuth accounts display their email and use the same direct status APIs a
 Codex. An `anthropic` OAuth login holds the same Claude subscriber grant Claude Code
 stores, so it reports Claude's own plan, organization and usage windows through the
 account endpoints described under **Claude Code**; OpenCode keeps no scopes and no
-account identity with that entry, so both are left to the service. Renewing that token
-stays OpenCode's -- the renewal rotates the refresh token a running OpenCode holds in
-memory, which authswitch cannot write into an instance it does not manage -- so an access
-token inside Claude Code's five-minute margin is reported as expired instead, with the
-two ways to renew it. API keys and opaque provider tokens have no reliable email, so their
+account identity with that entry, so both are left to the service. An access token inside
+Claude Code's five-minute margin is renewed first, with the request OpenCode's own
+Anthropic provider sends (`opencode-anthropic-auth`: `console.anthropic.com`, Claude
+Code's public client, no scope), and the rotated pair is written back into `auth.json`
+atomically, preserving every other provider. Nothing is stranded by that write: OpenCode's
+auth service re-reads `auth.json` on every lookup and its Anthropic provider asks for the
+credential again inside every request, so a running instance picks up the rotation exactly
+as it picks up its own. A refusal is reported and nothing is written, and a saved copy is
+never renewed, because OpenCode's own entry holds the same refresh token.
+API keys and opaque provider tokens have no reliable email, so their
 labels contain the provider and a SHA-256 fingerprint. Their quota/billing information is
 explicitly unavailable. `OPENCODE_AUTH_CONTENT` overrides the file and blocks file
 management. Provider configuration and environment credentials remain managed by OpenCode.
@@ -294,6 +303,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
@@ -339,10 +361,12 @@ reason names what to do:
   the service answered in a shape authswitch does not read. Nothing is guessed from a
   response it does not understand.
 
-An OpenCode `anthropic` row reads the same endpoints and so shows the same reasons,
-plus two of its own: `This Anthropic login's access token has expired.`, which OpenCode
-renews by running or by `opencode auth login`, and `This Anthropic login holds no usable
-access token`, which needs a new `opencode auth login`.
+An OpenCode `anthropic` row reads the same endpoints and so shows the same reasons. Its
+renewal adds `Login refresh: Login expired or was rejected. Log in again with opencode
+auth login.`, which is Anthropic refusing the refresh token OpenCode's entry holds -- no
+retry changes that, and the refusal is never remembered, because OpenCode owns that entry.
+`This saved Anthropic login's access token has expired.` is a stashed copy, which is left
+alone so that the login OpenCode uses keeps a refresh token the service still accepts.
 
 OpenCode and Claude saved records are separate owner-only files under
 `~/.authswitch/opencode` and `~/.authswitch/claude`. Emails are accepted as account
@@ -810,9 +834,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
@@ -885,7 +910,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
@@ -930,6 +957,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,
@@ -1038,7 +1068,7 @@ Account identity comes from the `id_token` inside the credential — the email c
 
 **Other Codex clients keep running.** Stopping the managed app-server does not stop an editor extension that spawned its own. Close it, or expect it to keep using the credential it already loaded.
 
-**A running OpenCode can undo a switch.** It holds the previous login in memory and rewrites the credential file at its next token refresh. Authswitch lists those instances, offers to stop them, warns when any keep running, and detects the overwrite afterwards — but it cannot prevent it while they run. Restart them after a switch. A running Claude Code picks the switch up instead; its guarantee rests on the behaviour and lock protocol verified against Claude Code 2.1.273, and `authswitch claude active` still reports a login that changed outside authswitch.
+**A running OpenCode can undo a switch.** Its auth service keeps no login in memory -- every lookup re-reads `auth.json` -- but a request already in flight, which read the previous login before the switch, can write that login's own rotation back afterwards, over a provider map OpenCode replaces in place. Authswitch lists those instances, offers to stop them, warns when any keep running, and detects the overwrite afterwards — but it cannot prevent it while they run. Restart them after a switch. A running Claude Code picks the switch up instead; its guarantee rests on the behaviour and lock protocol verified against Claude Code 2.1.273, and `authswitch claude active` still reports a login that changed outside authswitch.
 
 **The Codex stash is keyed by email.** Two Codex workspaces with the same email
 cannot both be saved under that key. Their account IDs are distinguished during

package/ts/00_commitinfo_data.ts

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

package/ts/accounts.ts

@@ -239,7 +239,8 @@ const STATUS_LOOKUP_CONCURRENCY = 4;
  * Bounded status lookups: at most four accounts at a time, started in order, each handed the caller's signal.
  * A lookup that fails reports undefined; once the signal aborts, no further lookup starts. A callback that throws
  * rejects the call, and no other lookup starts after it. No lookup activates, switches or clears a login, though an
- * adapter may renew the tokens of the saved copy it reads (`IAuthHarness.readAccountStatus`).
+ * adapter may renew the tokens of the credential it reads, saved or active, on that method's terms
+ * (`IAuthHarness.readAccountStatus`).
  */
 const lookupStatuses = async (
   harnessArg: IAuthHarness,

package/ts/classes.cli.ts

@@ -108,9 +108,9 @@ ${bold('Options')}
 
 A switch works while OpenCode or Claude Code is running. Claude Code picks the new login
 up on its next request, so its sessions are stopped only on --stop or --force-stop.
-OpenCode keeps the previous login in memory and can write it back at its next token
-refresh, so an OpenCode switch offers to stop it first; without a terminal it leaves
-it running and says so.
+OpenCode caches no login either, but a request already in flight can write the previous
+login's own rotation back, so an OpenCode switch offers to stop it first; without a
+terminal it leaves it running and says so.
 
 Watch covers the harnesses that support automatic switching (${[...this.harnesses.values()].filter(harness => harness.autoSwitch === true).map(harness => harness.id).join(', ') || 'none registered'}).
 --interval takes seconds or a unit (120, 90s, 2m; from 1m to 1d); --threshold takes 50 to 100.