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

package/dist/agent/commands/accounts.d.ts

@@ -3,11 +3,17 @@
  * accounts. ztc stores only ids/labels/paths; tokens live in each account's own
  * credential dir, written by the official CLI's own login. Subcommands:
  *
- *   /accounts                 list accounts grouped by provider
+ *   /accounts                 open the account manager (or list in plain output)
  *   /accounts add <provider> <id> [label…] [--path <dir>]
  *   /accounts use <id>        make an account the live one for its provider
  *   /accounts login <id>      run the official CLI login at the account's dir
  *   /accounts remove <id>     drop an account from the pool
  */
 import { Command } from './types.js';
+/**
+ * The account list is written into the transcript, which is saved and mirrored
+ * to every viewer, so the ChatGPT email appears masked: enough to tell two
+ * logins apart, not enough to publish the address.
+ */
+export declare function maskAccountEmail(email: string | undefined): string | undefined;
 export declare const accountsCommand: Command;

package/dist/agent/commands/accounts.js

@@ -3,7 +3,7 @@
  * accounts. ztc stores only ids/labels/paths; tokens live in each account's own
  * credential dir, written by the official CLI's own login. Subcommands:
  *
- *   /accounts                 list accounts grouped by provider
+ *   /accounts                 open the account manager (or list in plain output)
  *   /accounts add <provider> <id> [label…] [--path <dir>]
  *   /accounts use <id>        make an account the live one for its provider
  *   /accounts login <id>      run the official CLI login at the account's dir
@@ -11,9 +11,10 @@
  */
 import { spawnSync } from 'node:child_process';
 import { configStore } from '../../config.js';
-import { buildLoginCommand, canonicalAccountProvider, defaultAccountDir, defaultSourceFor, ensureAccountDir, isAccountProvider, probeAccountUsable, sourceDir, } from '../backends/account_pool.js';
+import { buildLoginCommand, canonicalAccountProvider, defaultAccountDir, defaultSourceFor, ensureAccountDir, findCodexHomeCollision, isAccountProvider, probeAccountUsable, sourceDir, } from '../backends/account_pool.js';
 import { loginAutoRunEnabled, loginFailureReasonText, runLoginCommand } from '../backends/account_login.js';
 import { notifyAccountsChanged } from '../backends/account_events.js';
+import { codexStatusCache } from '../backends/codex_account_status.js';
 import { runKimiDeviceLogin } from '../backends/kimi_code_auth.js';
 const PROVIDER_LABELS = {
     claude_code: 'Claude Code (claude CLI)',
@@ -28,7 +29,8 @@ function say(ctx, content) {
 function usage() {
     return [
         'Usage:',
-        '  /accounts                       list accounts',
+        '  /accounts                       open account manager',
+        '  /accounts list                  print account status',
         '  /accounts add <provider> <id> [label…] [--path <dir>]',
         '  /accounts use <id>              switch the live account for its provider',
         '  /accounts login <id>            sign in an account (official CLI or device flow)',
@@ -38,7 +40,38 @@ function usage() {
         `Providers: ${Object.keys(PROVIDER_LABELS).join(', ')}`,
     ].join('\n');
 }
-function renderList(ctx) {
+/**
+ * The account list is written into the transcript, which is saved and mirrored
+ * to every viewer, so the ChatGPT email appears masked: enough to tell two
+ * logins apart, not enough to publish the address.
+ */
+export function maskAccountEmail(email) {
+    if (!email)
+        return undefined;
+    const at = email.lastIndexOf('@');
+    if (at <= 0)
+        return '***';
+    return `${email[0]}***${email.slice(at)}`;
+}
+async function accountStatusLabel(account) {
+    if (!probeAccountUsable(account))
+        return 'needs login';
+    if (account.source.kind !== 'codex_home')
+        return 'ready';
+    const status = await codexStatusCache.read(account.source.path);
+    if (status.state === 'reauth_required')
+        return 'needs login';
+    const windows = status.windows.map((window) => `${window.name} ${Math.round(window.remainingPercent)}% left`).join(', ');
+    const tokens = status.usage?.lifetimeTokens === undefined
+        ? '' : `${status.usage.lifetimeTokens.toLocaleString()} lifetime tokens${status.usageStale ? ' (old)' : ''}`;
+    if (status.state === 'unavailable')
+        return windows ? `account unverified; last observed ${windows}` : 'account unverified';
+    const email = maskAccountEmail(status.email);
+    if (status.state === 'quota_unavailable')
+        return [email, 'quota stale', windows, tokens].filter(Boolean).join('; ');
+    return [email, windows, tokens].filter(Boolean).join('; ') || 'ready';
+}
+async function renderList(ctx) {
     const accounts = configStore.listAccounts();
     if (accounts.length === 0) {
         say(ctx, `No accounts configured.\n\n${usage()}`);
@@ -57,13 +90,13 @@ function renderList(ctx) {
         lines.push('', PROVIDER_LABELS[key] ?? key);
         for (const account of group) {
             const marker = active?.id === account.id ? '*' : ' ';
-            const usable = probeAccountUsable(account) ? 'ready' : 'needs login';
+            const usable = await accountStatusLabel(account);
             lines.push(`  ${marker} ${account.id} — ${account.label} [${usable}]`);
             lines.push(`      ${account.source.kind}: ${account.source.path}`);
         }
     }
     const rotation = configStore.getRotation();
-    lines.push('', `* = live account for that provider.   Auto-rotate: ${rotation.enabled ? `ON (${rotation.mode})` : 'off'}`);
+    lines.push('', `* = live account for that provider.   Auto-rotate (Claude/Kimi only): ${rotation.enabled ? `ON (${rotation.mode})` : 'off'}. Codex switches only when you choose an account.`);
     say(ctx, lines.join('\n'));
 }
 function parseAdd(args) {
@@ -88,29 +121,41 @@ function parseAdd(args) {
     }
     return { provider, id, label: labelParts.join(' ') || id, path };
 }
-async function handleAdd(args, ctx) {
-    const parsed = parseAdd(args);
-    if (typeof parsed === 'string') {
-        say(ctx, parsed);
-        return;
-    }
+async function addAccount(parsed) {
     if (configStore.getAccount(parsed.id)) {
-        say(ctx, `An account with id "${parsed.id}" already exists. Remove it first or pick another id.`);
-        return;
+        return { error: 'duplicate_id', message: `An account with id "${parsed.id}" already exists. Remove it first or pick another id.` };
     }
     const dir = parsed.path ?? defaultAccountDir(parsed.provider, parsed.id);
     const source = defaultSourceFor(parsed.provider, dir);
+    const collision = findCodexHomeCollision(configStore.listAccounts(), source);
+    if (collision) {
+        return { error: 'codex_home_collision', message: `That Codex credential home is already used by "${collision.label}". Choose another path.` };
+    }
     ensureAccountDir(source);
     const account = { id: parsed.id, label: parsed.label, provider: parsed.provider, source };
     configStore.addAccount(account);
     await configStore.save();
+    return { account };
+}
+async function handleAdd(args, ctx) {
+    const parsed = parseAdd(args);
+    if (typeof parsed === 'string') {
+        say(ctx, parsed);
+        return;
+    }
+    const result = await addAccount(parsed);
+    if ('error' in result) {
+        say(ctx, result.message);
+        return;
+    }
+    const { account } = result;
     const ready = probeAccountUsable(account);
     const next = ready
         ? `Already has credentials. Use it with: /accounts use ${account.id}`
         : `Sign in with: /accounts login ${account.id}`;
     say(ctx, [
         `Added "${account.label}" (${account.id}) for ${PROVIDER_LABELS[account.provider]}.`,
-        `  ${source.kind}: ${source.path}`,
+        `  ${account.source.kind}: ${account.source.path}`,
         next,
     ].join('\n'));
 }
@@ -125,6 +170,15 @@ async function handleUse(args, ctx) {
         say(ctx, `No account "${id}". See /accounts.`);
         return;
     }
+    if (account.source.kind === 'codex_home') {
+        const status = await codexStatusCache.read(account.source.path, true);
+        if (status.state === 'reauth_required' || status.state === 'unavailable') {
+            say(ctx, status.state === 'reauth_required'
+                ? `"${account.label}" needs a fresh ChatGPT sign-in. Run /accounts login ${account.id}, then switch again.`
+                : `"${account.label}" could not be verified. Refresh its status or sign in, then switch again.`);
+            return;
+        }
+    }
     configStore.setActiveAccount(account.provider, account.id);
     await configStore.save();
     const accountKey = canonicalAccountProvider(account.provider);
@@ -138,7 +192,7 @@ async function handleUse(args, ctx) {
         say(ctx, `Switched live ${PROVIDER_LABELS[account.provider]} account to "${account.label}".`);
     }
     else {
-        say(ctx, `Set "${account.label}" active for ${PROVIDER_LABELS[account.provider]}. It goes live when you switch to that provider (/model or /provider).`);
+        say(ctx, `Set "${account.label}" active for ${PROVIDER_LABELS[account.provider]}. It goes live when you switch to that provider with /model.`);
     }
 }
 async function handleLogin(args, ctx) {
@@ -216,6 +270,15 @@ async function handleLogin(args, ctx) {
         say(ctx, `Signing in "${account.label}" on the ztc host — complete it in the browser…`);
         const attempt = await runLoginCommand(login, () => probeAccountUsable(account));
         if (attempt.outcome === 'succeeded') {
+            if (account.source.kind === 'codex_home') {
+                codexStatusCache.invalidate(account.source.path);
+                const status = await codexStatusCache.read(account.source.path, true);
+                if (status.state === 'reauth_required' || status.state === 'unavailable') {
+                    notifyAccountsChanged();
+                    say(ctx, `"${account.label}" saved credentials, but the ChatGPT subscription could not be verified. Run /accounts login ${account.id} again.`);
+                    return;
+                }
+            }
             notifyAccountsChanged();
             say(ctx, `"${account.label}" is signed in. Make it live with: /accounts use ${account.id}`);
         }
@@ -235,7 +298,12 @@ async function handleLogin(args, ctx) {
         ].join('\n'));
         return;
     }
-    const ready = probeAccountUsable(account);
+    let ready = probeAccountUsable(account);
+    if (ready && account.source.kind === 'codex_home') {
+        codexStatusCache.invalidate(account.source.path);
+        const status = await codexStatusCache.read(account.source.path, true);
+        ready = status.state === 'ready' || status.state === 'quota_unavailable';
+    }
     say(ctx, ready
         ? `"${account.label}" is signed in. Make it live with: /accounts use ${account.id}`
         : `Login exited without usable credentials in ${sourceDir(account.source)}. Try again: /accounts login ${account.id}`);
@@ -244,7 +312,8 @@ function describeRotation() {
     const r = configStore.getRotation();
     const hours = (ms) => `${Math.round((ms / 3_600_000) * 10) / 10}h`;
     return [
-        `Auto-rotate: ${r.enabled ? 'ON' : 'off'}`,
+        `Auto-rotate (Claude/Kimi): ${r.enabled ? 'ON' : 'off'}`,
+        '  Codex: manual selection only',
         `  mode:      ${r.mode}`,
         `  subagents: ${r.subagentInheritance}`,
         `  cooldowns: default ${hours(r.defaultCooldownMs)}, weekly ${hours(r.weeklyCooldownMs)}`,
@@ -303,86 +372,212 @@ async function handleRemove(args, ctx) {
     await configStore.save();
     say(ctx, `Removed "${account.label}" (${id}) from the pool. Its credential dir was left in place:\n  ${sourceDir(account.source)}`);
 }
-// --- interactive CLI modal (real terminal only; text list elsewhere) ---
-function interactiveAddForm(ctx) {
-    ctx.form.showForm({
-        title: 'Add account',
-        submitLabel: 'Add',
-        fields: [
-            {
-                name: 'provider',
-                label: 'Provider',
-                type: 'select',
-                options: Object.keys(PROVIDER_LABELS).map((id) => ({ value: id, label: PROVIDER_LABELS[id] })),
-                defaultValue: 'claude_code',
+// --- interactive terminal settings page (text list in non-interactive output) ---
+function accountFamily(provider) {
+    if (provider.startsWith('claude_code'))
+        return 'Claude';
+    if (provider.startsWith('codex_'))
+        return 'Codex';
+    return 'Kimi';
+}
+function interactiveAddPage(ctx, provider) {
+    const selected = configStore.getProvider();
+    const draft = {
+        provider: provider ?? (isAccountProvider(selected) ? selected : 'claude_code'),
+        id: '', label: '', path: '',
+    };
+    const originalFamily = provider ? accountFamily(provider) : undefined;
+    const showAccounts = (family) => {
+        void runInteractive(ctx, family).catch((error) => say(ctx, `Could not open Accounts: ${String(error)}`));
+    };
+    const back = () => showAccounts(originalFamily);
+    let error = '';
+    let errorField;
+    let pending = false;
+    const showPage = (initialSetting) => {
+        const title = originalFamily ? `Add ${accountFamily(draft.provider)} account` : 'Add account';
+        ctx.settingsPanel?.showSettingsPanel({
+            title,
+            layout: 'page',
+            notice: error,
+            initialSetting,
+            categories: [
+                {
+                    name: 'Account',
+                    settings: [
+                        {
+                            name: 'provider', label: 'Provider', value: draft.provider, type: 'select',
+                            options: Object.keys(PROVIDER_LABELS)
+                                .map(id => ({ value: id, label: PROVIDER_LABELS[id] })),
+                            description: 'Choose a provider for sign-in.',
+                        },
+                        { name: 'id', label: 'Account ID', value: draft.id, type: 'text', placeholder: 'work',
+                            formatValue: value => value || '(required)',
+                            description: 'Unique name used to switch.' },
+                        { name: 'label', label: 'Label', value: draft.label, type: 'text', placeholder: 'Optional',
+                            formatValue: value => value || '(uses ID)',
+                            description: 'Optional name shown in Accounts.' },
+                        { name: 'path', label: 'Credential directory', value: draft.path, type: 'text', placeholder: 'Automatic',
+                            formatValue: value => value || 'Automatic',
+                            description: 'Blank creates an isolated profile.' },
+                        {
+                            name: 'create', label: 'Create account', value: '', type: 'text',
+                            formatValue: () => '↵',
+                            description: 'Save now; sign in from Accounts.',
+                            onActivate: () => {
+                                if (pending)
+                                    return;
+                                const id = draft.id.trim();
+                                if (!id) {
+                                    error = 'Account ID required';
+                                    errorField = 'id';
+                                    showPage('id');
+                                    return;
+                                }
+                                pending = true;
+                                void addAccount({
+                                    provider: draft.provider,
+                                    id,
+                                    label: draft.label.trim() || id,
+                                    path: draft.path.trim() || undefined,
+                                }).then(result => {
+                                    if ('error' in result) {
+                                        error = result.error === 'duplicate_id' ? 'Account ID already exists' : 'Credential directory in use';
+                                        errorField = result.error === 'duplicate_id' ? 'id' : 'path';
+                                        showPage(errorField);
+                                    }
+                                    else {
+                                        showAccounts(accountFamily(result.account.provider));
+                                    }
+                                }).catch((cause) => {
+                                    error = `Could not add account: ${String(cause)}`;
+                                    errorField = 'create';
+                                    showPage('create');
+                                }).finally(() => { pending = false; });
+                            },
+                        },
+                        { name: 'back', label: 'Back to accounts', value: '', type: 'text',
+                            formatValue: () => '↵', description: 'Return without saving.', onActivate: back },
+                    ],
+                },
+            ],
+            onSettingChange: (name, value) => {
+                const changedProvider = name === 'provider' && isAccountProvider(value);
+                if (changedProvider) {
+                    draft.provider = value;
+                }
+                else if (name === 'id')
+                    draft.id = value;
+                else if (name === 'label')
+                    draft.label = value;
+                else if (name === 'path')
+                    draft.path = value;
+                const resolvedError = Boolean(error) && (name === errorField || (changedProvider && errorField === 'path'));
+                if (resolvedError) {
+                    error = '';
+                    errorField = undefined;
+                }
+                if (changedProvider)
+                    showPage('id');
+                else if (resolvedError)
+                    showPage(name);
             },
-            { name: 'id', label: 'Account id (e.g. work)', type: 'text' },
-            { name: 'label', label: 'Label (optional)', type: 'text' },
-            { name: 'path', label: 'Credential dir (optional — reuse an existing one)', type: 'text' },
-        ],
-    }, async (values) => {
-        if (!values.id) {
-            // Empty values map = cancelled (browser × or terminal ESC), or a submit
-            // with no id. Either way nothing is added; don't frame it as an error.
-            say(ctx, 'Add cancelled (no account id given).');
-            return;
-        }
-        const args = [values.provider, values.id];
-        if (values.label)
-            args.push(...values.label.split(/\s+/));
-        if (values.path)
-            args.push('--path', values.path);
-        await handleAdd(args, ctx);
-    });
+            onClose: back,
+        });
+    };
+    showPage();
 }
-function runInteractive(ctx) {
+async function runInteractive(ctx, focus) {
     const accounts = configStore.listAccounts();
-    const options = accounts.map((account) => {
-        const active = configStore.getActiveAccount(account.provider)?.id === account.id;
-        const ready = probeAccountUsable(account) ? 'ready' : 'needs login';
-        return {
-            value: `acct:${account.id}`,
-            label: `${active ? '● ' : '  '}${account.label} (${account.id}) — ${ready}`,
-            description: PROVIDER_LABELS[account.provider],
+    const families = [
+        { name: 'Claude', provider: 'claude_code', matches: account => account.provider.startsWith('claude_code') },
+        { name: 'Codex', provider: 'codex_app_server', matches: account => account.provider.startsWith('codex_') },
+        { name: 'Kimi', provider: 'kimi_code', matches: account => account.provider === 'kimi_code' },
+    ];
+    const categories = await Promise.all(families.map(async (family) => {
+        const group = accounts.filter(family.matches);
+        const statuses = await Promise.all(group.map(accountStatusLabel));
+        const refresh = () => { void runInteractive(ctx, family.name); };
+        const runAction = (action) => {
+            void action().catch((error) => say(ctx, `Account action failed: ${String(error)}`)).finally(refresh);
         };
-    });
-    options.push({ value: 'add', label: '+ Add account', description: 'Register a new account' });
-    ctx.select.showSelect({ title: 'Accounts', question: 'Pick an account or add one', type: 'select', options }, (value) => {
-        if (value === null)
-            return;
-        const choice = Array.isArray(value) ? value[0] : value;
-        if (choice === 'add') {
-            interactiveAddForm(ctx);
-            return;
-        }
-        const id = choice.startsWith('acct:') ? choice.slice('acct:'.length) : choice;
-        ctx.select.showSelect({
-            title: id,
-            question: `Action for "${id}"`,
-            type: 'select',
-            options: [
-                { value: 'use', label: 'Use (make live for its provider)' },
-                { value: 'login', label: 'Login (sign in)' },
-                { value: 'remove', label: 'Remove from pool' },
+        return {
+            name: family.name,
+            settings: [
+                {
+                    name: `add:${family.name}`,
+                    label: `+ Add ${family.name} account`,
+                    value: '',
+                    type: 'text',
+                    description: 'Keep another account signed in for a quick manual switch.',
+                    onActivate: () => interactiveAddPage(ctx, family.provider),
+                },
+                ...(family.name === 'Codex' ? [{
+                        name: 'refresh:Codex',
+                        label: 'Refresh Codex status',
+                        value: '',
+                        type: 'text',
+                        description: 'Check sign-in, quota, and token activity again for every Codex account.',
+                        onActivate: () => runAction(async () => {
+                            await Promise.all(group.filter(account => account.source.kind === 'codex_home')
+                                .map(account => codexStatusCache.read(account.source.path, true)));
+                        }),
+                    }] : []),
+                ...group.flatMap((account, index) => {
+                    const active = configStore.getActiveAccount(account.provider)?.id === account.id;
+                    const status = statuses[index];
+                    return [
+                        {
+                            name: `use:${account.id}`,
+                            label: `${active ? '● ' : ''}${account.label}`,
+                            value: `${active ? 'In use · ' : ''}${status}`,
+                            type: 'text',
+                            description: `${PROVIDER_LABELS[account.provider]} · ${account.id} · ${sourceDir(account.source)}. Enter to use this account.`,
+                            onActivate: () => runAction(() => handleUse([account.id], ctx)),
+                        },
+                        {
+                            name: `login:${account.id}`,
+                            label: `Sign in · ${account.label}`,
+                            value: '',
+                            type: 'text',
+                            description: 'Refresh this account’s sign-in without signing out the others.',
+                            onActivate: () => runAction(() => handleLogin([account.id], ctx)),
+                        },
+                        {
+                            name: `remove:${account.id}`,
+                            label: `Remove · ${account.label}`,
+                            value: '',
+                            type: 'text',
+                            description: 'Forget this account. Its credential directory stays on disk.',
+                            onActivate: () => ctx.settingsPanel?.showSettingsPanel({
+                                title: `Remove ${account.label}?`,
+                                categories: [{ name: 'Confirm removal', settings: [
+                                            {
+                                                name: 'keepAccount', label: 'Keep account', value: '', type: 'text',
+                                                onActivate: refresh,
+                                            },
+                                            {
+                                                name: 'confirmRemoveAccount', label: `Remove ${account.label}`, value: '', type: 'text',
+                                                description: 'The credential directory stays on disk.',
+                                                onActivate: () => runAction(() => handleRemove([account.id], ctx)),
+                                            },
+                                        ] }],
+                                onSettingChange: () => { },
+                                onClose: refresh,
+                            }),
+                        },
+                    ];
+                }),
             ],
-        }, async (action) => {
-            if (action === null)
-                return;
-            const act = Array.isArray(action) ? action[0] : action;
-            switch (act) {
-                case 'use':
-                    await handleUse([id], ctx);
-                    return;
-                case 'login':
-                    handleLogin([id], ctx);
-                    return;
-                case 'remove':
-                    await handleRemove([id], ctx);
-                    return;
-                default:
-                    say(ctx, `Unknown action "${act}".`);
-            }
-        });
+        };
+    }));
+    const provider = configStore.getProvider();
+    const defaultFocus = provider.startsWith('codex_') ? 'Codex'
+        : provider.startsWith('claude_code') ? 'Claude'
+            : provider === 'kimi_code' ? 'Kimi' : undefined;
+    ctx.settingsPanel?.showSettingsPanel({
+        title: 'Accounts', categories, initialCategory: focus ?? defaultFocus,
+        onSettingChange: () => { },
     });
 }
 export const accountsCommand = {
@@ -397,23 +592,26 @@ export const accountsCommand = {
                 // auto-starts in every interactive session, so `isRunning()` is almost
                 // always true — gating on it sent `/accounts` to the browser even when no
                 // browser was open, so the terminal showed nothing. `hasViewers()` is true
-                // only when a browser is really watching: then open the rich panel there;
-                // otherwise fall back to the terminal picker (TTY) or a text list.
+                // only when a browser is really watching: then open Settings there;
+                // otherwise use the settings surface (terminal or parent mirror) or a text list.
                 if (ctx.mirror?.hasViewers?.()) {
-                    ctx.mirror.publish?.({ type: 'open_accounts', data: {} });
+                    ctx.mirror.publish?.({ type: 'settings_page', data: { title: 'Settings', filter: 'accounts' } });
                 }
-                else if (process.stdout.isTTY) {
-                    runInteractive(ctx);
+                else if (ctx.settingsPanel) {
+                    await runInteractive(ctx);
                 }
                 else {
-                    renderList(ctx);
+                    await renderList(ctx);
                 }
                 return;
             case 'list':
-                renderList(ctx);
+                await renderList(ctx);
                 return;
             case 'add':
-                await handleAdd(rest, ctx);
+                if (rest.length === 0 && ctx.settingsPanel)
+                    interactiveAddPage(ctx);
+                else
+                    await handleAdd(rest, ctx);
                 return;
             case 'use':
             case 'switch':

package/dist/agent/commands/config.js

@@ -1,7 +1,7 @@
 import { DEFAULT_SPINNER_VERBS, formatSpinnerVerbs, parseSpinnerVerbs } from '../../utils/spinner_verbs.js';
 import { CODEX_REASONING_EFFORTS, } from '../../config/types.js';
 import { runOpenAICompatibleWizard } from './openai_compat_wizard.js';
-import { settingsCommand } from './settings.js';
+import { openFactoryResetConfirmation, settingsCommand } from './settings.js';
 import { contextProgressBarConfig, normalizeBarColor, publishContextProgressBar, withBarColor, } from './context_progress_bar.js';
 import { compatEndpoint, DEFAULT_CONTEXT_PROGRESS_BAR } from '../../config.js';
 import { parseGoalTurnCap } from './goal.js';
@@ -116,7 +116,7 @@ const STATUS_LINE_USAGE = [
 export const configCommand = {
     name: 'config',
     description: 'Manage configuration',
-    usage: '[show|scope|local|global|key|provider|endpoint|openai-compat|auth-mode|model|effort|display|spinner|statusline|goal-max-turns|manifests-dir|context-progress-bar|workflows] [value]',
+    usage: '[show|reset|scope|local|global|key|provider|endpoint|openai-compat|auth-mode|model|effort|display|spinner|statusline|goal-max-turns|manifests-dir|context-progress-bar|workflows] [value]',
     agentRunnable: true,
     category: 'config',
     handler: async (args, ctx) => {
@@ -139,6 +139,14 @@ export const configCommand = {
             return;
         }
         switch (subCmd) {
+            case 'reset': {
+                if (rest.length > 0) {
+                    ctx.addMessage({ role: 'system', content: 'Usage: /config reset' });
+                    return;
+                }
+                openFactoryResetConfirmation(ctx);
+                return;
+            }
             case 'scope': {
                 const current = ctx.config.getConfigScope?.() || 'global';
                 const requested = value.trim().toLowerCase();
@@ -498,7 +506,7 @@ Usage: /config zrouter-url <url|clear>` });
                     }
                     ctx.addMessage({
                         role: 'system',
-                        content: `Models (${provider})\nCurrent model: ${currentModel}\n\nUsage: /model <model-name>${modelListSuffix}`
+                        content: `Models (${provider})\nCurrent model: ${currentModel}\n\nUsage: /model <model-name> or /model <provider> [model-name]${modelListSuffix}`
                     });
                     return;
                 }

package/dist/agent/commands/config_profile_switch.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from './types.js';
+export declare function switchConfigProfile(ctx: CommandContext, requested: string, allowNew?: boolean): Promise<void>;

package/dist/agent/commands/config_profile_switch.js

@@ -0,0 +1,22 @@
+import { mkdir } from 'node:fs/promises';
+import { activeProfile, builtinProfileEmulation, listConfigProfiles, profileConfigDir, validateProfileName } from '../../config/profiles.js';
+export async function switchConfigProfile(ctx, requested, allowNew = false) {
+    const name = validateProfileName(requested.trim());
+    if (!ctx.switchConfigProfile) {
+        throw new Error('This renderer cannot switch config profiles in place.');
+    }
+    if (!allowNew && !(await listConfigProfiles()).includes(name)) {
+        throw new Error(`Config profile "${name}" does not exist. Use /profile create ${name} to start a new one.`);
+    }
+    if (allowNew && (name === 'default' || builtinProfileEmulation(name))) {
+        throw new Error(`Config profile "${name}" is built in. Use /profile ${name} to select it.`);
+    }
+    if (allowNew && name !== 'default')
+        await mkdir(profileConfigDir(name), { recursive: true, mode: 0o700 });
+    if (name === activeProfile()) {
+        ctx.addMessage({ role: 'system', content: `Already using config profile ${name}.` });
+        return;
+    }
+    await ctx.switchConfigProfile(name);
+    ctx.addMessage({ role: 'system', content: `Switched to config profile ${name} in this session.` });
+}

package/dist/agent/commands/context.js

@@ -113,11 +113,12 @@ export const contextCommand = {
         // 0% would read as a cold prefix when the truth is "no telemetry".
         if (!estimated) {
             const cached = ctx.getCachedInputTokens?.();
-            const hitRate = cacheHitRate(cached, usedTokens);
+            const cacheInput = ctx.getCacheInputTokens?.() ?? usedTokens;
+            const hitRate = cacheHitRate(cached, cacheInput);
             if (hitRate !== undefined && cached !== undefined) {
                 lines.push('');
-                lines.push('Prompt cache (this turn):');
-                lines.push(`  ${hitRate.toFixed(0)}% served from cache (${formatTokens(cached)} of ${formatTokens(usedTokens)} input tokens)`);
+                lines.push('Prompt cache (last model call):');
+                lines.push(`  ${hitRate.toFixed(0)}% served from cache (${formatTokens(cached)} of ${formatTokens(cacheInput)} input tokens)`);
             }
         }
         // Approximate composition — estimate only, for orientation. The authoritative