@zergai/ztc 0.2.6-dev.36102446685 → 0.2.7-dev.36236183737

package/README.md

@@ -51,25 +51,26 @@ you are ready for ZTC to make the proposed changes.
 
 Authentication options are Zerg Router browser login (`/auth login`), a provider API key
 (`/config key <api-key>`), or Claude Code OAuth (`claude setup-token`, then
-`/provider claude_code`).
+`/model claude_code`).
 
 For browser login at **zergrouter.com**, run `ztc auth login` in your shell or
 `/auth login` inside ZTC. Both use the same flow and credentials. See
 [Zerg Router and DeepSeek setup](docs/zerg-router.md) for model selection,
 Claude Code/Codex emulation, and `ztc "prompt"` or `ztc -p "prompt"` usage.
 
-Use `/provider openai` or `/provider deepseek` for direct API calls with your
-local keys. Use `/provider zergrouter [upstream-provider]` to route through your
-Router login, or `/provider modal` for Modal shared endpoints. For Ollama,
+Use `/model openai [model]` or `/model deepseek [model]` for direct API calls with your
+local keys. Use `/model zergrouter <upstream-provider> [model]` to route through your
+Router login, or `/model modal [model]` for Modal shared endpoints. For Ollama,
 LM Studio, or a custom server, configure `/config openai-compat` and select
-`/provider local`. Switching providers selects an appropriate default model;
+`/model local [model]`. Switching providers selects an appropriate default model;
 selecting the same provider preserves your current model.
 
-Type `/provider ` or `/model ` to search suggestions by ID, name, or alias.
+Type `/model ` to search providers and current-provider models by ID, name, or alias.
 Search is fuzzy, so `/model dskfl` finds DeepSeek Flash. Use Up/Down to select,
-Tab or Enter to complete, then Enter to run the command. Escape dismisses
-suggestions. Custom model IDs can still be entered directly.
-`/model` names the selected provider and lists only its models. A successful
+Tab or Enter to complete a provider and continue to its models. Enter on a model
+suggestion fills its ID; press Enter again to apply it. Escape dismisses suggestions.
+Custom model IDs can still be entered directly.
+After a provider is entered, the picker names it and lists only its models. A successful
 live catalog replaces bundled suggestions, including when the catalog is empty;
 bundled suggestions are used while loading or when discovery fails.
 Modal lists registered aliases, such as `kimi-k3` and `deepseek-v4.1-flash`;
@@ -567,11 +568,17 @@ When a saved session includes `zmux` state, `ztc resume` restores the pane layou
 | `/config statusline <left|right> <field,...>` | Set status line fields without opening the editor |
 | `/config statusline variant <field> <raw\|short\|long>` | Set one field's verbosity without opening the editor |
 | `/config statusline edit` | Open the status line field editor |
-| `/provider [name]` | Select direct API, local endpoint, or Zerg Router routing |
-| `/model <name>` | Select a model, with fuzzy autocomplete while typing |
+| `/model <provider> [model]` | Select a provider and optional model; `/model <model>` keeps the active provider |
+| `/model zergrouter <provider> [model]` | Select a Router provider and optional model |
 | `/models` | List available models |
 | `/permissions` | View/update tool permissions |
 
+`/profile list` and `/settings` → **Config Scope** → **Active config profile** show one profile catalog. The built-in `ztc`, `ztc-coder`, `ztc-datascience`, and `scientist` profiles share the default settings and sign-ins; each selects its named emulation layer. They work without setup. An existing saved directory with one of those names remains an independent config profile, so its data stays accessible.
+
+Custom config profiles keep settings and sign-ins separate. Start one with `ztc --profile work`, or switch the running session with `/profile work`. `/profile create work` starts a new profile. Switching keeps the session ID and conversation while rebuilding the agent. A later `ztc resume` restores the session's saved profile unless you specify `--profile`. The default config stays at `~/.ztc/config.json`; custom named configs live at `~/.ztc/profiles/<name>/config.json`. Session history stays shared. Switching does not rewrite settings after the one-time migration described below.
+
+On first use of this release, each existing config profile adopts the new default settings once. Its account registrations, authentication, API keys, and credential-bearing integration settings are retained. Later edits to that profile are kept. New profiles start with the same defaults. The migration writes only the active profile's config file, so switching to an unused profile applies its migration then.
+
 #### Bottom status line
 
 The terminal status line has independently ordered left and right fields. Values that are unavailable are omitted. In narrow terminals, lower-priority fields are hidden before mode, connection state, or active errors.
@@ -608,7 +615,21 @@ Available fields are `mode`, `session-name`, `session-id`, `workspace`, `context
 
 ZTC separates the official OpenAI Codex App Server integration from the older direct ChatGPT Codex backend.
 
-Use `ztc --provider codex_app_server` for the documented OpenAI App Server path. It launches `codex app-server` over JSONL stdio and uses App Server auth/model discovery. This first milestone runs without ZTC tool schemas and fails explicit ZTC tool-calling backend requests, because Codex App Server owns tool execution and approval semantics; full App Server approval/tool event mapping is still a separate runtime-mode step. Run `codex login status` before starting ZTC if auth is unclear.
+Use `ztc --provider codex_app_server` for the documented OpenAI App Server path. It launches `codex app-server` over JSONL stdio and uses App Server auth, model discovery, and dynamic tool calls. Run `codex login status` before starting ZTC if the machine-default login is unclear.
+
+To keep several ChatGPT accounts signed in for manual switching, add each as a separate `codex_app_server` profile:
+
+```text
+/accounts add codex_app_server work Work
+/accounts login work
+/accounts add codex_app_server personal Personal
+/accounts login personal
+/accounts use work
+```
+
+Each login uses the official Codex CLI with its own `CODEX_HOME` under `~/.ztc/accounts/`, file credential storage, and ChatGPT authentication. The accounts stay signed in on disk without keeping an App Server process running for every account. `/accounts use <id>` switches the active profile; the browser Accounts panel offers the same one-click selection. Codex accounts never rotate automatically when a quota is reached, even if auto-rotation is enabled for Claude or Kimi.
+
+The Accounts panel and `/accounts list` refresh the selected profiles through the official App Server. They show the ChatGPT identity, remaining quota windows, and token activity when OpenAI reports them. A failed quota or usage read is marked stale and retains the last observed value; an expired login needs a new `/accounts login <id>`. A profile whose login cannot be verified does not replace the current active profile. The panel's Refresh button checks again immediately. If an administrator requires keyring-only credentials, Codex may refuse the per-profile file-store setting; that profile will need a supported organization policy before it can be added to this pool.
 
 Use `ztc --provider codex_legacy` for the existing direct `chatgpt.com/backend-api/codex` backend backed by `~/.codex/auth.json`. Existing config values with `provider: "codex"` remain supported as a compatibility alias for `codex_legacy`; new configs should use the explicit provider IDs.
 
@@ -689,7 +710,7 @@ Optional App Server config:
 
 | Shortcut | Action |
 |----------|--------|
-| `Enter` | Apply the selected model/provider, run a command, or submit input |
+| `Enter` | Fill a partial completion; run an exact command or model, or submit input |
 | `Shift+Enter` | Insert newline |
 | `Ctrl+C` | Exit |
 | `Ctrl+L` | Clear screen |
@@ -712,10 +733,15 @@ Optional App Server config:
 | `Ctrl+Y` | Paste back the most recent kill — undo a cleared prompt |
 | `Alt+Y` / `Ctrl+Alt+Y` | With Ctrl+Y, step through earlier kills |
 
-Slash commands, `/model`, and `/provider` share a fuzzy-search menu above the
-prompt. It shows up to four choices, the result position, and the current
-model/provider. Model choices belong to the active provider. Commands that need
-an argument open that step on Enter; Tab always lets you edit before running.
+Slash commands and `/model` share a fuzzy-search menu above the prompt. It shows
+as many choices as fit above the prompt while reserving transcript space. The
+menu shows the result position and current model/provider. The
+first `/model` step suggests providers and models for the active provider. Tab
+or Enter on a provider opens its model step. Enter on a partial model fills the
+draft; press Enter again to run it. An exact model ID runs on the first Enter.
+Press Esc, then Enter to switch providers without
+choosing a model. Model suggestions use the selected provider and route.
+Commands that need an argument open that step on Enter or Tab.
 Argument syntax appears as one short usage line instead of selectable chips.
 
 ---

package/dist/App.js

@@ -383,7 +383,7 @@ export const App = () => {
     }, []);
     const showToastRef = useRef(null);
     /** Returns the post-enqueue size, or null if the queue was full. */
-    const enqueueMessage = useCallback((text) => {
+    const enqueueMessage = useCallback((text, delivery = 'end-of-turn') => {
         const current = queueRef.current;
         if (current.length >= MAX_QUEUE) {
             showToastRef.current?.(`Queue full (${MAX_QUEUE}). Cancel or wait.`);
@@ -393,6 +393,7 @@ export const App = () => {
             id: generateId(),
             text,
             queuedAt: new Date(),
+            delivery,
         };
         const nextSize = current.length + 1;
         setQueue(prev => (prev.length >= MAX_QUEUE ? prev : [...prev, entry]));
@@ -574,6 +575,8 @@ export const App = () => {
                     // are intentionally dropped on idle, as before.)
                     contextTokens: s.contextTokens,
                     contextWindow: s.contextWindow,
+                    cacheInputTokens: s.cacheInputTokens,
+                    cachedInputTokens: s.cachedInputTokens,
                     tokensEstimated: s.tokensEstimated,
                     authError: false
                 }));
@@ -741,7 +744,10 @@ export const App = () => {
         getContextWindow: () => agentStateRef.current.contextWindow,
         // /clear -> 0 and /compact -> reduced size: reactively shrink the bar (the
         // backend won't report the drop until the next turn).
-        setContextUsage: (used, estimated) => setAgentState(s => ({ ...s, contextTokens: used, tokensEstimated: estimated })),
+        setContextUsage: (used, estimated) => setAgentState(s => ({
+            ...s, contextTokens: used, tokensEstimated: estimated,
+            cacheInputTokens: undefined, cachedInputTokens: undefined,
+        })),
         model: configStore.get().model
     }), [addMessage, clearMessages, getMessages, setMessages, reloadAgent, exit, shellController, retryLast, inputMode, promptController, formController]);
     // Handle commands
@@ -1021,6 +1027,8 @@ export const App = () => {
                         // Provider-reported window (Codex) feeds the bar denominator; keep the
                         // last-known one when this event doesn't carry one.
                         contextWindow: event.contextWindow ?? s.contextWindow,
+                        cacheInputTokens: event.cacheInputTokens,
+                        cachedInputTokens: event.contextCachedInputTokens,
                         tokensEstimated: event.usage.estimated
                     }));
                     break;
@@ -1098,8 +1106,9 @@ export const App = () => {
     React.useEffect(() => {
         const prevStatus = prevStatusRef.current;
         prevStatusRef.current = agentState.status;
-        if (inputMode !== 'queue')
-            return;
+        // Deliberately NOT gated on `inputMode`: /inputmode only selects what Enter
+        // does while busy. A Tab-queued prompt promised end-of-turn delivery and
+        // must still be sent when the run is configured to interrupt on Enter.
         if (agentState.status !== 'idle')
             return;
         if (prevStatus === 'idle' && queue.length === 0)
@@ -1108,6 +1117,11 @@ export const App = () => {
             return;
         if (flushingRef.current)
             return;
+        // End-of-turn entries only; a `subturn` entry still waiting here is started
+        // by its own fallback path, so taking it here would send it twice.
+        const ready = queueRef.current.find(entry => entry.delivery !== 'subturn');
+        if (!ready)
+            return;
         flushingRef.current = true;
         const next = dequeueMessage();
         if (!next) {
@@ -1117,7 +1131,7 @@ export const App = () => {
         void handleSubmit(next.text).finally(() => {
             flushingRef.current = false;
         });
-    }, [agentState.status, queue.length, inputMode, dequeueMessage, handleSubmit]);
+    }, [agentState.status, queue.length, dequeueMessage, handleSubmit]);
     const showToast = useCallback((message) => {
         setToast(message);
         if (toastTimerRef.current) {

package/dist/agent/agent.d.ts

@@ -105,6 +105,8 @@ export interface AgentRunResult {
     usage?: TokenUsage;
     stopReason: 'complete' | 'interactive' | 'max_iterations';
     reasoning?: string;
+    /** Ordered model-facing messages produced during a turn that accepted steering. */
+    turnMessages?: Message[];
 }
 export interface HarnessToolCallResult {
     success: boolean;
@@ -224,6 +226,8 @@ export declare class Agent {
      * immediately followed by tool_end.
      */
     private emitObservation;
+    /** Ask a provider-owned tool loop to accept a busy user message. */
+    steerUserMessage(message: Message): Promise<boolean>;
     /** Tools that end the agent turn when called (require user interaction before continuing). */
     private static readonly TURN_ENDING_TOOLS;
     /**
@@ -263,7 +267,7 @@ export declare class Agent {
      * authoritative history and mirrors the accepted user/assistant pair around
      * the same core loop used by unhosted ZTC.
      */
-    run(messages: Message[], signal?: AbortSignal): Promise<AgentRunResult>;
+    run(messages: Message[], signal?: AbortSignal, takeSteering?: () => Message[]): Promise<AgentRunResult>;
     private runCore;
     /**
      * Release the backend. The backend lives as long as the Agent — the run loop

package/dist/agent/agent.js

@@ -896,6 +896,12 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
                 return;
         }
     }
+    /** Ask a provider-owned tool loop to accept a busy user message. */
+    async steerUserMessage(message) {
+        if (this.#conversationBinding)
+            return false;
+        return this.backend.steerUserMessage?.(message) ?? false;
+    }
     /** Tools that end the agent turn when called (require user interaction before continuing). */
     static TURN_ENDING_TOOLS = new Set([
         'ask_user',
@@ -955,10 +961,10 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
      * authoritative history and mirrors the accepted user/assistant pair around
      * the same core loop used by unhosted ZTC.
      */
-    async run(messages, signal) {
+    async run(messages, signal, takeSteering) {
         const binding = this.#conversationBinding;
         if (!binding)
-            return this.runCore(messages, signal);
+            return this.runCore(messages, signal, takeSteering);
         const userMessage = [...messages].reverse().find((message) => message.role === 'user'
             && !message.metadata?.synthetic
             && !message.metadata?.toolResult);
@@ -987,6 +993,9 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
             if (!workingMessages.some((message) => message.id === userMessage.id)) {
                 workingMessages.push({ ...userMessage });
             }
+            // The host driver publishes only the initial user and final assistant
+            // for this turn. Leave busy input pending for a new hosted turn so the
+            // authoritative conversation cannot silently omit it.
             const result = await this.runCore(workingMessages, signal);
             const assistantMessage = {
                 id: `host_assistant_${randomUUID()}`,
@@ -1033,11 +1042,13 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         }
     }
     // Main execution loop shared by hosted and standalone turns.
-    async runCore(messages, signal) {
+    async runCore(messages, signal, takeSteering) {
         if (!this.hasApiKey()) {
             throw new AgentError('No API key configured. Use /config key <key> to set one.', 'NO_API_KEY');
         }
         const allToolCalls = [];
+        const turnMessages = [];
+        let acceptedSteering = false;
         let iterations = 0;
         // Each turn gets its own auto-continue budget; a long-running Agent must
         // not inherit one spent by the previous turn.
@@ -1110,7 +1121,10 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
                     const contextTokens = Math.max(0, usage.inputTokens - this._currentTransientOverageTokens);
                     // `usage` (this turn) may carry a provider-reported context window (Codex);
                     // forward it so the bar uses the real window over the static guess.
-                    this.emit({ type: 'token_usage', usage: totalUsage, contextTokens, contextWindow: usage.contextWindow });
+                    this.emit({
+                        type: 'token_usage', usage: totalUsage, contextTokens, contextWindow: usage.contextWindow,
+                        cacheInputTokens: usage.inputTokens, contextCachedInputTokens: usage.cachedInputTokens,
+                    });
                     // An incomplete provider response can still contain convincing prose or a
                     // partially assembled tool call. Treat it as a failed inference before
                     // either branch can persist the text as a final answer or execute an
@@ -1361,21 +1375,25 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
                         // so maxIterations exhaustion still has something to return.
                         lastToolTurnText = textContent;
                     }
-                    messages.push({
+                    const toolUseMessage = {
                         id: `assistant_${Date.now()}`,
                         role: 'assistant',
                         content: textContent || '[Using tools...]',
                         timestamp: new Date(),
                         toolCalls: allToolCalls.slice(-toolUseBlocks.length),
                         ...(response.reasoning ? { metadata: { reasoningContent: response.reasoning } } : {}),
-                    });
-                    messages.push({
+                    };
+                    messages.push(toolUseMessage);
+                    turnMessages.push(toolUseMessage);
+                    const toolResultMessage = {
                         id: `tool_${Date.now()}`,
                         role: 'user',
                         content: JSON.stringify(toolResults),
                         timestamp: new Date(),
                         metadata: { toolResult: true },
-                    });
+                    };
+                    messages.push(toolResultMessage);
+                    turnMessages.push(toolResultMessage);
                     // An explicit terminal tool may supply the answer after its bookkeeping
                     // succeeds. Keep the tool-use/result pair above for conversation replay.
                     if (combined.length === 1 && combined[0].toolCall.status === 'complete') {
@@ -1406,6 +1424,17 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
                         stopReason = 'interactive';
                         break;
                     }
+                    // A busy user message belongs after the completed tool-use/result pair
+                    // and before the next inference. Keep terminal tools and exhausted turns
+                    // on the normal next-turn path because no model request remains here.
+                    if (iterations < this.config.maxIterations) {
+                        const steering = takeSteering?.() ?? [];
+                        if (steering.length > 0) {
+                            messages.push(...steering);
+                            turnMessages.push(...steering);
+                            acceptedSteering = true;
+                        }
+                    }
                 }
                 catch (err) {
                     const error = err.message;
@@ -1459,6 +1488,7 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
             usage: totalUsage || undefined,
             stopReason,
             ...(finalReasoning ? { reasoning: finalReasoning } : {}),
+            ...(acceptedSteering ? { turnMessages } : {}),
         };
     }
     /**
@@ -1790,6 +1820,19 @@ INVESTIGATION STRATEGY — before making tool calls to explore or debug, follow
         if (statusCode === 403 || errorType === 'PERMISSION_DENIED') {
             return { retryable: false, reason: admissionMessage || 'Permission denied' };
         }
+        // Router billing admission (402 billing_required) is the first thing an
+        // unsubscribed user hits on the default route, so say what to do. Only the
+        // Router's H3 envelope may supply its public wording; any other 402 body
+        // stays private behind the canonical message.
+        if (statusCode === 402) {
+            const guidance = 'Subscribe in Zerg Router (Dashboard → Billing), or choose another model with /model.';
+            return {
+                retryable: false,
+                reason: admissionMessage
+                    ? `${admissionMessage.replace(/\.?\s*$/, '.')} ${guidance}`
+                    : `This model needs an active Zerg Router subscription. ${guidance}`,
+            };
+        }
         // Keep the Router's setup failure actionable without echoing arbitrary
         // remote bodies. Only these known provider names can enter the message.
         const missingRouterKey = typeof errorMessage === 'string'

package/dist/agent/backends/account_pool.d.ts

@@ -2,12 +2,9 @@
  * Account pool — model + resolution for switchable Claude Code + Codex
  * subscription accounts.
  *
- * S0 scope: turn the configured active account (per provider) into the
- * backend-construction options consumed by {@link createBackendForProvider}.
- * The lever is pure path/env redirection — ZTC never touches tokens; each
- * official CLI (or the direct auth manager) refreshes its own creds in its own
- * per-account dir/file. Later slices add the `/accounts` ops and the rotation
- * engine on top of this module.
+ * Resolve each active account to an isolated credential path for the backend.
+ * Official CLI logins write each profile's credentials; this module probes
+ * their files and builds the corresponding process environment.
  */
 import type { Account, AccountProvider, AccountRotation, AccountSource, ZTCConfig } from '../../config/types.js';
 /** Root dir for ztc-owned per-account credential dirs. */
@@ -69,6 +66,8 @@ export declare function defaultSourceFor(provider: AccountProvider, dir: string)
 export declare function sourceDir(source: AccountSource): string;
 /** Create an account's credential dir (0700) if missing. Returns the dir. */
 export declare function ensureAccountDir(source: AccountSource): string;
+/** A registered Codex profile already reading this same credential directory. */
+export declare function findCodexHomeCollision(accounts: readonly Account[], source: AccountSource): Account | undefined;
 /**
  * Whether an account holds ISOLATED (per-account) credentials. Always probes
  * the account's EXPLICIT path — never the cached default — and for the Claude

package/dist/agent/backends/account_pool.js

@@ -2,22 +2,21 @@
  * Account pool — model + resolution for switchable Claude Code + Codex
  * subscription accounts.
  *
- * S0 scope: turn the configured active account (per provider) into the
- * backend-construction options consumed by {@link createBackendForProvider}.
- * The lever is pure path/env redirection — ZTC never touches tokens; each
- * official CLI (or the direct auth manager) refreshes its own creds in its own
- * per-account dir/file. Later slices add the `/accounts` ops and the rotation
- * engine on top of this module.
+ * Resolve each active account to an isolated credential path for the backend.
+ * Official CLI logins write each profile's credentials; this module probes
+ * their files and builds the corresponding process environment.
  */
 import { spawnSync } from 'node:child_process';
-import { mkdirSync } from 'node:fs';
+import { mkdirSync, realpathSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { normalizeProviderId } from './provider_ids.js';
 import { hasUsableClaudeCodeAuth } from './claude_code_auth.js';
 import { hasUsableCodexAuth } from './codex_auth.js';
+import { CODEX_SUBSCRIPTION_CONFIG_ARGS, buildCodexAppServerEnv } from './codex_app_server.js';
 import { hasUsableKimiCodeAuth } from './kimi_code_auth.js';
 import { runtimeDiagOnce } from '../../utils/debug_log.js';
+import { profileConfigDir } from '../../config/profiles.js';
 /** Root dir for ztc-owned per-account credential dirs. */
 export const ACCOUNTS_ROOT = join(homedir(), '.ztc', 'accounts');
 const ACCOUNT_PROVIDERS = [
@@ -107,7 +106,10 @@ export function resolveRotation(config) {
 // ---------------------------------------------------------------------------
 /** Default ztc-owned credential dir for a freshly-added account. */
 export function defaultAccountDir(provider, id) {
-    return join(ACCOUNTS_ROOT, provider, id);
+    // Resolve at call time, matching ConfigStore's ZTC_CONFIG_DIR override. This
+    // keeps managed credentials beside the selected config, including test homes.
+    const root = join(profileConfigDir(), 'accounts');
+    return join(root, provider, id);
 }
 /**
  * The {@link AccountSource} for a provider whose credentials live under `dir`.
@@ -126,9 +128,9 @@ export function defaultSourceFor(provider, dir) {
         case 'claude_code':
             return { kind: 'claude_config_dir', path: dir };
         case 'codex_app_server':
-            return { kind: 'codex_home', path: dir };
+            return { kind: 'codex_home', path: resolve(dir) };
         case 'codex_legacy':
-            return { kind: 'codex_auth_file', path: basename(dir) === 'auth.json' ? dir : join(dir, 'auth.json') };
+            return { kind: 'codex_auth_file', path: basename(dir) === 'auth.json' ? resolve(dir) : join(resolve(dir), 'auth.json') };
         case 'claude_code_direct':
             return {
                 kind: 'claude_creds_file',
@@ -162,6 +164,24 @@ export function ensureAccountDir(source) {
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     return dir;
 }
+function canonicalAccountHome(path) {
+    // `.native` returns the on-disk case, so `CodexA` and `codexa` on a
+    // case-insensitive volume resolve to the same credential directory.
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/** A registered Codex profile already reading this same credential directory. */
+export function findCodexHomeCollision(accounts, source) {
+    if (source.kind !== 'codex_home' && source.kind !== 'codex_auth_file')
+        return undefined;
+    const home = canonicalAccountHome(sourceDir(source));
+    return accounts.find((account) => (account.source.kind === 'codex_home' || account.source.kind === 'codex_auth_file')
+        && canonicalAccountHome(sourceDir(account.source)) === home);
+}
 /**
  * Whether an account holds ISOLATED (per-account) credentials. Always probes
  * the account's EXPLICIT path — never the cached default — and for the Claude
@@ -258,6 +278,10 @@ export function warnSharedKeychainAccount(account, keychainPresent = sharedClaud
         + `share that one login — switching or rotating between them has no effect until each `
         + `logs in per-account (/accounts).`);
 }
+/** Quote a path for the displayed POSIX shell command. */
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
 export function buildLoginCommand(account) {
     const source = account.source;
     switch (source.kind) {
@@ -274,11 +298,12 @@ export function buildLoginCommand(account) {
         case 'codex_home':
         case 'codex_auth_file': {
             const dir = sourceDir(source);
+            const args = [...CODEX_SUBSCRIPTION_CONFIG_ARGS, 'login'];
             return {
                 command: 'codex',
-                args: ['login'],
-                env: { ...process.env, CODEX_HOME: dir },
-                display: `CODEX_HOME=${dir} codex login`,
+                args,
+                env: buildCodexAppServerEnv(dir),
+                display: `CODEX_HOME=${shellQuote(dir)} codex ${args.map((arg) => arg === '-c' || arg === 'login' ? arg : shellQuote(arg)).join(' ')}`,
             };
         }
         case 'kimi_creds_file': {

package/dist/agent/backends/account_rotation.d.ts

@@ -11,6 +11,7 @@
 import type { AccountStateStore } from './account_state.js';
 import type { AgentBackend, BackendRequest, BackendResponse, StreamEvent } from './types.js';
 import type { Account } from '../../config/types.js';
+import type { Message } from '../../types.js';
 export type RotationMode = 'failover' | 'round_robin';
 export interface AccountPoolBindings {
     /** Every configured account. */
@@ -99,7 +100,9 @@ export declare class RotatingBackend implements AgentBackend {
      * close() can also dispose one that is still mid-turn.
      */
     private current;
+    private steeringAccepted;
     constructor(opts: RotatingBackendOptions);
+    steerUserMessage(message: Message): Promise<boolean>;
     /** Close a per-turn inner and forget it as current if it still is. */
     private releaseInner;
     /**

package/dist/agent/backends/account_rotation.js

@@ -120,14 +120,23 @@ export class RotatingBackend {
      * close() can also dispose one that is still mid-turn.
      */
     current = null;
+    steeringAccepted = false;
     constructor(opts) {
         this.opts = opts;
         this.now = opts.now ?? (() => Date.now());
     }
+    async steerUserMessage(message) {
+        const accepted = await (this.current?.steerUserMessage?.(message) ?? false);
+        if (accepted)
+            this.steeringAccepted = true;
+        return accepted;
+    }
     /** Close a per-turn inner and forget it as current if it still is. */
     releaseInner(inner) {
-        if (this.current === inner)
+        if (this.current === inner) {
             this.current = null;
+            this.steeringAccepted = false;
+        }
         inner.close?.();
     }
     /**
@@ -220,6 +229,7 @@ export class RotatingBackend {
             if (!account)
                 throw this.terminalError();
             const inner = this.current = this.opts.buildInner(account);
+            this.steeringAccepted = false;
             try {
                 return await inner.generate(req);
             }
@@ -240,7 +250,7 @@ export class RotatingBackend {
                 const next = this.rotate(account, sig);
                 // A dynamic tool already ran this turn -> replaying re-fires its side
                 // effect. Cool the failed account for the next turn, but surface this error.
-                if (replayUnsafe)
+                if (replayUnsafe || this.steeringAccepted)
                     throw error;
                 if (!next)
                     throw this.terminalError();
@@ -263,6 +273,7 @@ export class RotatingBackend {
                 throw this.terminalError();
             let emitted = false;
             const inner = this.current = this.opts.buildInner(account);
+            this.steeringAccepted = false;
             try {
                 // generateStream is required on AgentBackend — no fallback probe.
                 for await (const event of inner.generateStream(req)) {
@@ -288,7 +299,7 @@ export class RotatingBackend {
                 const next = this.rotate(account, sig);
                 // Mid-stream partial output OR a dynamic tool that already ran -> can't
                 // replay cleanly. Pool is rotated for the next turn; surface this error.
-                if (emitted || replayUnsafe)
+                if (emitted || replayUnsafe || this.steeringAccepted)
                     throw error;
                 if (!next)
                     throw this.terminalError();

package/dist/agent/backends/codex_account_status.d.ts

@@ -0,0 +1,42 @@
+export interface CodexQuotaWindow {
+    name: string;
+    remainingPercent: number;
+    resetAt?: number;
+}
+export interface CodexAccountStatus {
+    state: 'ready' | 'reauth_required' | 'quota_unavailable' | 'unavailable';
+    email?: string;
+    plan?: string;
+    windows: CodexQuotaWindow[];
+    observedAt?: number;
+    usage?: {
+        lifetimeTokens?: number;
+        todayTokens?: number;
+        observedAt: number;
+    };
+    usageStale?: boolean;
+}
+export type CodexStatusProbe = (home: string) => Promise<CodexAccountStatus>;
+/**
+ * Minimum spacing between probes of one credential home, even when forced, for
+ * the shared mirror cache. A forced read spawns the Codex App Server and
+ * refreshes the login's token, so repeated refresh clicks (or a looping client)
+ * share one recent probe.
+ */
+export declare const CODEX_STATUS_MIN_FORCED_INTERVAL_MS = 30000;
+/** Cache official Codex status per credential home so a mirror poll does not spawn a CLI each time. */
+export declare class CodexStatusCache {
+    private readonly probe;
+    private readonly entries;
+    private readonly pending;
+    private readonly generations;
+    private readonly minForcedIntervalMs;
+    constructor(probe: CodexStatusProbe, options?: {
+        minForcedIntervalMs?: number;
+    });
+    read(home: string, force?: boolean): Promise<CodexAccountStatus>;
+    invalidate(home: string): void;
+}
+/** Read identity and quota through the official Codex App Server under one isolated CODEX_HOME. */
+export declare function inspectCodexAccount(home: string): Promise<CodexAccountStatus>;
+export declare const codexStatusCache: CodexStatusCache;