@zergai/ztc 0.2.6-dev.36102446685 → 0.3.0-beta.1

package/dist/agent/commands/index.js

@@ -13,7 +13,6 @@ import { shellCommand, cdCommand } from './shell.js';
 import { clipboardCommand } from './clipboard.js';
 import { modelsCommand } from './models.js';
 import { modelCommand } from './model.js';
-import { providerCommand } from './provider.js';
 import { permissionsCommand } from './permissions.js';
 import { skillsCommand } from './skills.js';
 import { retryCommand } from './retry.js';
@@ -66,7 +65,7 @@ import { effortCommand, thinkingCommand, fastCommand } from './effort.js';
 import { runtimePluginRegistry } from '../../plugin/runtime_registry.js';
 const commandList = [];
 const helpCommand = makeHelpCommand(() => commandList);
-commandList.push(helpCommand, authCommand, loginCommand, logoutCommand, accountsCommand, zergCommand, zergsCommand, configCommand, debugCommand, clearCommand, statusCommand, runtimeCommand, hooksCommand, emulationCommand, shellCommand, cdCommand, clipboardCommand, modelsCommand, modelCommand, providerCommand, permissionsCommand, initCommand, forkCommand, sideCommand, diffCommand, rawCommand, themeCommand, doctorCommand, intentCommand, profileCommand, skillsCommand, keybindingsCommand, keymapCommand, shortcutsCommand, updateCommand, restartCommand, reloadCommand, inputModeCommand, retryCommand, dictationStatusCommand, embeddedCommand, benchCommand, voiceCommand, sfxCommand, compactCommand, automodeCommand, sessionsCommand, resumeCommand, renameCommand, contextCommand, shannonRunnerCommand, planCommand, executeCommand, modeCommand, modeListCommand, exitModeCommand, validateCommand, previewCommand, saveCommand, dcaigCommand, manifestCommand, swarmCommand, swarmStopCommand, swarmStatusCommand, superviseCommand, superviseStopCommand, superviseStatusCommand, zlickyCommand, zlickyStopCommand, zlickyStatusCommand, zlickyActCommand, zlickyPresenceCommand, zlickyPttCommand, simCommand, simStopCommand, simStatusCommand, simRunCommand, simCheckpointCommand, simResumeCommand, evolveCommand, evolveStopCommand, evolveStatusCommand, evolveBestCommand, optimizeCommand, batchCommand, batchStatusCommand, batchStopCommand, workflowsCommand, mirrorCommand, settingsCommand, mcpCommand, loopCommand, goalCommand, effortCommand, thinkingCommand, fastCommand, exitCommand);
+commandList.push(helpCommand, authCommand, loginCommand, logoutCommand, accountsCommand, zergCommand, zergsCommand, configCommand, debugCommand, clearCommand, statusCommand, runtimeCommand, hooksCommand, emulationCommand, shellCommand, cdCommand, clipboardCommand, modelsCommand, modelCommand, permissionsCommand, initCommand, forkCommand, sideCommand, diffCommand, rawCommand, themeCommand, doctorCommand, intentCommand, profileCommand, skillsCommand, keybindingsCommand, keymapCommand, shortcutsCommand, updateCommand, restartCommand, reloadCommand, inputModeCommand, retryCommand, dictationStatusCommand, embeddedCommand, benchCommand, voiceCommand, sfxCommand, compactCommand, automodeCommand, sessionsCommand, resumeCommand, renameCommand, contextCommand, shannonRunnerCommand, planCommand, executeCommand, modeCommand, modeListCommand, exitModeCommand, validateCommand, previewCommand, saveCommand, dcaigCommand, manifestCommand, swarmCommand, swarmStopCommand, swarmStatusCommand, superviseCommand, superviseStopCommand, superviseStatusCommand, zlickyCommand, zlickyStopCommand, zlickyStatusCommand, zlickyActCommand, zlickyPresenceCommand, zlickyPttCommand, simCommand, simStopCommand, simStatusCommand, simRunCommand, simCheckpointCommand, simResumeCommand, evolveCommand, evolveStopCommand, evolveStatusCommand, evolveBestCommand, optimizeCommand, batchCommand, batchStatusCommand, batchStopCommand, workflowsCommand, mirrorCommand, settingsCommand, mcpCommand, loopCommand, goalCommand, effortCommand, thinkingCommand, fastCommand, exitCommand);
 export const commands = commandList;
 export function refreshPluginCommands() {
     const existing = new Set(commandList.map(command => command.name));

package/dist/agent/commands/input_mode.js

@@ -1,6 +1,6 @@
 export const inputModeCommand = {
     name: 'inputmode',
-    description: 'Set input mode while an agent is running',
+    description: 'Set busy Enter behavior: queue sends after the next tool, interrupt restarts the turn; Tab queues after the turn',
     usage: '<queue|interrupt>',
     handler: (args, ctx) => {
         const mode = (args[0] || '').toLowerCase();

package/dist/agent/commands/model.js

@@ -1,16 +1,21 @@
 import { configCommand } from './config.js';
 import { modelsCommand } from './models.js';
+import { canonicalProvider } from './provider_choices.js';
+import { selectProviderModel } from './provider_selection.js';
 const MODEL_SUBCOMMANDS = ['list', 'latest', 'set'];
 export const modelCommand = {
     name: 'model',
-    description: 'Set model, or use list/latest/set as alias for /models',
-    usage: '<model-id|list [provider]|latest [provider]|set <model-id>>',
+    description: 'Select provider and model, or set a model on the current provider',
+    usage: '<provider> [model] | zergrouter <provider> [model] | <model-id> | list [provider] | latest [provider] | set <model-id>',
     agentRunnable: true,
     category: 'config',
     handler: (args, ctx) => {
         if (args.length > 0 && MODEL_SUBCOMMANDS.includes(args[0].toLowerCase())) {
             return modelsCommand.handler(args, ctx);
         }
+        if (args.length > 1 || (args.length === 1 && canonicalProvider(args[0]))) {
+            return selectProviderModel(args, ctx);
+        }
         return configCommand.handler(['model', ...args], ctx);
     }
 };

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

@@ -74,6 +74,18 @@ export declare const planCommand: Command;
  * Commit plan: extract tasks, exit plan mode, begin implementation
  */
 export declare function commitPlan(planFile: string, planContent: string, tasks: string[], ctx: CommandContext, autoApprove: boolean): void;
+export type PlanApprovalDecision = {
+    kind: 'approve';
+} | {
+    kind: 'edit';
+} | {
+    kind: 'cancel';
+} | {
+    kind: 'feedback';
+    text: string;
+};
+/** Both plan entry points ask through the same question surface and answer shape. */
+export declare function askPlanApproval(ctx: CommandContext, onDecision: (decision: PlanApprovalDecision) => void): void;
 /**
  * /execute command - Exit plan mode and begin implementation
  *

package/dist/agent/commands/plan.js

@@ -473,6 +473,39 @@ ${planContent}`,
         });
     }
 }
+/** Both plan entry points ask through the same question surface and answer shape. */
+export function askPlanApproval(ctx, onDecision) {
+    const approveLabel = 'Yes, begin implementation (Recommended)';
+    const editLabel = 'Edit plan first';
+    ctx.questionnaire.showQuestionnaire({
+        title: 'Plan Approval',
+        questions: [{
+                name: 'decision',
+                question: 'Ready to begin implementation?',
+                type: 'select',
+                required: true,
+                options: [
+                    { value: 'approve', label: approveLabel, description: 'Approve the plan, create tasks, and start coding' },
+                    { value: 'edit', label: editLabel, description: 'Return to plan mode and continue editing' },
+                ],
+            }],
+        allowOther: true,
+    }, answers => {
+        const answer = answers?.decision;
+        if (typeof answer !== 'string' || !answer.trim()) {
+            onDecision({ kind: 'cancel' });
+        }
+        else if (answer === 'approve' || answer === approveLabel) {
+            onDecision({ kind: 'approve' });
+        }
+        else if (answer === 'edit' || answer === editLabel) {
+            onDecision({ kind: 'edit' });
+        }
+        else {
+            onDecision({ kind: 'feedback', text: answer.trim() });
+        }
+    });
+}
 /**
  * /execute command - Exit plan mode and begin implementation
  *
@@ -525,54 +558,32 @@ Tasks: ${tasks.length} implementation step${tasks.length !== 1 ? 's' : ''} found
             role: 'system',
             content: planSummary,
         });
-        // Show approval select widget
-        ctx.select.showSelect({
-            title: 'Plan Approval',
-            question: 'Ready to begin implementation?',
-            type: 'select',
-            options: [
-                {
-                    value: 'approve',
-                    label: 'Yes, begin implementation (Recommended)',
-                    description: 'Approve the plan, create tasks, and start coding',
-                },
-                {
-                    value: 'edit',
-                    label: 'Edit plan first',
-                    description: 'Return to plan mode and continue editing',
-                },
-            ],
-            allowOther: true,
-        }, (value) => {
-            if (value === null) {
-                // Cancelled - stay in plan mode
+        askPlanApproval(ctx, decision => {
+            if (decision.kind === 'cancel') {
                 ctx.addMessage({
                     role: 'system',
                     content: 'Plan execution cancelled. Still in plan mode.',
                 });
                 return;
             }
-            const selection = typeof value === 'string' ? value : '';
-            if (selection === 'approve') {
+            if (decision.kind === 'approve') {
                 commitPlan(planFile, planContent, tasks, ctx, false);
                 ctx.triggerAgentTurn?.();
             }
-            else if (selection === 'edit') {
+            else if (decision.kind === 'edit') {
                 ctx.addMessage({
                     role: 'system',
                     content: 'Returning to plan mode. Continue editing your plan, then run /execute when ready.',
                 });
             }
             else {
-                // Custom "Other" text - treat as feedback, stay in plan mode
                 ctx.addMessage({
                     role: 'system',
-                    content: `Feedback noted. Still in plan mode.\n\nFeedback: ${selection}`,
+                    content: `Feedback noted. Still in plan mode.\n\nFeedback: ${decision.text}`,
                 });
-                // Add feedback as user message so the agent can see it
                 ctx.addMessage({
                     role: 'user',
-                    content: `Please update the plan based on this feedback: ${selection}`,
+                    content: `Please update the plan based on this feedback: ${decision.text}`,
                 });
             }
         });

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

@@ -1,2 +1,2 @@
-import { Command } from './types.js';
+import type { Command } from './types.js';
 export declare const profileCommand: Command;

package/dist/agent/commands/profile.js

@@ -1,274 +1,51 @@
-import { mkdirSync, writeFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { optimizeCommand } from './optimize.js';
-import { buildProfileOptimizationCommand, getProfileGateCommand, getProfileManifest, listProfileManifests, } from '../../emulation/profile_gates.js';
-function helpText() {
-    return [
-        'Manage ZTC prompt profiles and benchmark gates.',
-        '',
-        'Usage:',
-        '  /profile list',
-        '  /profile show <ztc|ztc-coder|ztc-datascience|scientist>',
-        '  /profile gates <profile>',
-        '  /profile command <profile> <gate> [--tier smoke|initial|expanded|sweep] [--limit N]',
-        '  /profile run <profile> <gate> [--tier smoke|initial|expanded|sweep] [--limit N]',
-        '  /profile optimize <profile> [--profile quick|balanced|deep|exhaustive] [--run]',
-        '  /profile sweep <profile> [--tier smoke|initial|expanded|sweep]',
-    ].join('\n');
-}
-function formatGate(gate) {
-    return [
-        `- ${gate.name} [${gate.status}]`,
-        `  benchmark: ${gate.benchmark}`,
-        `  purpose: ${gate.purpose}`,
-        gate.command ? `  command: ${gate.command.join(' ')}` : undefined,
-        gate.tierCommands?.expanded ? `  expanded: ${gate.tierCommands.expanded.join(' ')}` : undefined,
-        gate.tierCommands?.sweep ? `  sweep: ${gate.tierCommands.sweep.join(' ')}` : undefined,
-        gate.notes?.length ? `  notes: ${gate.notes.join(' ')}` : undefined,
-    ].filter(Boolean).join('\n');
-}
-function replaceLimit(command, limit) {
-    if (!limit) {
-        return command;
-    }
-    const idx = command.indexOf('--limit');
-    if (idx >= 0) {
-        return [...command.slice(0, idx + 1), limit, ...command.slice(idx + 2)];
-    }
-    return [...command, '--limit', limit];
-}
-function findFlagValue(args, flag) {
-    const idx = args.indexOf(flag);
-    if (idx < 0) {
-        return undefined;
-    }
-    const value = args[idx + 1];
-    return value && !value.startsWith('--') ? value : undefined;
-}
-function shellQuote(value) {
-    if (/^[A-Za-z0-9_./:=,@+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function normalizeTier(value) {
-    if (value === 'smoke' || value === 'expanded' || value === 'sweep') {
-        return value;
-    }
-    return 'initial';
-}
-function gateCommand(profileId, gateName, limit, tier) {
-    const manifest = getProfileManifest(profileId);
-    if (!manifest) {
-        return [];
-    }
-    const normalizedGate = gateName.toLowerCase();
-    const gate = manifest.gates.find(candidate => candidate.benchmark.toLowerCase() === normalizedGate ||
-        candidate.name.toLowerCase().replace(/\s+/g, '-') === normalizedGate ||
-        candidate.name.toLowerCase() === normalizedGate);
-    if (!gate?.command) {
-        return [];
-    }
-    return replaceLimit(getProfileGateCommand(gate, normalizeTier(tier)), limit);
-}
-function profileRunDir(profileId, tier) {
-    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
-    return join(homedir(), '.ztc', 'profile-runs', `${stamp}-${profileId}-${tier}`);
-}
-function tierLimit(tier, benchmark) {
-    if (tier === 'smoke') {
-        return '2';
-    }
-    if (tier === 'initial') {
-        return '5';
-    }
-    if (tier === 'expanded') {
-        return benchmark === 'polyglot' ? '10' : '25';
-    }
-    if (tier === 'sweep') {
-        if (benchmark === 'ds1000')
-            return '100';
-        if (benchmark === 'polyglot')
-            return '25';
-        if (benchmark === 'hotpotqa')
-            return '50';
-        if (benchmark === 'swebench')
-            return '10';
-        return '25';
-    }
-    return undefined;
-}
-function tierOptimizationProfile(tier) {
-    if (tier === 'smoke') {
-        return 'quick';
-    }
-    if (tier === 'expanded') {
-        return 'deep';
-    }
-    if (tier === 'sweep') {
-        return 'exhaustive';
-    }
-    return 'balanced';
-}
-function writeJson(path, value) {
-    writeFileSync(path, JSON.stringify(value, null, 2), 'utf-8');
-}
+import { activeProfile, builtinProfileEmulation, listConfigProfiles } from '../../config/profiles.js';
+import { switchConfigProfile } from './config_profile_switch.js';
+const USAGE = [
+    'Configuration profiles:',
+    '  /profile list                list built-in and saved profiles',
+    '  /profile <name>              switch this session to an existing profile',
+    '  /profile use <name>          same as above',
+    '  /profile create <name>       create and switch to a custom profile',
+].join('\n');
+const OLD_BENCHMARK_COMMANDS = new Set(['show', 'gates', 'command', 'run', 'optimize', 'sweep']);
 export const profileCommand = {
     name: 'profile',
-    description: 'Inspect and run ZTC prompt-profile benchmark gates',
-    usage: '<list|show|gates|command|run|optimize>',
+    description: 'List and switch configuration profiles',
+    usage: '[list|<name>|use <name>|create <name>]',
     handler: async (args, ctx) => {
-        const [subcommand, ...rest] = args;
-        if (!subcommand) {
-            ctx.addMessage({ role: 'system', content: helpText() });
-            return;
-        }
-        if (subcommand === 'list') {
-            ctx.addMessage({
-                role: 'system',
-                content: [
-                    'ZTC profiles:',
-                    ...listProfileManifests().map(profile => `- ${profile.id}: ${profile.name} — ${profile.description}`),
-                ].join('\n'),
-            });
-            return;
-        }
-        if (subcommand === 'show') {
-            const id = rest[0];
-            const manifest = id ? getProfileManifest(id) : undefined;
-            if (!manifest) {
-                ctx.addMessage({ role: 'system', content: 'Usage: /profile show <profile>' });
+        const [action, ...rest] = args;
+        if (!action || action === 'list' || action === 'configs' || action === 'help') {
+            if (rest.length > 0) {
+                ctx.addMessage({ role: 'system', content: USAGE });
                 return;
             }
-            ctx.addMessage({
-                role: 'system',
-                content: [
-                    `${manifest.name} (${manifest.id})`,
-                    manifest.description,
-                    '',
-                    `source: ${manifest.source.repo} ${manifest.source.promptPath}`,
-                    `runtime: compatibility ${manifest.runtime.compatibilityVersion}, ${manifest.runtime.promptProfile}`,
-                    `benchmark plan: ${manifest.runtime.benchmarkPlan.join(', ')}`,
-                    `failure policy: ${manifest.failurePolicy}`,
-                    '',
-                    'Gates:',
-                    ...manifest.gates.map(formatGate),
-                ].join('\n'),
-            });
-            return;
-        }
-        if (subcommand === 'gates') {
-            const id = rest[0];
-            const manifest = id ? getProfileManifest(id) : undefined;
-            if (!manifest) {
-                ctx.addMessage({ role: 'system', content: 'Usage: /profile gates <profile>' });
+            if (action === 'help') {
+                ctx.addMessage({ role: 'system', content: USAGE });
                 return;
             }
-            ctx.addMessage({
-                role: 'system',
-                content: [`Profile gates for ${manifest.id}:`, ...manifest.gates.map(formatGate)].join('\n'),
+            const names = await listConfigProfiles();
+            const lines = names.map(name => {
+                const emulation = builtinProfileEmulation(name);
+                return `  ${name === activeProfile() ? '*' : ' '} ${name}${emulation ? ` (built-in: ${emulation} emulation)` : ''}`;
             });
+            ctx.addMessage({ role: 'system', content: `Config profiles (* active):\n${lines.join('\n')}${!action ? `\n\n${USAGE}` : ''}` });
             return;
         }
-        if (subcommand === 'command' || subcommand === 'run') {
-            const [profileId, gateName] = rest;
-            const limit = findFlagValue(rest, '--limit');
-            const tier = findFlagValue(rest, '--tier');
-            const command = profileId && gateName ? gateCommand(profileId, gateName, limit, tier) : [];
-            if (command.length === 0) {
-                ctx.addMessage({ role: 'system', content: 'Usage: /profile command <profile> <gate> [--limit N]' });
-                return;
-            }
-            const rendered = command.map(shellQuote).join(' ');
-            if (subcommand === 'command') {
-                ctx.addMessage({ role: 'system', content: rendered });
-                return;
-            }
-            const result = await ctx.shell.run(rendered);
-            ctx.addMessage({
-                role: 'system',
-                content: [
-                    `Profile gate command: ${rendered}`,
-                    `Exit code: ${result.exitCode}`,
-                    result.stdout,
-                    result.stderr,
-                ].filter(Boolean).join('\n'),
-            });
+        if (OLD_BENCHMARK_COMMANDS.has(action)) {
+            ctx.addMessage({ role: 'system', content: 'Use /emulation to inspect prompt modes. Profile benchmark gates remain available through npm run profiles:baseline.' });
             return;
         }
-        if (subcommand === 'optimize') {
-            const id = rest[0];
-            const optimizationProfile = findFlagValue(rest, '--profile');
-            const command = id ? buildProfileOptimizationCommand(id, optimizationProfile ? { profile: optimizationProfile } : {}) : [];
-            if (command.length === 0) {
-                ctx.addMessage({ role: 'system', content: 'Usage: /profile optimize <profile> [--profile quick|balanced|deep|exhaustive] [--run]' });
-                return;
-            }
-            const rendered = `/${command.join(' ')}`;
-            if (!rest.includes('--run')) {
-                ctx.addMessage({ role: 'system', content: rendered });
-                return;
-            }
-            await optimizeCommand.handler(command.slice(1), ctx);
+        const namedCommand = action === 'use' || action === 'switch' || action === 'create';
+        const name = namedCommand ? rest[0] : action;
+        if (!name || (namedCommand ? rest.length !== 1 : rest.length !== 0)) {
+            ctx.addMessage({ role: 'system', content: USAGE });
             return;
         }
-        if (subcommand === 'sweep') {
-            const id = rest[0];
-            const tier = findFlagValue(rest, '--tier') || 'smoke';
-            const manifest = id ? getProfileManifest(id) : undefined;
-            if (!manifest || !['smoke', 'initial', 'expanded', 'sweep'].includes(tier)) {
-                ctx.addMessage({ role: 'system', content: 'Usage: /profile sweep <profile> [--tier smoke|initial|expanded|sweep]' });
-                return;
-            }
-            const runDir = profileRunDir(manifest.id, tier);
-            mkdirSync(runDir, { recursive: true });
-            const results = [];
-            for (const gate of manifest.gates.filter(gate => gate.status === 'available' && gate.command)) {
-                const limit = tierLimit(tier, gate.benchmark);
-                const command = replaceLimit(getProfileGateCommand(gate, normalizeTier(tier)), limit).map(shellQuote).join(' ');
-                const result = await ctx.shell.run(command);
-                const record = {
-                    gate: gate.name,
-                    benchmark: gate.benchmark,
-                    command,
-                    exit_code: result.exitCode,
-                    stdout_path: join(runDir, `${gate.benchmark}-stdout.txt`),
-                    stderr_path: join(runDir, `${gate.benchmark}-stderr.txt`),
-                };
-                writeFileSync(record.stdout_path, result.stdout || '', 'utf-8');
-                writeFileSync(record.stderr_path, result.stderr || '', 'utf-8');
-                results.push(record);
-            }
-            let optimizeCommandLine = null;
-            if (tier !== 'smoke') {
-                const command = buildProfileOptimizationCommand(manifest.id, { profile: tierOptimizationProfile(tier) });
-                optimizeCommandLine = `/${command.join(' ')} --run`;
-                await optimizeCommand.handler([...command.slice(1), '--run'], ctx);
-            }
-            const summaryPath = join(runDir, 'summary.json');
-            writeJson(summaryPath, {
-                schema_version: 1,
-                created_at: new Date().toISOString(),
-                profile: manifest.id,
-                tier,
-                provider: ctx.config.getProvider(),
-                model: ctx.config.getModel?.() || ctx.config.get().model,
-                optimize_command: optimizeCommandLine,
-                results,
-            });
-            ctx.addMessage({
-                role: 'system',
-                content: [
-                    `Profile sweep complete: ${manifest.id} (${tier})`,
-                    `Run dir: ${runDir}`,
-                    `Summary: ${summaryPath}`,
-                    `Gates: ${results.length}`,
-                    optimizeCommandLine ? `Optimize: ${optimizeCommandLine}` : 'Optimize: skipped for smoke tier',
-                ].join('\n'),
-            });
-            return;
+        try {
+            await switchConfigProfile(ctx, name, action === 'create');
+        }
+        catch (error) {
+            ctx.addMessage({ role: 'system', content: `Profile switch failed: ${error.message}` });
         }
-        ctx.addMessage({ role: 'system', content: helpText() });
     },
 };

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

@@ -9,6 +9,17 @@ export declare const PROVIDER_CHOICES: ({
     description: string;
     aliases?: undefined;
 })[];
-export declare const ROUTER_PROVIDERS: string[];
+/**
+ * Providers ZTC will never hand to the Router branch, either because Router
+ * cannot serve them over HTTP or because nesting them would be wrong.
+ *
+ * Router's own `listProviderCatalog` (GET /v1/models) is the source of truth for
+ * what it offers. This is deliberately an exclusion list: when Router adds a
+ * provider, ZTC offers it without a ZTC change. Only add an entry here to block
+ * one, never to enable one.
+ */
+export declare const ROUTER_EXCLUDED_PROVIDERS: string[];
+/** True when a provider can be dispatched as a Router upstream. */
+export declare function canRouteThroughRouter(provider: string): boolean;
 export declare function canonicalProvider(value: string): string | undefined;
 export declare function isLocalSubscription(provider: string): boolean;

package/dist/agent/commands/provider_choices.js

@@ -6,6 +6,7 @@ export const PROVIDER_CHOICES = [
     { id: 'gemini', label: 'Google Gemini', description: 'Direct API key', aliases: ['google'] },
     { id: 'deepseek', label: 'DeepSeek', description: 'Direct API key' },
     { id: 'kimi', label: 'Kimi (Moonshot)', description: 'Direct API key', aliases: ['moonshot'] },
+    { id: 'fireworks', label: 'Fireworks', description: 'Direct API key or Zerg Router', aliases: ['fireworks-ai'] },
     { id: 'inception', label: 'Inception', description: 'Direct API key' },
     { id: 'clarifai', label: 'Clarifai', description: 'Direct API key' },
     { id: 'openai_compatible', label: 'OpenAI-compatible', description: 'Local or custom endpoint', aliases: ['openai-compatible', 'local', 'ollama'] },
@@ -15,8 +16,34 @@ export const PROVIDER_CHOICES = [
     { id: 'codex_legacy', label: 'Codex Legacy', description: 'Local Codex credentials' },
     { id: 'kimi_code', label: 'Kimi Code', description: 'Local Kimi credentials', aliases: ['kimi-code'] },
 ];
-// These use HTTP inference through Router; subscription backends stay local.
-export const ROUTER_PROVIDERS = ['anthropic', 'openai', 'gemini', 'deepseek', 'kimi', 'modal'];
+/**
+ * Providers ZTC will never hand to the Router branch, either because Router
+ * cannot serve them over HTTP or because nesting them would be wrong.
+ *
+ * Router's own `listProviderCatalog` (GET /v1/models) is the source of truth for
+ * what it offers. This is deliberately an exclusion list: when Router adds a
+ * provider, ZTC offers it without a ZTC change. Only add an entry here to block
+ * one, never to enable one.
+ */
+export const ROUTER_EXCLUDED_PROVIDERS = [
+    // Local subscription logins: inference runs on this machine, not Router, and
+    // Router holds no credential for them.
+    'claude_code',
+    'claude_code_direct',
+    'codex_app_server',
+    'codex_legacy',
+    'kimi_code',
+    // Routing Router through Router would nest the same gateway in itself.
+    'zergrouter',
+    // A custom OpenAI-compatible endpoint names its own base URL and models.
+    'openai_compatible',
+];
+const ROUTER_EXCLUDED = new Set(ROUTER_EXCLUDED_PROVIDERS);
+/** True when a provider can be dispatched as a Router upstream. */
+export function canRouteThroughRouter(provider) {
+    const normalized = normalizeProviderId(provider);
+    return normalized.length > 0 && !ROUTER_EXCLUDED.has(normalized);
+}
 export function canonicalProvider(value) {
     const normalized = normalizeProviderId(value);
     return PROVIDER_CHOICES.find(choice => choice.id === normalized || choice.aliases?.includes(normalized))?.id;

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

@@ -0,0 +1,3 @@
+import type { CommandContext } from './types.js';
+/** Apply a provider and optional model in one validated config transition. */
+export declare function selectProviderModel(args: string[], ctx: CommandContext): Promise<void>;

package/dist/agent/commands/provider_selection.js

@@ -0,0 +1,63 @@
+import { getDefaultModelForProvider } from '../../config/defaults.js';
+import { isBuildableResolvedConfig } from './config.js';
+import { applyRuntimeModelSelection, getEffectiveModel } from './runtime_model.js';
+import { canRouteThroughRouter, canonicalProvider } from './provider_choices.js';
+import { resolveModelAndProvider } from '../../panes/model_catalog.js';
+import { getDefaultModel } from '../../utils/models.js';
+/** Apply a provider and optional model in one validated config transition. */
+export async function selectProviderModel(args, ctx) {
+    const values = args.filter(Boolean);
+    const current = ctx.config.getProvider();
+    const choice = canonicalProvider(values[0]);
+    const routed = choice === 'zergrouter' || choice === 'modal';
+    // Router's catalog is the source of truth, so a Router upstream ZTC has no
+    // PROVIDER_CHOICES entry for still selects; the exclusion rule gates it.
+    const upstream = values[1] ? (canonicalProvider(values[1]) ?? values[1]) : undefined;
+    const provider = choice === 'zergrouter'
+        ? (upstream ?? (canRouteThroughRouter(current) ? current : 'anthropic'))
+        : choice;
+    if (!provider || (routed && !canRouteThroughRouter(provider))) {
+        ctx.addMessage({ role: 'system', content: `Unknown provider or unsupported Router provider: ${values.join(' ')}. Run /model to see the choices.` });
+        return;
+    }
+    if (values.length > (choice === 'zergrouter' ? 3 : 2)) {
+        ctx.addMessage({ role: 'system', content: 'Usage: /model <provider> [model] or /model zergrouter <upstream-provider> [model]' });
+        return;
+    }
+    const authMode = routed ? 'zrouter' : 'direct';
+    const defaultModel = provider === 'inception' ? getDefaultModel(provider) : getDefaultModelForProvider(provider);
+    const explicitModel = values[choice === 'zergrouter' ? 2 : 1];
+    const model = explicitModel || (provider === current ? getEffectiveModel(ctx)
+        : provider === 'openai_compatible'
+            ? (ctx.config.getOpenAICompatibleSettings?.().defaultModel || getDefaultModelForProvider(provider))
+            : resolveModelAndProvider(defaultModel, provider).model);
+    try {
+        const llm = ctx.config.resolveLLMBackendConfig({ provider, model,
+            config: { ...ctx.config.get(), provider, model, authMode } });
+        if (llm.authMode !== authMode) {
+            throw new Error('Routing is pinned by ZTC_LLM_AUTH_MODE/ZERG_LLM_AUTH_MODE. Unset it before switching routes.');
+        }
+        if (!isBuildableResolvedConfig(llm)) {
+            throw new Error(provider === 'openai_compatible'
+                ? 'Configure a local or custom endpoint with /config openai-compat, then select /model openai_compatible.'
+                : `No usable direct credentials for ${provider}. Set /config key ${provider} <api-key> or configure this provider's local login.`);
+        }
+    }
+    catch (error) {
+        ctx.addMessage({ role: 'system', content: `✗ ${error instanceof Error ? error.message : String(error)} Keeping the current selection.` });
+        return;
+    }
+    ctx.config.set('authMode', authMode);
+    ctx.config.setProvider(provider);
+    // CLI overrides can still expose the previous provider/model until hot-swap.
+    ctx.config.set('model', model);
+    await ctx.config.save();
+    applyRuntimeModelSelection(ctx, provider, model);
+    ctx.addMessage({ role: 'system', content: [
+            '✓ Model selected',
+            `provider: ${provider}`,
+            `model: ${model}`,
+            `route: ${routed ? 'zergrouter' : 'direct'}`,
+            `scope: ${ctx.config.getConfigScope?.() || 'global'}`,
+        ].join('\n') });
+}

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

@@ -1,3 +1,5 @@
 import { Command, CommandContext, SettingCategory } from './types.js';
 export declare function buildSettingsCategories(ctx: CommandContext): Promise<SettingCategory[]>;
 export declare const settingsCommand: Command;
+/** A separate confirmation page keeps destructive reset out of ordinary row editing. */
+export declare function openFactoryResetConfirmation(ctx: CommandContext, onDone?: () => void | Promise<void>): void;