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

package/dist/config/defaults.d.ts

@@ -15,6 +15,12 @@ export declare const DEFAULT_CLARIFAI_MODEL = "https://clarifai.com/openai/chat-
  * (factory) and to display the active effort in the model picker.
  */
 export declare function resolveCodexEffort(config: ZTCConfig, provider?: string, model?: string): CodexReasoningEffort | undefined;
+/**
+ * The highest-priority saved effort when the active model rejects it, so the
+ * UI can say the choice is not applied instead of silently falling back.
+ * Undefined when the top choice is supported or nothing is saved.
+ */
+export declare function unsupportedCodexEffort(config: ZTCConfig, provider?: string, model?: string): CodexReasoningEffort | undefined;
 export declare function inferDefaultProvider(): string;
 export declare function getDefaultModelForProvider(provider: string): string;
 export declare function getDefaultApiKeyForProvider(provider: string): string | undefined;

package/dist/config/defaults.js

@@ -4,6 +4,7 @@ import { KIMI_CODE_AUTH_SENTINEL, hasUsableKimiCodeAuth } from '../agent/backend
 import { CODEX_APP_SERVER_SENTINEL, CODEX_LEGACY_PROVIDER, isCodexAppServerProvider, isCodexLegacyProvider } from '../agent/backends/provider_ids.js';
 import { isCodexReasoningEffortSupported } from '../utils/models.js';
 import { DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_MODEL } from '../utils/deepseek.js';
+import { FIREWORKS_FUNDED_MODEL } from '../utils/fireworks.js';
 export const DEFAULT_OPENAI_MODEL = 'gpt-5.4-nano';
 export const DEFAULT_CODEX_MODEL = 'gpt-5.6-sol';
 export const DEFAULT_ANTHROPIC_MODEL = 'claude-opus-5';
@@ -31,6 +32,21 @@ export function resolveCodexEffort(config, provider, model) {
     }
     return undefined;
 }
+/**
+ * The highest-priority saved effort when the active model rejects it, so the
+ * UI can say the choice is not applied instead of silently falling back.
+ * Undefined when the top choice is supported or nothing is saved.
+ */
+export function unsupportedCodexEffort(config, provider, model) {
+    const chosen = [
+        model ? config.codexEffortByModel?.[model] : undefined,
+        provider ? config.codexEffortByProvider?.[provider] : undefined,
+        config.codexEffort,
+    ].find((candidate) => Boolean(candidate));
+    if (!chosen || isCodexReasoningEffortSupported(provider, model, chosen))
+        return undefined;
+    return chosen;
+}
 function has_env_key(name) {
     const value = process.env[name];
     return typeof value === 'string' && value.length > 0;
@@ -44,6 +60,8 @@ export function inferDefaultProvider() {
         return 'gemini';
     if (has_env_key('KIMI_API_KEY') || has_env_key('MOONSHOT_API_KEY'))
         return 'kimi';
+    if (has_env_key('FIREWORKS_API_KEY'))
+        return 'fireworks';
     if (has_env_key('OPENAI_COMPAT_API_KEY'))
         return 'openai_compatible';
     if (has_env_key('INCEPTION_API_KEY'))
@@ -80,6 +98,8 @@ export function getDefaultModelForProvider(provider) {
             return DEFAULT_DEEPSEEK_MODEL;
         case 'modal':
             return MODAL_DEEPSEEK_FLASH_MODEL;
+        case 'fireworks':
+            return FIREWORKS_FUNDED_MODEL;
         case 'clarifai':
             return DEFAULT_CLARIFAI_MODEL;
         case 'openai':

package/dist/config/profiles.d.ts

@@ -0,0 +1,9 @@
+export declare const BUILTIN_CONFIG_PROFILES: readonly ["ztc", "ztc-coder", "ztc-datascience", "scientist"];
+export declare function builtinProfileEmulation(name: string): string | undefined;
+export declare function validateProfileName(name: string): string;
+export declare function activeProfile(): string;
+export declare function profileConfigDir(profile?: string): string;
+/** Profiles live beside the default config. Listing never creates or changes one. */
+export declare function listConfigProfiles(): Promise<string[]>;
+/** Replace a launch's original --profile with the profile selected in this process. */
+export declare function withActiveProfileArg(argv: readonly string[]): string[];

package/dist/config/profiles.js

@@ -0,0 +1,87 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+export const BUILTIN_CONFIG_PROFILES = ['ztc', 'ztc-coder', 'ztc-datascience', 'scientist'];
+export function builtinProfileEmulation(name) {
+    const builtin = BUILTIN_CONFIG_PROFILES.find(profile => profile === name);
+    if (!builtin)
+        return undefined;
+    const root = process.env.ZTC_CONFIG_DIR || join(homedir(), '.ztc');
+    return existsSync(join(root, 'profiles', name)) ? undefined : builtin;
+}
+export function validateProfileName(name) {
+    if (name !== 'default' && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+        throw new Error('Profile name must be 1–64 characters: letters, numbers, dots, underscores, or hyphens; it must start with a letter or number.');
+    }
+    if (name === '.' || name === '..') {
+        throw new Error('Profile name cannot be . or ..');
+    }
+    return name;
+}
+export function activeProfile() {
+    return validateProfileName(process.env.ZTC_PROFILE || 'default');
+}
+export function profileConfigDir(profile = activeProfile()) {
+    const root = process.env.ZTC_CONFIG_DIR || join(homedir(), '.ztc');
+    const name = validateProfileName(profile);
+    if (name === 'default')
+        return root;
+    const namedDir = join(root, 'profiles', name);
+    // Built-in presets share the default config and sign-ins. Preserve an older
+    // explicitly created directory with the same name instead of hiding its data.
+    return builtinProfileEmulation(name) ? root : namedDir;
+}
+/** Profiles live beside the default config. Listing never creates or changes one. */
+export async function listConfigProfiles() {
+    const root = process.env.ZTC_CONFIG_DIR || join(homedir(), '.ztc');
+    let entries;
+    try {
+        entries = await readdir(join(root, 'profiles'), { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return [...BUILTIN_CONFIG_PROFILES, 'default', activeProfile()]
+                .filter((name, index, names) => names.indexOf(name) === index)
+                .sort(profileOrder);
+        }
+        throw error;
+    }
+    const named = entries.filter(entry => entry.isDirectory() && entry.name !== 'default')
+        .map(entry => entry.name)
+        .filter(name => {
+        try {
+            validateProfileName(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    const profiles = new Set([activeProfile(), ...BUILTIN_CONFIG_PROFILES, ...named]);
+    profiles.delete('default');
+    return ['default', ...profiles].sort(profileOrder);
+}
+function profileOrder(left, right) {
+    const rank = (name) => {
+        if (name === 'default')
+            return 0;
+        const index = BUILTIN_CONFIG_PROFILES.findIndex(profile => profile === name);
+        return index < 0 ? Number.MAX_SAFE_INTEGER : index + 1;
+    };
+    return rank(left) - rank(right) || left.localeCompare(right);
+}
+/** Replace a launch's original --profile with the profile selected in this process. */
+export function withActiveProfileArg(argv) {
+    const delimiter = argv.indexOf('--');
+    const flags = delimiter < 0 ? argv : argv.slice(0, delimiter);
+    const retained = [];
+    for (let i = 0; i < flags.length; i++) {
+        if (flags[i] === '--profile') {
+            i += 1;
+            continue;
+        }
+        retained.push(flags[i]);
+    }
+    return [...retained, '--profile', activeProfile(), ...(delimiter < 0 ? [] : argv.slice(delimiter))];
+}

package/dist/config/types.d.ts

@@ -297,6 +297,8 @@ export interface CompactionSettings {
     jev?: JevCompactionSettings;
 }
 export interface ZTCConfig {
+    /** Marks the one-time replacement of pre-preset settings in this profile. */
+    settingsDefaultsVersion?: number;
     /** Configurable terminal status line fields, ordering, separator, and colors. */
     statusLine?: import('../ui/status_line_config.js').StatusLineSettings;
     apiKey?: string;

package/dist/config.d.ts

@@ -12,6 +12,7 @@ export declare function build_default_config(): ZTCConfig;
 export declare function shouldRefreshSuperuserStatus(env?: NodeJS.ProcessEnv): boolean;
 export declare class ConfigStore {
     private config;
+    private profileEmulation;
     private legacyApiKeyFromEnvironment;
     private routerCredentials;
     private routerCredentialsError;
@@ -34,7 +35,11 @@ export declare class ConfigStore {
     private applyEnvOverrides;
     load(force?: boolean): Promise<ZTCConfig>;
     refresh(): Promise<void>;
+    /** Load a profile in this process; restore the old view if runtime activation fails. */
+    switchProfile(name: string, activate: () => void | Promise<void>): Promise<void>;
     save(): Promise<void>;
+    /** Clear the active profile's saved settings and reset this process's settings view. */
+    factoryReset(): Promise<void>;
     get(): ZTCConfig;
     /**
      * The configuration without this process's `--effort` override: the saved
@@ -105,6 +110,8 @@ export declare class ConfigStore {
      * per-model > per-provider > global. Defaults to the current provider/model.
      */
     getCodexEffort(provider?: string, model?: string): CodexReasoningEffort | undefined;
+    /** Saved effort the active (or given) model rejects; undefined when it applies. */
+    getUnsupportedCodexEffort(provider?: string, model?: string): CodexReasoningEffort | undefined;
     /** Effort chosen by a startup `--effort` flag for this process (= none when unset). */
     getCodexEffortOverride(): CodexReasoningEffort | undefined;
     /**

package/dist/config.js

@@ -1,9 +1,10 @@
-import { homedir } from 'os';
 import { join } from 'path';
-import { readFile, writeFile, mkdir, chmod } from 'fs/promises';
+import { readFile, writeFile, mkdir, chmod, unlink, rename, realpath } from 'fs/promises';
+import { randomUUID } from 'crypto';
+import { activeProfile, builtinProfileEmulation, profileConfigDir, validateProfileName } from './config/profiles.js';
 import { accountSourceToBackendOptions, canonicalAccountProvider, probeAccountIsolated, resolveActiveAccount, resolveRotation, } from './agent/backends/account_pool.js';
 import { notifyAccountsChanged } from './agent/backends/account_events.js';
-import { inferDefaultProvider, getDefaultApiKeyForProvider, getDefaultModelForProvider, resolveCodexEffort } from './config/defaults.js';
+import { inferDefaultProvider, getDefaultApiKeyForProvider, getDefaultModelForProvider, resolveCodexEffort, unsupportedCodexEffort } from './config/defaults.js';
 import { resolveRepoModelOverride } from './config/repo_config.js';
 import { CODEX_AUTH_SENTINEL, hasUsableCodexAuth } from './agent/backends/codex_auth.js';
 import { CLAUDE_CODE_AUTH_SENTINEL, hasUsableClaudeCodeCliAuth as hasUsableClaudeCodeAuth } from './agent/backends/claude_cli.js';
@@ -182,21 +183,44 @@ const DEFAULT_WORKFLOWS = {
     maxAgents: 50,
     workflowTimeoutMs: 43_200_000,
 };
+const SETTINGS_DEFAULTS_VERSION = 1;
+const PERSONAL_DEFAULT_PROVIDER = 'modal';
+const PERSONAL_DEFAULT_MODEL = 'deepseek-v4.1-flash';
+const PERSONAL_DEFAULT_PROXY_URL = 'https://zergrouter.com';
+/** Environment variables that already name a working provider route. */
+const ROUTE_CREDENTIAL_ENV = [
+    'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY', 'GEMINI_API_KEY', 'KIMI_API_KEY',
+    'MOONSHOT_API_KEY', 'FIREWORKS_API_KEY', 'OPENAI_COMPAT_API_KEY', 'INCEPTION_API_KEY',
+    'CLARIFAI_API_KEY', 'DEEPSEEK_API_KEY', 'ZTC_AUTH_TOKEN',
+];
+/**
+ * Modal DeepSeek through Zerg Router is the default for a person starting
+ * fresh. The Modal route needs a Router device login, so a process launched
+ * with another credential in its environment (a provider key, or a platform
+ * token as headless hosts pass) keeps the route that credential serves, as
+ * ZTC did before the personal default. Only the environment is consulted, so
+ * the default does not depend on files in the user's home.
+ */
 function default_provider() {
-    return inferDefaultProvider();
+    const hasRouteCredential = ROUTE_CREDENTIAL_ENV.some(name => Boolean(process.env[name]?.trim()));
+    return hasRouteCredential ? inferDefaultProvider() : PERSONAL_DEFAULT_PROVIDER;
 }
 export function build_default_config() {
     const provider = default_provider();
     return {
+        settingsDefaultsVersion: SETTINGS_DEFAULTS_VERSION,
         apiKey: getDefaultApiKeyForProvider(provider),
         apiKeys: undefined,
         provider,
         openaiCompatibleBaseUrl: undefined,
-        model: getDefaultModelForProvider(provider),
+        model: provider === PERSONAL_DEFAULT_PROVIDER ? PERSONAL_DEFAULT_MODEL : getDefaultModelForProvider(provider),
         // Like Codex, leave output limits to the provider unless explicitly set.
         maxTokens: undefined,
         zergEndpoint: undefined,
+        // `auto` routes through the Router once signed in and still honors an
+        // explicit provider with a direct key; `zrouter` would reject that key.
         authMode: 'auto',
+        zergProxyUrl: PERSONAL_DEFAULT_PROXY_URL,
         emulationId: undefined,
         spinnerVerbs: DEFAULT_SPINNER_VERBS,
         toolPermissions: { ...DEFAULT_TOOL_PERMISSIONS },
@@ -238,11 +262,132 @@ export function build_default_config() {
         mcpServers: {},
     };
 }
+/**
+ * The settings this release gives new defaults: the compaction and display
+ * behavior every existing profile adopts once. Everything else a profile saved
+ * (security settings, effort choices, limits, keybindings, the status line) is
+ * the user's and carries over untouched.
+ */
+const ADOPTED_DEFAULT_KEYS = [
+    'autoCompactThreshold',
+    'compactionTargetPercent',
+    'compactionTriggerMode',
+    'compaction',
+    'contextTokenBudget',
+    'autoContinue',
+    'messageDisplay',
+];
+/** Keys that pick the provider route. Replaced together so a route stays coherent. */
+const ROUTING_SETTING_KEYS = [
+    'provider',
+    'model',
+    'authMode',
+    'zergProxyUrl',
+    'zergEndpoint',
+    'apiEnvironment',
+    'zrouterRoutePlan',
+];
+function normalizedOrigin(value) {
+    return value?.trim().replace(/\/+$/, '') || undefined;
+}
+/**
+ * True when the saved provider route can already reach a model: a direct or
+ * platform credential, a subscription or account login, a configured
+ * OpenAI-compatible endpoint, an explicit direct mode, or a router other than
+ * the new default. Only a route that cannot work is replaced by the new
+ * personal default.
+ */
+function savedRouteIsUsable(saved) {
+    if (!saved.provider)
+        return false;
+    const provider = normalizeProviderId(saved.provider);
+    if (saved.authMode === 'direct')
+        return true;
+    const origin = normalizedOrigin(saved.zergProxyUrl);
+    if (origin && origin !== PERSONAL_DEFAULT_PROXY_URL)
+        return true;
+    if (saved.auth?.token)
+        return true;
+    if (saved.apiKey || saved.apiKeys?.[provider] || saved.apiKeys?.[saved.provider])
+        return true;
+    if (getDefaultApiKeyForProvider(provider))
+        return true;
+    if (provider === 'openai_compatible'
+        && (saved.openaiCompatibleBaseUrl || saved.openaiCompatible?.baseUrl))
+        return true;
+    return Boolean(saved.accounts?.accounts?.some(account => normalizeProviderId(account.provider) === provider));
+}
+/**
+ * Adopt this release's new defaults once: the compaction and display settings,
+ * and the Modal route for a profile whose saved route cannot reach a model.
+ * Everything else the profile saved carries over, so the migration can never
+ * widen a security setting or drop a credential.
+ */
+function migrateSettingsDefaults(saved) {
+    const defaults = build_default_config();
+    const migrated = { ...saved, settingsDefaultsVersion: SETTINGS_DEFAULTS_VERSION };
+    const record = migrated;
+    const fresh = defaults;
+    const adopted = savedRouteIsUsable(saved)
+        ? ADOPTED_DEFAULT_KEYS
+        : [...ADOPTED_DEFAULT_KEYS, ...ROUTING_SETTING_KEYS];
+    for (const key of adopted) {
+        if (fresh[key] === undefined)
+            delete record[key];
+        else
+            record[key] = fresh[key];
+    }
+    // The legacy single slot belongs to the saved provider; give it a
+    // provider-scoped home so a later provider change cannot misattribute it.
+    if (saved.apiKey !== undefined) {
+        const oldProvider = saved.provider || inferDefaultProvider();
+        migrated.apiKeys = { [oldProvider]: saved.apiKey, ...saved.apiKeys };
+        delete migrated.apiKey;
+    }
+    return migrated;
+}
+async function writeMigratedSettings(path, settings, original) {
+    // A symlinked config (dotfiles setups) is migrated at its target, so the link
+    // keeps pointing at the file ZTC reads instead of being replaced by a copy.
+    let target = path;
+    try {
+        target = await realpath(path);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    // Keep the pre-migration file once, so a user can recover anything the new
+    // defaults replaced. Never overwrite an earlier backup.
+    try {
+        await writeFile(`${target}.pre-defaults-v${SETTINGS_DEFAULTS_VERSION}.bak`, original, {
+            encoding: 'utf-8', mode: 0o600, flag: 'wx',
+        });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+    const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, JSON.stringify(settings, null, 2), { encoding: 'utf-8', mode: 0o600, flag: 'wx' });
+        await rename(temporary, target);
+    }
+    finally {
+        try {
+            await unlink(temporary);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
 /** Config dir, overridable via ZTC_CONFIG_DIR (test isolation + custom locations).
  * Resolved at call time so a test can point it at a temp dir without import-order
  * games, and so it never writes the real ~/.ztc. */
 function configDir() {
-    return process.env.ZTC_CONFIG_DIR || join(homedir(), '.ztc');
+    return profileConfigDir();
 }
 function configFile() {
     return join(configDir(), 'config.json');
@@ -253,6 +398,7 @@ export function shouldRefreshSuperuserStatus(env = process.env) {
 }
 export class ConfigStore {
     config = build_default_config();
+    profileEmulation = builtinProfileEmulation(activeProfile());
     // The legacy slot also carries runtime defaults. Only a configured key may
     // be migrated into apiKeys or written to disk.
     legacyApiKeyFromEnvironment = true;
@@ -375,6 +521,7 @@ export class ConfigStore {
     async load(force = false) {
         if (this.loaded && !force)
             return this.config;
+        this.profileEmulation = builtinProfileEmulation(activeProfile());
         this.routerCredentialsError = null;
         try {
             this.routerCredentials = await loadRouterCredentials();
@@ -386,46 +533,62 @@ export class ConfigStore {
             this.routerCredentialsError = error instanceof Error ? error
                 : new Error('Invalid ZTC router credentials. Run ztc auth login.');
         }
+        let saved;
+        let savedText = '';
         try {
             const data = await readFile(configFile(), 'utf-8');
-            const saved = JSON.parse(data);
-            this.config = { ...build_default_config(), ...saved };
-            this.legacyApiKeyFromEnvironment = saved.apiKey === undefined;
-            // Defaults were built for the inferred provider. A saved provider without
-            // a saved key must not inherit that other provider's credential.
-            if (saved.provider && saved.apiKey === undefined) {
-                this.config.apiKey = getDefaultApiKeyForProvider(saved.provider);
-            }
-            if (saved.provider && saved.model === undefined) {
-                this.config.model = getDefaultModelForProvider(saved.provider);
-            }
-            if (this.config.model === 'claude-opus-4-5-20250514' || this.config.model === 'claude-opus-4-20250514') {
-                this.config.model = 'claude-opus-5';
+            savedText = data;
+            const parsed = JSON.parse(data);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error('config.json must contain an object');
             }
-            if (!this.config.spinnerVerbs) {
-                this.config.spinnerVerbs = DEFAULT_SPINNER_VERBS;
-            }
-            if (!this.config.toolPermissions) {
-                this.config.toolPermissions = { ...DEFAULT_TOOL_PERMISSIONS };
-            }
-            this.config.permissionProfiles = {
-                ...DEFAULT_PERMISSION_PROFILES,
-                ...(this.config.permissionProfiles || {}),
-            };
-            this.config.permissionProfile = this.config.permissionProfile || 'trusted';
-            this.config.sandbox = { ...DEFAULT_SANDBOX, ...(this.config.sandbox || {}) };
-            this.config.intents = { ...DEFAULT_INTENTS, ...(this.config.intents || {}) };
-            this.config.contextProgressBar = { ...DEFAULT_CONTEXT_PROGRESS_BAR, ...(this.config.contextProgressBar || {}) };
-            this.config.messageDisplay = { ...DEFAULT_MESSAGE_DISPLAY, ...(this.config.messageDisplay || {}) };
-            this.config.compaction = resolveCompactionSettings(this.config);
-            this.applyEnvOverrides();
+            saved = parsed;
         }
         catch {
-            // File doesn't exist or is invalid, use defaults
+            // File doesn't exist or is invalid, use defaults.
             this.config = build_default_config();
             this.legacyApiKeyFromEnvironment = true;
             this.applyEnvOverrides();
+            this.loaded = true;
+            return this.config;
+        }
+        if (typeof saved.settingsDefaultsVersion !== 'number'
+            || saved.settingsDefaultsVersion < SETTINGS_DEFAULTS_VERSION) {
+            const migrated = migrateSettingsDefaults(saved);
+            // A failed write must not make an unmigrated profile appear migrated.
+            await writeMigratedSettings(configFile(), migrated, savedText);
+            saved = migrated;
+        }
+        this.config = { ...build_default_config(), ...saved };
+        this.legacyApiKeyFromEnvironment = saved.apiKey === undefined;
+        // Defaults were built for the preset provider. A saved provider without
+        // a saved key must not inherit that other provider's credential.
+        if (saved.provider && saved.apiKey === undefined) {
+            this.config.apiKey = getDefaultApiKeyForProvider(saved.provider);
         }
+        if (saved.provider && saved.model === undefined) {
+            this.config.model = getDefaultModelForProvider(saved.provider);
+        }
+        if (this.config.model === 'claude-opus-4-5-20250514' || this.config.model === 'claude-opus-4-20250514') {
+            this.config.model = 'claude-opus-5';
+        }
+        if (!this.config.spinnerVerbs) {
+            this.config.spinnerVerbs = DEFAULT_SPINNER_VERBS;
+        }
+        if (!this.config.toolPermissions) {
+            this.config.toolPermissions = { ...DEFAULT_TOOL_PERMISSIONS };
+        }
+        this.config.permissionProfiles = {
+            ...DEFAULT_PERMISSION_PROFILES,
+            ...(this.config.permissionProfiles || {}),
+        };
+        this.config.permissionProfile = this.config.permissionProfile || 'trusted';
+        this.config.sandbox = { ...DEFAULT_SANDBOX, ...(this.config.sandbox || {}) };
+        this.config.intents = { ...DEFAULT_INTENTS, ...(this.config.intents || {}) };
+        this.config.contextProgressBar = { ...DEFAULT_CONTEXT_PROGRESS_BAR, ...(this.config.contextProgressBar || {}) };
+        this.config.messageDisplay = { ...DEFAULT_MESSAGE_DISPLAY, ...(this.config.messageDisplay || {}) };
+        this.config.compaction = resolveCompactionSettings(this.config);
+        this.applyEnvOverrides();
         this.loaded = true;
         return this.config;
     }
@@ -436,6 +599,64 @@ export class ConfigStore {
         this.sessionOverrides = sessionOverrides;
         this.configScope = scope;
     }
+    /** Load a profile in this process; restore the old view if runtime activation fails. */
+    async switchProfile(name, activate) {
+        const next = validateProfileName(name);
+        if (next === activeProfile())
+            return;
+        const sameConfigDirectory = profileConfigDir(next) === profileConfigDir();
+        const target = join(profileConfigDir(next), 'config.json');
+        try {
+            const saved = JSON.parse(await readFile(target, 'utf-8'));
+            if (!saved || typeof saved !== 'object' || Array.isArray(saved)) {
+                throw new Error('config.json must contain an object');
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw new Error(`Cannot load config profile ${next}: ${error.message}`);
+            }
+        }
+        const previousEnv = process.env.ZTC_PROFILE;
+        const previous = {
+            config: this.config,
+            profileEmulation: this.profileEmulation,
+            loaded: this.loaded,
+            legacyApiKeyFromEnvironment: this.legacyApiKeyFromEnvironment,
+            routerCredentials: this.routerCredentials,
+            routerCredentialsError: this.routerCredentialsError,
+            routerFallbackWarning: this.routerFallbackWarning,
+            sessionOverrides: this.sessionOverrides,
+            cliOverrides: this.cliOverrides,
+            runtimeActivePerProvider: this.runtimeActivePerProvider,
+            configScope: this.configScope,
+        };
+        process.env.ZTC_PROFILE = next;
+        if (sameConfigDirectory) {
+            // Preset switches keep the current settings layer, except an explicit
+            // emulation override that would conceal the selected preset.
+            const { emulationId: _emulationId, ...remainingOverrides } = this.sessionOverrides;
+            this.sessionOverrides = remainingOverrides;
+        }
+        else {
+            this.sessionOverrides = {};
+            this.cliOverrides = {};
+            this.runtimeActivePerProvider = {};
+            this.configScope = 'global';
+        }
+        try {
+            await this.load(true);
+            await activate();
+        }
+        catch (error) {
+            if (previousEnv === undefined)
+                delete process.env.ZTC_PROFILE;
+            else
+                process.env.ZTC_PROFILE = previousEnv;
+            Object.assign(this, previous);
+            throw error;
+        }
+    }
     async save() {
         if (this.configScope === 'session') {
             return;
@@ -464,6 +685,23 @@ export class ConfigStore {
             runtimeDiag('error', `Failed to save config: ${err?.message ?? err}`);
         }
     }
+    /** Clear the active profile's saved settings and reset this process's settings view. */
+    async factoryReset() {
+        for (const path of [configFile(), join(configDir(), 'router-auth.json')]) {
+            try {
+                await unlink(path);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        this.sessionOverrides = {};
+        this.cliOverrides = {};
+        this.runtimeActivePerProvider = {};
+        this.configScope = 'global';
+        await this.load(true);
+    }
     get() {
         return this.composeConfig(true);
     }
@@ -478,6 +716,7 @@ export class ConfigStore {
     composeConfig(includeEffortOverride) {
         return {
             ...this.config,
+            ...(this.profileEmulation ? { emulationId: this.profileEmulation } : {}),
             ...this.sessionOverrides,
             ...(includeEffortOverride ? this.cliOverrides : this.cliOverridesWithoutEffort()),
             // Explicit process effort outranks saved scoped defaults without changing them.
@@ -515,7 +754,7 @@ export class ConfigStore {
         }
     }
     set(key, value) {
-        if (this.configScope === 'session') {
+        if (this.configScope === 'session' || (key === 'emulationId' && this.profileEmulation)) {
             this.sessionOverrides[key] = value;
             return;
         }
@@ -606,10 +845,10 @@ export class ConfigStore {
         }
     }
     getEmulationId() {
-        return this.config.emulationId;
+        return this.get().emulationId;
     }
     setEmulationId(id) {
-        this.config.emulationId = id;
+        this.set('emulationId', id);
     }
     getMaskedApiKey() {
         const key = this.getApiKey();
@@ -780,6 +1019,10 @@ export class ConfigStore {
     getCodexEffort(provider, model) {
         return resolveCodexEffort(this.get(), provider ?? this.getProvider(), model ?? this.getModel());
     }
+    /** Saved effort the active (or given) model rejects; undefined when it applies. */
+    getUnsupportedCodexEffort(provider, model) {
+        return unsupportedCodexEffort(this.get(), provider ?? this.getProvider(), model ?? this.getModel());
+    }
     /** Effort chosen by a startup `--effort` flag for this process (= none when unset). */
     getCodexEffortOverride() {
         return this.cliOverrides.codexEffort;

package/dist/headless.js

@@ -668,11 +668,18 @@ export class HeadlessApp {
                                     inputTokens: event.usage.inputTokens,
                                     outputTokens: event.usage.outputTokens,
                                     totalTokens: event.usage.totalTokens,
+                                    ...(event.usage.cachedInputTokens === undefined ? {} : { cachedInputTokens: event.usage.cachedInputTokens }),
                                     estimated: event.usage.estimated === true,
                                 },
                                 ...(typeof event.contextTokens === 'number'
                                     ? { contextTokens: event.contextTokens }
                                     : {}),
+                                ...(typeof event.cacheInputTokens === 'number'
+                                    ? { cacheInputTokens: event.cacheInputTokens }
+                                    : {}),
+                                ...(typeof event.contextCachedInputTokens === 'number'
+                                    ? { contextCachedInputTokens: event.contextCachedInputTokens }
+                                    : {}),
                                 ...(typeof event.contextWindow === 'number'
                                     ? { contextWindow: event.contextWindow }
                                     : {}),
@@ -989,6 +996,13 @@ export class HeadlessApp {
      * Initialize the app
      */
     async init() {
+        // Load the persisted profile before reading any credential signal.
+        // `runHeadless` is a public entry point, so it cannot assume its caller ran
+        // the CLI loader (headless_cli.ts does; direct library callers may not).
+        // Without this the gate below reads unloaded defaults and rejects a profile
+        // whose real credential (for example a Codex subscription auth.json) is on
+        // disk. `load()` is idempotent, so the CLI path is unaffected.
+        await configStore.load();
         // Require either direct provider key or platform auth token.
         if (!configStore.hasApiKey() && !configStore.isAuthenticated()) {
             this.output({

package/dist/panes/model_catalog.d.ts

@@ -1,4 +1,4 @@
-export declare const PANE_PROVIDERS: readonly ["anthropic", "claude_code", "openai", "codex_app_server", "codex_legacy", "gemini", "deepseek", "modal", "kimi", "kimi_code"];
+export declare const PANE_PROVIDERS: readonly ["anthropic", "claude_code", "openai", "codex_app_server", "codex_legacy", "gemini", "deepseek", "fireworks", "modal", "kimi", "kimi_code"];
 export type PaneProvider = typeof PANE_PROVIDERS[number];
 export interface CatalogModel {
     id: string;