@zergai/ztc 0.4.0-beta.1 → 0.4.1-dev.36919234045

package/dist/app/selection_completion.js

@@ -1,3 +1,5 @@
+import { routerModelIds, routerModelsForProvider, resolveRouterModel } from '../utils/router_catalog.js';
+import { reasoningCommandChoices, reasoningEnabled } from '../utils/reasoning.js';
 import { MODEL_CATALOG } from '../panes/model_catalog.js';
 import { canRouteThroughRouter, canonicalProvider, PROVIDER_CHOICES } from '../agent/commands/provider_choices.js';
 import { resolveSlashUsage } from '../agent/commands/usage_spec.js';
@@ -42,6 +44,11 @@ function commandUsage(text, commands) {
 function parseSelectionInput(text, commands) {
     if (commands.length && /^\/[\w-]*$/.test(text))
         return { kind: 'command', prefix: '/', query: text.slice(1) };
+    const reasoning = text.match(/^\/(effort|thinking)\s+([^\s]*)\s*$/i);
+    if (reasoning && commands.some(command => command.name === reasoning[1].toLowerCase())) {
+        const command = reasoning[1].toLowerCase();
+        return { kind: 'reasoning', command, prefix: `/${command} `, query: reasoning[2] };
+    }
     const model = text.match(/^\/(model|models)\s+([^\n]*)$/i);
     if (!model)
         return commandUsage(text, commands);
@@ -98,6 +105,9 @@ function commandSelections(commands) {
 /** Static preview for renderers without a completion controller. Explicit null hides it. */
 export function commandCompletionView(text, commands) {
     const parsed = parseSelectionInput(text, commands);
+    if (parsed?.kind === 'reasoning')
+        return { kind: 'usage', candidates: [], selected: 0, loading: false,
+            usage: `/${parsed.command} [${parsed.command === 'effort' ? 'level|default' : 'setting'}]` };
     if (parsed?.kind !== 'command' && parsed?.kind !== 'usage')
         return null;
     return { kind: parsed.kind, query: parsed.query, usage: parsed.usage,
@@ -126,23 +136,31 @@ export class SelectionCompletion {
     requestController = null;
     commands = [];
     currentModel;
+    routerCatalog;
+    reasoning = {};
     constructor(changed = () => { }) {
         this.changed = changed;
     }
-    update(text, provider, loadModels, commands = [], currentModel) {
+    update(text, provider, loadModels, commands = [], currentModel, loadCatalog, activeRouted = false, reasoning = {}) {
         this.commands = commands;
-        this.currentModel = currentModel;
         const parsed = parseSelectionInput(text, commands);
         const catalogProvider = parsed?.modelProvider ?? provider;
+        const routed = parsed?.routed ?? ((parsed?.includeModels || parsed?.kind === 'reasoning') && activeRouted ? true : undefined);
         if (provider !== this.provider || catalogProvider !== this.catalogProvider
-            || parsed?.routed !== this.catalogRoute || parsed?.kind !== this.parsed?.kind) {
+            || routed !== this.catalogRoute || parsed?.kind !== this.parsed?.kind
+            || reasoning.scope !== this.reasoning.scope || (parsed?.kind === 'reasoning' && currentModel !== this.currentModel)) {
             this.requestController?.abort();
             this.generation++;
             this.requested = false;
             this.loading = false;
             this.unavailable = false;
             this.discovered = undefined;
+            this.routerCatalog = undefined;
         }
+        this.currentModel = currentModel;
+        this.reasoning = reasoning;
+        if (reasoning.catalog)
+            this.routerCatalog = reasoning.catalog;
         if (text !== this.text || provider !== this.provider) {
             this.selected = 0;
             this.firstVisible = 0;
@@ -153,9 +171,28 @@ export class SelectionCompletion {
         this.text = text;
         this.provider = provider;
         this.catalogProvider = catalogProvider;
-        this.catalogRoute = parsed?.routed;
+        this.catalogRoute = routed;
         this.parsed = parsed;
         this.filter();
+        if ((parsed?.routerOnly || routed) && !this.requested && loadCatalog) {
+            this.requested = true;
+            this.loading = true;
+            this.requestController = new AbortController();
+            const generation = this.generation;
+            void loadCatalog(this.requestController.signal).then(catalog => {
+                if (generation !== this.generation)
+                    return;
+                this.routerCatalog = catalog;
+                this.discovered = routerModelIds(catalog, catalogProvider);
+            }).catch(() => { if (generation === this.generation)
+                this.unavailable = true; }).finally(() => {
+                if (generation !== this.generation)
+                    return;
+                this.loading = false;
+                this.filter();
+                this.changed();
+            });
+        }
         if ((parsed?.kind === 'model' || parsed?.includeModels) && !this.requested && loadModels) {
             this.requested = true;
             this.loading = true;
@@ -181,9 +218,35 @@ export class SelectionCompletion {
     }
     filter() {
         const selectedValue = this.candidates[this.selected]?.value;
-        const models = modelSelections(this.catalogProvider, this.discovered)
+        if (this.parsed?.kind === 'reasoning') {
+            const catalog = this.routerCatalog;
+            const contract = this.catalogRoute
+                ? catalog?.version === 1 && !catalog.authRequired
+                    ? resolveRouterModel(catalog, this.provider, this.currentModel ?? '')?.capabilities?.reasoning ?? []
+                    : catalog?.version === 0 && !catalog.authRequired ? this.reasoning.contract : []
+                : this.reasoning.contract;
+            const command = this.parsed.command;
+            const current = command === 'effort' ? this.reasoning.current
+                : this.reasoning.current === undefined ? undefined : reasoningEnabled(this.reasoning.current) ? 'on' : 'off';
+            this.candidates = fuzzySelections(reasoningCommandChoices(command, this.provider, this.currentModel ?? '', contract)
+                .map(value => ({ value, label: value, current: value === current,
+                description: value === 'default' ? 'Inherit model/provider defaults' : undefined })), this.parsed.query);
+            const previousIndex = this.candidates.findIndex(candidate => candidate.value === selectedValue);
+            this.selected = previousIndex >= 0 ? previousIndex : 0;
+            this.revealSelection();
+            return;
+        }
+        const routed = this.catalogRoute && this.routerCatalog?.version === 1;
+        const models = (routed ? routerModelsForProvider(this.routerCatalog, this.catalogProvider).map(row => ({
+            value: row.id, label: row.display_name || row.id,
+            description: [row.capabilities?.tools === false ? 'Chat only' : '', row.available === false ? 'Access unavailable' : '', this.routerCatalog?.cached ? 'Cached catalog' : ''].filter(Boolean).join(' · '),
+        })) : modelSelections(this.catalogProvider, this.discovered))
             .map(model => ({ ...model, current: this.catalogProvider === this.provider && model.value === this.currentModel }));
-        const providers = PROVIDER_CHOICES.filter(p => !this.parsed?.routerOnly || canRouteThroughRouter(p.id))
+        const routerProviders = this.parsed?.routerOnly && this.routerCatalog
+            ? [...new Map(this.routerCatalog.models.filter(row => this.routerCatalog?.version === 0 || row.capabilities?.chat).map(row => [row.owned_by, {
+                        id: row.owned_by, label: row.provider_display_name || row.owned_by, description: this.routerCatalog?.cached ? 'Cached catalog' : 'Via Zerg Router', aliases: [],
+                    }])).values()] : PROVIDER_CHOICES;
+        const providers = routerProviders.filter(p => !this.parsed?.routerOnly || canRouteThroughRouter(p.id))
             .map(p => ({ value: p.id, label: p.label, description: p.description, aliases: p.aliases,
             current: p.id === this.provider, needsArgument: true }));
         const source = this.parsed?.kind === 'command' ? commandSelections(this.commands)
@@ -218,6 +281,7 @@ export class SelectionCompletion {
             return null;
         return { candidates: this.candidates, selected: this.selected, firstVisible: this.firstVisible, loading: this.loading, unavailable: this.unavailable,
             kind: this.parsed.kind, query: this.parsed.query, usage: this.parsed.usage,
+            command: this.parsed.command, model: this.parsed.kind === 'reasoning' ? this.currentModel : undefined,
             provider: this.parsed.kind === 'model' ? this.catalogProvider : undefined,
             routed: this.parsed.kind === 'model' ? this.catalogRoute : undefined,
             mixed: this.parsed.includeModels };
@@ -255,6 +319,10 @@ export class SelectionCompletion {
             if (this.parsed.kind === 'provider' && candidate.needsArgument) {
                 return { handled: true, text: `${completed} ` };
             }
+            if (key.return && (this.parsed.kind === 'model' || this.parsed.kind === 'reasoning' || (this.parsed.includeModels && !candidate.needsArgument))) {
+                this.dismissedInput = this.text;
+                return { handled: true, text: completed, submit: true };
+            }
             if (key.return && completed === this.text)
                 return { handled: false };
             this.dismissedInput = completed;

package/dist/app/session_manager.js

@@ -7,7 +7,7 @@
 import { saveSession, saveSessionToFile, saveMuxStateOnly, cleanupOldSessions } from '../session.js';
 import { pruneZtcTempDirs } from '../utils/ztc_cleanup.js';
 import { configStore } from '../config.js';
-import { estimateConversationTokens, formatTokenCount, getContextStatus, contextStatusFromUsed, resolveAutoCompact, } from '../utils/context.js';
+import { estimateConversationTokens, formatTokenCount, getContextStatus, getContextWindowSize, contextStatusFromUsed, resolveAutoCompact, } from '../utils/context.js';
 import { compactConversation, describeCompaction, compactMessages, smartSummarizer, localSummarizer } from '../utils/compaction.js';
 import { stripEphemeralMessages } from '../utils/ephemeral.js';
 /**
@@ -47,7 +47,8 @@ export class SessionManager {
     async writeCurrentSession(options) {
         const messages = this.deps.getMessages();
         const muxState = this.deps.getMuxState ? await this.deps.getMuxState() : undefined;
-        const runtimeState = this.deps.getRuntimeState ? this.deps.getRuntimeState() : undefined;
+        const runtimeState = { ...this.deps.getRuntimeState?.(), authMode: configStore.getResolvedAuthMode(),
+            routerOrigin: configStore.getResolvedAuthMode() === 'direct' ? undefined : configStore.get().zergProxyUrl };
         const hostedSettings = this.deps.getHostedSettings ? this.deps.getHostedSettings() : undefined;
         const hasRuntimeState = runtimeState !== undefined && (runtimeState.mode !== undefined
             || runtimeState.planFile !== undefined
@@ -153,8 +154,8 @@ export class SessionManager {
         // /context); fall back to the char/4 estimate only before the first API call.
         const realUsed = this.deps.getContextTokens?.() ?? 0;
         const status = realUsed > 0
-            ? contextStatusFromUsed(realUsed, model, this.deps.getContextWindow?.())
-            : getContextStatus(messages, model);
+            ? contextStatusFromUsed(realUsed, model, (configStore.getModelContextWindow(model) !== undefined ? configStore.getModelContextWindow(model) : this.deps.getContextWindow?.()))
+            : getContextStatus(messages, model, configStore.getModelContextWindow(model));
         const threshold = opts?.threshold ?? configStore.getAutoCompactThreshold();
         const targetPercent = configStore.getCompactionTargetPercent();
         const triggerMode = configStore.getCompactionTriggerMode();
@@ -164,7 +165,7 @@ export class SessionManager {
         const decision = resolveAutoCompact({
             used: realUsed > 0 ? realUsed : estimateConversationTokens(messages),
             model,
-            windowOverride: this.deps.getContextWindow?.(),
+            windowOverride: (configStore.getModelContextWindow(model) !== undefined ? configStore.getModelContextWindow(model) : this.deps.getContextWindow?.()),
             thresholdPercent: threshold,
             triggerMode,
             tokenBudget: configStore.getContextTokenBudget(),
@@ -199,7 +200,7 @@ export class SessionManager {
                 return false;
             }
             this.deps.setMessages(result.messages);
-            const newStatus = getContextStatus(result.messages, model);
+            const newStatus = getContextStatus(result.messages, model, configStore.getModelContextWindow(model));
             const verb = describeCompaction(result);
             this.deps.addMessage({
                 role: 'system',
@@ -228,13 +229,17 @@ export class SessionManager {
         const summarizer = this.buildSummarizer();
         this.deps.debugLog('[SessionManager.forceCompact] Forcing aggressive compaction');
         try {
-            const result = await compactMessages(messages, model, summarizer, 30, 5);
+            // A provider can reject request structure before its token window fills.
+            // Forced recovery must shrink even when the history already fits 30% of
+            // that window; otherwise the next request repeats the same rejection.
+            const targetTokens = Math.max(1, Math.min(Math.floor((getContextWindowSize(model, configStore.getModelContextWindow(model)) || estimateConversationTokens(messages)) * 0.3), Math.floor(estimateConversationTokens(messages) / 2)));
+            const result = await compactMessages(messages, model, summarizer, 30, 5, targetTokens);
             if (result.removed === 0) {
                 this.deps.debugLog('[SessionManager.forceCompact] Nothing to compact — all messages are recent or system');
                 return false;
             }
             this.deps.setMessages(result.messages);
-            const newStatus = getContextStatus(result.messages, model);
+            const newStatus = getContextStatus(result.messages, model, configStore.getModelContextWindow(model));
             this.deps.debugLog(`[SessionManager.forceCompact] Compacted ${result.removed} msgs: ${formatTokenCount(result.tokensBefore)} → ${formatTokenCount(result.tokensAfter)} (${Math.round(newStatus.percentage)}%)`);
             return true;
         }

package/dist/cli_args.js

@@ -1,11 +1,9 @@
-import { CODEX_REASONING_EFFORTS } from './config/types.js';
-import { getSupportedCodexReasoningEfforts, unsupportedEffortMessage } from './utils/models.js';
 import { validateProfileName } from './config/profiles.js';
 const BOOLEAN_FLAGS = new Set([
     '--no-pin-task-header', '--help', '-h', '--version', '-v', '--list-sessions', '--plan', '--desktop', '--mux', '--no-mux', '--new-window', '--fullscreen', '--pane', '--human-sim-pane', '--zlicky', '--computer-use', '--ml', '--sfx-list', '--voyager-loop', '--mirror', '--open-mirror', '--mirror-open', '--no-browser-open', '--navigator-hidden', '--headless-mirror', '--headless-mirror-open', '--headless-interactive', '--headless', '--json', '--json-stream', '--quiet', '-q', '--timestamps', '--verbose', '--colony',
 ]);
 const REQUIRED_VALUE_FLAGS = new Set([
-    '--cwd', '--name', '--session-id', '--session-file', '--mode', '--agent-domain', '--domain-paths', '--embedded', '--embedded-rom', '--embedded-workflow', '--embedded-runtime-tick-ms', '--embedded-runtime-frame-budget', '--bench', '--bench-workflow', '--num-zergs', '--provider', '--model', '--profile', '--effort', '--thinking', '--emulation', '--prompt', '--max-iterations', '--timeout', '--output', '--voyager-task', '--voyager-max-rounds', '--mirror-port', '--navigator-group', '--connect-zerg',
+    '--cwd', '--name', '--session-id', '--session-file', '--mode', '--agent-domain', '--domain-paths', '--embedded', '--embedded-rom', '--embedded-workflow', '--embedded-runtime-tick-ms', '--embedded-runtime-frame-budget', '--bench', '--bench-workflow', '--num-zergs', '--provider', '--model', '--auth-mode', '--router-url', '--profile', '--effort', '--thinking', '--emulation', '--prompt', '--max-iterations', '--timeout', '--output', '--voyager-task', '--voyager-max-rounds', '--mirror-port', '--navigator-group', '--connect-zerg',
 ]);
 const OPTIONAL_VALUE_FLAGS = new Set(['--resume', '--continue', '-c', '--sfx']);
 /** Separate prompt text from options before the legacy flag consumers see it. */
@@ -96,19 +94,7 @@ export function validateCliArgs(args) {
                     return { ok: false, message: error.message, error: 'invalid_profile', flag: token, value: next };
                 }
             }
-            if (token === '--effort') {
-                if (!CODEX_REASONING_EFFORTS.includes(next)) {
-                    return { ok: false, message: `--effort must be one of: ${CODEX_REASONING_EFFORTS.join(', ')}.`, error: 'invalid_effort', flag: token, value: next };
-                }
-                const modelIndex = args.indexOf('--model');
-                const providerIndex = args.indexOf('--provider');
-                const model = modelIndex >= 0 ? args[modelIndex + 1] : undefined;
-                const provider = providerIndex >= 0 ? args[providerIndex + 1] : undefined;
-                const supported = getSupportedCodexReasoningEfforts(model, provider);
-                if (supported && !supported.includes(next)) {
-                    return { ok: false, message: unsupportedEffortMessage(model, next, supported), error: 'unsupported_effort', flag: token, value: next };
-                }
-            }
+            // Model-specific effort validation runs after configuration and Router definitions load.
             i += 1;
             continue;
         }

package/dist/cli_main.js

@@ -298,6 +298,8 @@ Options:
   --bench-workflow <id>
                        Run a bench workflow after opening the workspace
   --provider <name>    LLM provider override (anthropic, claude_code, openai, codex_app_server, codex_legacy, gemini, inception, kimi, kimi_code, etc.; codex is a legacy alias)
+  --auth-mode <mode>  Override routing for this process (auto, direct, zrouter)
+  --router-url <url>  Router origin for this process; matching login is required
   --profile <name>     Use named settings in ~/.ztc/profiles/<name>/config.json
                        (default: ~/.ztc/config.json). Sessions stay shared.
   --model <name>       LLM model override (e.g., claude-sonnet-4-20250514, gpt-4o)
@@ -1043,9 +1045,20 @@ async function main() {
         const { initMcpServers } = await import('./mcp/client.js');
         await initMcpServers(mcpServers);
     }
+    const authModeIndex = args.indexOf('--auth-mode');
+    const routerUrlIndex = args.indexOf('--router-url');
+    if (authModeIndex >= 0 || routerUrlIndex >= 0) {
+        const authMode = authModeIndex >= 0 ? args[authModeIndex + 1] : configStore.getAuthMode();
+        if (!['auto', 'direct', 'zrouter'].includes(authMode))
+            throw new Error('Invalid --auth-mode');
+        configStore.setCliOverride('authMode', authMode);
+        if (routerUrlIndex >= 0)
+            configStore.setCliOverride('zergProxyUrl', args[routerUrlIndex + 1]);
+    }
     // Apply --provider / --model CLI overrides (never persisted to config.json)
+    const cliRoute = configStore.getResolvedAuthMode();
     const resolvedCliOverride = cliModel
-        ? resolveModelAndProvider(cliModel, cliProvider || undefined)
+        ? resolveModelAndProvider(cliModel, cliProvider || undefined, cliRoute)
         : undefined;
     const effectiveCliProvider = (resolvedCliOverride?.provider || cliProvider);
     const effectiveCliModel = resolvedCliOverride?.model || cliModel;
@@ -1069,11 +1082,17 @@ async function main() {
     const thinkingIndex = args.indexOf('--thinking');
     if (effortIndex >= 0 || thinkingIndex >= 0) {
         const { parseReasoningSelection } = await import('./utils/reasoning.js');
-        const level = parseReasoningSelection(configStore.getProvider(), configStore.getModel(), configStore.getCodexEffort(), {
-            effort: effortIndex >= 0 ? args[effortIndex + 1] : undefined,
-            thinking: thinkingIndex >= 0 ? args[thinkingIndex + 1] : undefined,
-        });
-        configStore.setCliOverride('codexEffort', level ?? undefined);
+        try {
+            const level = parseReasoningSelection(configStore.getProvider(), configStore.getModel(), configStore.getCodexEffort(), {
+                effort: effortIndex >= 0 ? args[effortIndex + 1] : undefined,
+                thinking: thinkingIndex >= 0 ? args[thinkingIndex + 1] : undefined,
+            }, configStore.getReasoningContract());
+            configStore.setCliOverride('codexEffort', level ?? undefined);
+        }
+        catch (error) {
+            console.error(`[ztc] ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(2);
+        }
     }
     // Background-refresh superuser status so pre-existing logins get the field backfilled.
     // Skip for colony children (they inherit the parent status) and explicitly offline

package/dist/cli_ratatui.js

@@ -13,7 +13,7 @@ import { randomUUID } from 'crypto';
 import { appendFileSync, existsSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import { execFile, spawn as spawnChild } from 'child_process';
+import { execFile, spawnSync } from 'child_process';
 import { promisify } from 'util';
 import { configStore } from './config.js';
 import { withActiveProfileArg } from './config/profiles.js';
@@ -79,6 +79,7 @@ import { createAgentWithConfig, AgentRunLifecycle } from './app/agent_runner.js'
 import { clearWorkerExecutor } from './worker/index.js';
 import { isPhantomCompletion } from './app/phantom_completion.js';
 import { SelectionCompletion } from './app/selection_completion.js';
+import { routerCatalogScope } from './utils/router_catalog.js';
 import { shouldAttachParentMirrorClient, shouldMarkMirrorServerAsColonyChild } from './app/mirror_startup.js';
 import { buildDesktopUpdateRelaunchContext, buildHotRestartLaunch, prepareDesktopUpdateAuthorization, reduceDesktopUpdateOwnerHandshake, requestColonyCellRestart, } from './app/restart.js';
 export { buildDesktopUpdateRelaunchContext, buildHotRestartArgs, requestColonyCellRestart, } from './app/restart.js';
@@ -1031,6 +1032,8 @@ export class RatatuiApp {
         if (options?.resumeSession) {
             this.sessionId = options.resumeSession.metadata.id;
             this.resumedSession = options.resumeSession;
+            if (!options.resumeSession.hosted_settings)
+                configStore.restoreSessionSelection(options.resumeSession.metadata);
             this.resumedPaneSpecs = mergeSessionPaneSpecs(options.resumeSession.mux_state, options.resumeSession.pane_specs);
             this.sessionName = options.resumeSession.metadata.name;
             this.hostedSessionSettings = options.resumeSession.hosted_settings
@@ -1084,7 +1087,7 @@ export class RatatuiApp {
         });
         // Initialize context status to show meter from the start
         const model = configStore.get().model;
-        const total = getContextWindowSize(model);
+        const total = getContextWindowSize(model, configStore.getModelContextWindow(model));
         this.controller.dispatch({
             type: 'SET_CONTEXT',
             length: 0,
@@ -1580,7 +1583,7 @@ export class RatatuiApp {
         this.mirrorServer?.setSuperuser(configStore.isSuperuser());
     }
     /** Change the active config while retaining this renderer's session and transcript. */
-    async switchConfigProfileInPlace(name) {
+    async switchConfigProfileInPlace(name, duplicateSource) {
         if (this.isHostedRuntime()) {
             throw new Error('Hosted thread settings cannot be replaced by a local config profile.');
         }
@@ -1620,7 +1623,7 @@ export class RatatuiApp {
             await preloadSkillsManifest();
         };
         try {
-            await configStore.switchProfile(name, async () => {
+            const activate = async () => {
                 touchedRuntime = true;
                 applyColonyOptIn();
                 mcpChanged = previousMcp !== JSON.stringify(configStore.get().mcpServers ?? {})
@@ -1636,7 +1639,11 @@ export class RatatuiApp {
                 this.hookLifecycle.ensureWatcher();
                 if (this.shouldPersistSession())
                     await this.saveCurrentSession(true);
-            });
+            };
+            if (duplicateSource === undefined)
+                await configStore.switchProfile(name, activate);
+            else
+                await configStore.duplicateProfile(name, duplicateSource, activate);
         }
         catch (error) {
             this.overseerModelOverride = previousOverseerOverride;
@@ -1722,6 +1729,10 @@ export class RatatuiApp {
             setAgentState: (state) => this.controller.setAgentState(state),
             reloadAgent: (options) => this.reloadAgentInPlace(options?.defer),
             switchConfigProfile: (name) => this.switchConfigProfileInPlace(name),
+            duplicateProfile: async (name, source) => {
+                await this.switchConfigProfileInPlace(name, source);
+                return name;
+            },
             setRuntimeModelOverride: (provider, model) => {
                 configStore.setCliOverride('provider', provider);
                 configStore.setCliOverride('model', model);
@@ -3370,7 +3381,7 @@ export class RatatuiApp {
                     sessionName: this.resumedSession.metadata.name,
                     messageCount: this.resumedSession.messages.length,
                     updatedAt: this.resumedSession.metadata.updatedAt,
-                    contextPercentage: getContextStatus(this.resumedSession.messages, model).percentage,
+                    contextPercentage: getContextStatus(this.resumedSession.messages, model, configStore.getModelContextWindow(model)).percentage,
                     mode: launchMode,
                     credentialsReady,
                 });
@@ -3862,14 +3873,14 @@ export class RatatuiApp {
     }
     createZtcPaneSpec(options) {
         const resolved = options?.model
-            ? resolveModelAndProvider(options.model, options.provider)
+            ? resolveModelAndProvider(options.model, options.provider, configStore.getResolvedAuthMode())
             : { model: undefined, provider: options?.provider };
         return createZtcLaunchSpec({
             sessionId: options?.sessionId,
             sessionMode: options?.sessionMode,
             cwd: options?.cwd ?? (this.shellCwd || process.cwd()),
             title: options?.title || 'ZTC',
-            providerOverride: isPaneProvider(resolved.provider) ? resolved.provider : undefined,
+            providerOverride: isPaneProvider(resolved.provider, configStore.getResolvedAuthMode()) ? resolved.provider : undefined,
             modelOverride: resolved.model,
             extraArgs: [],
         });
@@ -3882,7 +3893,7 @@ export class RatatuiApp {
         const configProvider = configStore.getProvider();
         const providerOverride = launchSpec?.kind === 'ztc' ? launchSpec.providerOverride : undefined;
         const modelOverride = launchSpec?.kind === 'ztc' ? launchSpec.modelOverride : undefined;
-        const configuredPaneProvider = isPaneProvider(configProvider) ? configProvider : undefined;
+        const configuredPaneProvider = isPaneProvider(configProvider, configStore.getResolvedAuthMode()) ? configProvider : undefined;
         const effectiveProvider = isZtc
             ? providerOverride
                 || (!modelOverride ? configuredPaneProvider : undefined)
@@ -4284,13 +4295,18 @@ export class RatatuiApp {
                 // --- Shared validation ---
                 let nextOverride = null;
                 if (command.override) {
-                    const resolved = resolveModelAndProvider(command.override.model, command.override.provider);
-                    if (!isPaneProvider(resolved.provider) || !resolved.model || !isCatalogModelForProvider(resolved.provider, resolved.model)) {
+                    const route = configStore.getResolvedAuthMode();
+                    const resolved = resolveModelAndProvider(command.override.model, command.override.provider, route);
+                    const catalog = configStore.getRoutedModelCatalog();
+                    const knownModel = catalog?.version === 1
+                        ? catalog.models.some(row => row.owned_by === resolved.provider && row.id === resolved.model && row.capabilities?.chat)
+                        : isCatalogModelForProvider(resolved.provider || '', resolved.model);
+                    if (!isPaneProvider(resolved.provider, route) || !resolved.model || !knownModel) {
                         const error = 'Unsupported pane model selection.';
                         this.publishPaneSystemMessage(command.pane_id, error);
                         return { ok: false, error };
                     }
-                    if (!configStore.getApiKey(resolved.provider) && !configStore.isAuthenticated()) {
+                    if (route !== 'zrouter' && !configStore.getApiKey(resolved.provider) && !configStore.isAuthenticated()) {
                         const error = `no API key configured for provider ${resolved.provider}`;
                         this.publishPaneSystemMessage(command.pane_id, error);
                         return { ok: false, error };
@@ -4352,7 +4368,7 @@ export class RatatuiApp {
                 const effectiveProvider = nextOverride?.provider || configStore.getProvider();
                 this.childPaneModels.set(command.pane_id, effectiveModel);
                 pane.effectiveModel = effectiveModel;
-                pane.effectiveProvider = isPaneProvider(effectiveProvider) ? effectiveProvider : undefined;
+                pane.effectiveProvider = isPaneProvider(effectiveProvider, configStore.getResolvedAuthMode()) ? effectiveProvider : undefined;
                 this.mirrorServer?.setPaneModel(command.pane_id, effectiveModel, effectiveProvider);
                 if (pane.launchSpec?.kind === 'ztc') {
                     pane.launchSpec.providerOverride = nextOverride?.provider;
@@ -4377,8 +4393,8 @@ export class RatatuiApp {
                     return { ok: false, error };
                 }
                 const level = (effort ?? null);
-                if (level !== null && !isCodexReasoningEffortSupported(command.provider, command.model, level)) {
-                    const supported = getSupportedCodexReasoningEfforts(command.model, command.provider) ?? [];
+                if (level !== null && !isCodexReasoningEffortSupported(command.provider, command.model, level, configStore.getReasoningWireSurface(command.provider, command.model))) {
+                    const supported = getSupportedCodexReasoningEfforts(command.model, command.provider, configStore.getReasoningWireSurface(command.provider, command.model)) ?? [];
                     const error = unsupportedEffortMessage(command.model, level, supported);
                     this.publishPaneSystemMessage(command.pane_id, error);
                     return { ok: false, error };
@@ -4897,7 +4913,8 @@ export class RatatuiApp {
         // the static table alone would revert the denominator (e.g. 400K -> 200K for
         // would revert the denominator to a stale static fallback until the next
         // token_usage event corrects it.
-        const windowOverride = this.controller.getState().contextStatus?.total;
+        const advertisedWindow = configStore.getModelContextWindow(model);
+        const windowOverride = advertisedWindow !== undefined ? advertisedWindow : this.controller.getState().contextStatus?.total;
         const status = contextStatusFromUsed(used, model, windowOverride);
         this.controller.dispatch({ type: 'SET_CONTEXT', length: used, estimated, status });
         const agentState = this.controller.getState().agentState;
@@ -5616,7 +5633,16 @@ export class RatatuiApp {
             ? this.inputState.segments[0].text : '';
         if (textCursorIndex(this.inputState.segments, this.inputState.cursor) !== text.length)
             text = '';
-        this.selectionCompletion.update(text, configStore.getProvider(), (signal, provider, authMode) => buildModelsController(configStore).list(provider, { signal, authMode }), commands, configStore.getModel());
+        let routed = configStore.getAuthMode() === 'zrouter';
+        try {
+            routed = configStore.resolveLLMBackendConfig().useProxy;
+        }
+        catch { /* Discovery can still show its isolated cache. */ }
+        const reasoningCommand = /^\/(?:effort|thinking)\s/i.test(text);
+        const connection = reasoningCommand && routed ? configStore.getRouterCatalogConnection() : undefined;
+        this.selectionCompletion.update(text, configStore.getProvider(), (signal, provider, authMode) => buildModelsController(configStore).list(provider, { signal, authMode }), commands, configStore.getModel(), buildModelsController(configStore).catalog, routed, reasoningCommand ? { catalog: routed ? configStore.getRoutedModelCatalog() : undefined,
+            current: configStore.getCodexEffort(), contract: configStore.getReasoningContract(),
+            scope: connection ? routerCatalogScope(connection) : undefined } : {});
         return this.selectionCompletion.view();
     }
     handleInput(input, key) {
@@ -5708,8 +5734,15 @@ export class RatatuiApp {
         this.updateSelectionCompletion();
         const selection = this.selectionCompletion.handleKey({ ...key, return: key.return || input === '\r' || input === '\n' });
         if (selection.handled) {
-            if (selection.text !== undefined)
-                this.setInputToText(selection.text, selection.text.length);
+            if (selection.text !== undefined) {
+                if (selection.submit && !this.queueEdit) {
+                    this.clearComposerAfterSubmit(selection.text);
+                    void this.handleSubmit(selection.text);
+                }
+                else {
+                    this.setInputToText(selection.text, selection.text.length);
+                }
+            }
             else
                 this.render();
             return;
@@ -7420,7 +7453,7 @@ export class RatatuiApp {
                         // exact same math /context and auto-compact use, so all surfaces agree.
                         // event.contextWindow (when the provider reports one, e.g. Codex's
                         // modelContextWindow) overrides the static window guess.
-                        const status = contextStatusFromUsed(used, model, event.contextWindow);
+                        const status = contextStatusFromUsed(used, model, event.contextWindow ?? configStore.getModelContextWindow(model));
                         const total = status.total;
                         const percentage = status.percentage;
                         const previousContextTokens = this.controller.getState().agentState.contextTokens;
@@ -10389,33 +10422,37 @@ export class RatatuiApp {
         try {
             debugLog(`[${options.label}] Saving session before relaunch...`);
             await this.saveCurrentSession();
-            // Clean up
-            this.sessionManager?.stopAutoSave();
-            if (this.dictationCleanup) {
-                this.dictationCleanup();
-                this.dictationCleanup = null;
-            }
-            void shutdownLSPManager();
             if (this.mirrorServer) {
                 this.mirrorServer.publishSessionEnd({ reloadOnReconnect: true });
                 await stopMirrorStreamServer();
                 this.mirrorServer = null;
             }
-            // Tear down TUI (exits raw mode, leaves alternate screen)
-            await this.tui.stop();
+            // execve skips exit handlers. Release the old session's registry entry,
+            // timers, backends and renderer before replacing the process. Persistence
+            // already happened above, while the renderer could still snapshot panes.
+            await this.exit(false, { announce: false, persistSession: false, terminateProcess: false });
             // Build relaunch args: preserve runtime flags but force the target session
             // as the only resume target.
-            const { command, args, shell } = buildHotRestartLaunch(withActiveProfileArg(process.argv.slice(1)), options.sessionId, process.execPath);
             const spawnCwd = existsSync(options.cwd) ? options.cwd : process.cwd();
+            const { command, args, shell } = buildHotRestartLaunch(withActiveProfileArg(process.argv.slice(1)), options.sessionId, process.execPath, spawnCwd);
             debugLog(`[${options.label}] Spawning new process: ${command} ${args.join(' ')} (cwd=${spawnCwd})`);
-            const child = spawnChild(command, args, {
+            // Keep the foreground job alive. Spawning and exiting lets the shell
+            // reclaim the terminal, so the orphaned renderer fails with raw-mode EIO.
+            // Node 20 lacks execve; its fallback must wait until the replacement ends.
+            const runtime = process;
+            if (runtime.execve) {
+                process.chdir(spawnCwd);
+                runtime.execve(command, [command, ...args], process.env);
+            }
+            const result = spawnSync(command, args, {
                 stdio: 'inherit',
                 cwd: spawnCwd,
                 env: process.env,
                 shell,
             });
-            child.unref();
-            process.exit(0);
+            if (result.error)
+                throw result.error;
+            process.exit(result.status ?? 1);
         }
         catch (err) {
             debugLog(`[${options.label}] Failed: ${err.message}`);

package/dist/config/defaults.d.ts

@@ -1,3 +1,4 @@
+import type { ReasoningWireSurface } from '@zerg/model-contracts';
 import type { CodexReasoningEffort, ZTCConfig } from './types.js';
 export declare const DEFAULT_OPENAI_MODEL = "gpt-5.4-nano";
 export declare const DEFAULT_CODEX_MODEL = "gpt-5.6-sol";
@@ -14,7 +15,7 @@ export declare const DEFAULT_CLARIFAI_MODEL = "https://clarifai.com/openai/chat-
  * undefined (use the provider default). Used both when building an agent
  * (factory) and to display the active effort in the model picker.
  */
-export declare function resolveCodexEffort(config: ZTCConfig, provider?: string, model?: string): CodexReasoningEffort | undefined;
+export declare function resolveCodexEffort(config: ZTCConfig, provider?: string, model?: string, contract?: ReasoningWireSurface | import('../utils/router_catalog.js').RouterModelCapabilities): 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.

package/dist/config/defaults.js

@@ -20,14 +20,19 @@ export const DEFAULT_CLARIFAI_MODEL = 'https://clarifai.com/openai/chat-completi
  * undefined (use the provider default). Used both when building an agent
  * (factory) and to display the active effort in the model picker.
  */
-export function resolveCodexEffort(config, provider, model) {
+export function resolveCodexEffort(config, provider, model, contract = config.authMode === 'zrouter' || provider === 'openai_compatible' ? 'chat_tools' : 'native_api') {
     const candidates = [
         model ? config.codexEffortByModel?.[model] : undefined,
         provider ? config.codexEffortByProvider?.[provider] : undefined,
         config.codexEffort,
     ];
     for (const candidate of candidates) {
-        if (candidate && isCodexReasoningEffortSupported(provider, model, candidate))
+        if (!candidate)
+            continue;
+        const supported = typeof contract === 'string'
+            ? isCodexReasoningEffortSupported(provider, model, candidate, contract)
+            : contract.reasoning?.choices.includes(candidate);
+        if (candidate && supported)
             return candidate;
     }
     return undefined;
@@ -143,6 +148,8 @@ export function getDefaultApiKeyForProvider(provider) {
             return process.env.DEEPSEEK_API_KEY;
         case 'modal':
             return undefined; // Modal credentials belong to the Router platform.
+        case 'fireworks':
+            return process.env.FIREWORKS_API_KEY;
         default:
             return (process.env.ANTHROPIC_API_KEY
                 || process.env.OPENAI_API_KEY

package/dist/config/resolved.d.ts

@@ -35,8 +35,8 @@ export interface AuthContext {
  * `apiKey` is the DIRECT provider key (what a direct backend would use).
  * `authToken` is the platform/proxy bearer. When `useProxy` is true the active
  * backend streams through `proxyUrl` with `authToken`; the direct `apiKey` is
- * still surfaced so callers that special-case a provider (e.g. a direct Gemini
- * key) can opt out of the proxy.
+ * still surfaced for direct-provider construction. Auto-mode preferences are
+ * resolved before `useProxy` is returned.
  */
 export interface ResolvedLLMConfig {
     provider: string;