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

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

@@ -1,3 +1,5 @@
+import type { ReasoningWireSurface } from '@zerg/model-contracts';
+import type { ReasoningContract } from '../../utils/reasoning.js';
 import { AgentState, Message, FormFieldDef, type TodoStatus } from '../../types.js';
 import { ZTCConfig, ZTCAuthMode, ZTCConfigScope, OpenAICompatibleSettings, ZTCPermissionProfile, IntentLayerSettings, WorkflowSettings, CodexReasoningEffort } from '../../config/types.js';
 import type { AuthContext, ResolvedLLMConfig } from '../../config/resolved.js';
@@ -9,6 +11,11 @@ import type { BenchController } from '../../bench/controller.js';
 import type { SlashUsage } from './usage_spec.js';
 import type { KeyEvent } from '../../ui/widgets/types.js';
 export interface ConfigController {
+    getRouterCatalogConnection?: () => import('../../utils/router_catalog.js').RouterCatalogConnection | undefined;
+    getRoutedModelCatalog?: () => import('../../utils/router_catalog.js').RouterCatalog | undefined;
+    adoptRouterCatalog?(catalog: import('../../utils/router_catalog.js').RouterCatalog): Promise<void>;
+    getRouterCatalog?: () => import('../../utils/router_catalog.js').RouterCatalog | undefined;
+    getModelContextWindow?: (model?: string, provider?: string) => number | null | undefined;
     locationLabel?: string;
     get: () => ZTCConfig;
     set: <K extends keyof ZTCConfig>(key: K, value: ZTCConfig[K]) => void;
@@ -49,6 +56,8 @@ export interface ConfigController {
     getModel?: () => string;
     setModelEffort: (model: string, level: CodexReasoningEffort | null) => void;
     /** Effort chosen by a startup `--effort` for this process only. */
+    getReasoningWireSurface?: (provider?: string, model?: string) => ReasoningWireSurface;
+    getReasoningContract?: (provider?: string, model?: string) => ReasoningContract;
     getCodexEffortOverride?: () => CodexReasoningEffort | undefined;
     /** Drop the process-only effort override after an explicit in-session choice. */
     clearCodexEffortOverride?: () => void;
@@ -93,9 +102,13 @@ export interface ClipboardController {
     writeText: (text: string) => Promise<void>;
 }
 export interface ModelsController {
+    catalog?: (signal?: AbortSignal, options?: {
+        refresh?: boolean;
+    }) => Promise<import('../../utils/router_catalog.js').RouterCatalog>;
     list: (provider?: string, options?: {
         signal?: AbortSignal;
         authMode?: 'direct' | 'zrouter';
+        refresh?: boolean;
     }) => Promise<string[]>;
 }
 export interface SkillsController {
@@ -293,6 +306,12 @@ export interface CommandContext {
     }) => void;
     /** Reconfigure this running session from another config profile. */
     switchConfigProfile?: (name: string) => Promise<void>;
+    /**
+     * Copy a profile's settings into a new one and switch to it, returning the
+     * new profile's name. Optional exactly as `switchConfigProfile` is: a
+     * renderer that cannot switch in place cannot duplicate either.
+     */
+    duplicateProfile?: (name: string, source: string) => Promise<string>;
     /**
      * Apply a provider/model selection to the currently running process. This
      * updates any session-local runtime override before recreating the agent, so

package/dist/agent/factory.js

@@ -1,5 +1,6 @@
+import { readRouterCatalog } from '../utils/router_catalog.js';
 import { Agent } from './agent.js';
-import { OpenAICompatibleBackend, GeminiBackend, ZergAPIBackend, ZRouterStreamBackend, createBackendForProvider } from './backends/index.js';
+import { ZergAPIBackend, ZRouterStreamBackend, createBackendForProvider } from './backends/index.js';
 import { CODEX_AUTH_SENTINEL } from './backends/codex_auth.js';
 import { CLAUDE_CODE_AUTH_SENTINEL } from './backends/claude_cli.js';
 import { KIMI_CODE_AUTH_SENTINEL } from './backends/kimi_code_auth.js';
@@ -232,7 +233,17 @@ export function resolveAgentBackendFromConfig(options) {
         runtimeDiag('error', '[ztc] Modal requires Zerg Router authentication. Run ztc auth login and use authMode zrouter.');
         return null;
     }
-    if (isCodexAppServerProvider(provider)) {
+    if (useProxy) {
+        // Route selection is resolved before any provider-specific backend.
+        apiKey = proxyToken;
+        const connection = configStore.getRouterCatalogConnection(proxyUrl);
+        const workspaceId = connection?.token === apiKey ? connection.workspaceId : undefined;
+        runtimeDiag('info', `[ztc] routing LLM via ZergRouter proxy ${JSON.stringify({ proxy_url: proxyUrl, provider, has_token: Boolean(proxyToken) })}`);
+        backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider, conversationId: options.sessionId,
+            workspaceId,
+            catalog: readRouterCatalog({ origin: proxyUrl, token: apiKey, workspaceId }) });
+    }
+    else if (isCodexAppServerProvider(provider)) {
         try {
             backend = createBackendForProvider(provider, {
                 apiKey: '',
@@ -297,71 +308,6 @@ export function resolveAgentBackendFromConfig(options) {
         }
         apiKey = KIMI_CODE_AUTH_SENTINEL;
     }
-    else if (useProxy) {
-        // Proxy mode: stream through the platform ZRouter proxy.
-        //
-        // ZRouter emits a UNIFIED custom SSE ({type:delta|usage|done}) for ALL
-        // providers — on /v1/messages (anthropic) AND /v1/chat/completions (openai
-        // et al.), NOT the provider-native SSE. So the SDK-shaped backends
-        // (AnthropicBackend / OpenAICompatibleBackend) can't parse the proxy stream
-        // (they expect native SSE) and would render empty. ZRouterStreamBackend
-        // speaks the unified format for every provider, so route all proxy arms
-        // through it. The one exception is a user-supplied direct Gemini key, which
-        // hits Google natively and skips the proxy.
-        apiKey = proxyToken;
-        // Proof-chain log: confirms the agent chose the router (visible in the
-        // container's logs via ZergCloud /container-logs). Never logs the token.
-        runtimeDiag('info', `[ztc] routing LLM via ZergRouter proxy ${JSON.stringify({
-            proxy_url: proxyUrl,
-            provider,
-            has_token: Boolean(proxyToken),
-        })}`);
-        // Router forwards this to Modal as a conversation pin, so the turns of one
-        // conversation keep reusing one container's cached prompt prefix. It is the
-        // ZTC session id, so it survives `--resume`; the per-process client session
-        // Router already receives does not. Undefined when the caller has no session
-        // (the backend then omits the header).
-        const conversationId = options.sessionId;
-        switch (provider) {
-            case 'openai':
-                backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider: 'openai', conversationId });
-                break;
-            case 'gemini': {
-                // Auto mode prefers the user's direct Gemini key; forced Router mode
-                // keeps its authenticated proxy route. Otherwise
-                // stream through ZRouter's gemini path. Use the resolver's already-computed
-                // directApiKey — re-reading the env-first singleton would bypass the
-                // options.config snapshot / apiKey override the resolver honors.
-                const geminiDirectKey = directApiKey;
-                if (geminiDirectKey && authMode !== 'zrouter') {
-                    backend = new GeminiBackend({ apiKey: geminiDirectKey });
-                    apiKey = geminiDirectKey;
-                }
-                else {
-                    backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider: 'gemini', conversationId });
-                }
-                break;
-            }
-            case 'inception':
-                // ZRouter has no inception provider path; keep the OpenAI-compatible shim.
-                backend = new OpenAICompatibleBackend({ apiKey, baseUrl: `${proxyUrl}/v1`, extraBody: { provider: 'inception' } });
-                break;
-            case 'openai_compatible':
-                backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider: 'openai_compatible', conversationId });
-                break;
-            case 'kimi':
-            case 'moonshot':
-                backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider: 'kimi', conversationId });
-                break;
-            case 'modal':
-            case 'deepseek':
-                backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider, conversationId });
-                break;
-            case 'anthropic':
-            default:
-                backend = new ZRouterStreamBackend({ apiKey, proxyUrl: proxyUrl, provider: 'anthropic', conversationId });
-        }
-    }
     else if (useDirectProvider) {
         // Use direct provider with user's API key — delegate to shared factory.
         // For openai_compatible we pass full settings (headers / apiPath) so
@@ -734,7 +680,7 @@ export function createAgentFromConfig(options) {
         tracer: options.tracer,
         hooks,
         approvalRequester: options.hookApprovalRequester,
-        codexEffort: resolveCodexEffort(options.config, provider, effectiveModel),
+        codexEffort: resolveCodexEffort(options.config, provider, effectiveModel, backend.getModelCapabilities?.(effectiveModel)),
         codexFastMode: options.config.codexFastMode,
         // Codex panes never defer: dynamicTools are registered once at thread/start,
         // so a schema hidden behind tool_search would be unreachable for the whole

package/dist/agent/subagent.d.ts

@@ -1,13 +1,3 @@
-/**
- * SubAgent - Isolated agent for context-heavy operations
- *
- * Spawns a separate agent with its own context to handle tasks like:
- * - Exploring codebases
- * - Searching for patterns
- * - Reading multiple files
- *
- * Only the final summary is returned to the main agent, keeping the main context clean.
- */
 import { AgentBackend } from './backends/index.js';
 import type { Tool } from './tools/types.js';
 import type { Policy } from './runtime/policy.js';

package/dist/agent/subagent.js

@@ -1,3 +1,5 @@
+import { ZRouterStreamBackend } from './backends/zrouter_stream.js';
+import { readRouterCatalog } from '../utils/router_catalog.js';
 /**
  * SubAgent - Isolated agent for context-heavy operations
  *
@@ -44,6 +46,18 @@ function isToolUseBlock(block) {
 function getSubAgentModel(provider, preferredModel) {
     if (preferredModel)
         return preferredModel;
+    if (configStore.resolveLLMBackendConfig({ provider }).useProxy) {
+        if (configStore.getProvider() === provider)
+            return configStore.getModel();
+        const catalog = configStore.getRouterCatalog();
+        const rows = catalog?.models.filter(row => row.owned_by === provider && (catalog.version === 0 || row.capabilities?.chat));
+        const selected = rows?.find(row => row.is_default) ?? rows?.[0];
+        if (selected)
+            return selected.id;
+        if (!configStore.getRouterCatalog() || configStore.getRouterCatalog()?.version === 0)
+            return getDefaultModel(provider, 'cheap');
+        throw new Error('Select a Router model for this subagent.');
+    }
     return getDefaultModel(provider, 'cheap');
 }
 /**
@@ -57,6 +71,12 @@ function getSubAgentModel(provider, preferredModel) {
  */
 function createBackend(provider, apiKey) {
     const config = configStore.get();
+    const resolved = configStore.resolveLLMBackendConfig({ provider, apiKeyOverride: apiKey });
+    if (resolved.useProxy) {
+        return new ZRouterStreamBackend({ apiKey: resolved.authToken, proxyUrl: resolved.proxyUrl, provider,
+            workspaceId: configStore.getRouterCatalogConnection()?.workspaceId,
+            catalog: readRouterCatalog({ origin: resolved.proxyUrl, token: resolved.authToken, workspaceId: configStore.getRouterCatalogConnection()?.workspaceId }) });
+    }
     const accountOpts = accountBackendOptions(config, provider);
     const rotationOpts = subagentShouldRotate(resolveRotation(config))
         ? buildAccountRotation(config) ?? {}
@@ -109,6 +129,8 @@ export class SubAgent {
      * @param opts  Optional overrides (abort signal, custom system prompt, tools)
      */
     async run(task, opts) {
+        if (this.backend.getModelCapabilities?.(this.model)?.tools === false)
+            throw new Error('Chat-only models cannot run tool-dependent subagents.');
         const signal = opts?.signal;
         const startTime = Date.now();
         const timeoutMs = this.config.timeoutMs || 120000; // 2 minute default

package/dist/agent/tool_response_store.d.ts

@@ -72,7 +72,7 @@ export declare class ToolResponseStore {
      * fraction of the active model's context window so a small-context model
      * (gpt-4 8k → 2k effective) doesn't get crushed by a Claude-tuned default.
      */
-    effectiveBudget(model: string): number;
+    effectiveBudget(model: string, windowOverride?: number | null): number;
     private cacheBudgetTokens;
     /**
      * Swap to a new session directory. Preloads only `meta` from each record

package/dist/agent/tool_response_store.js

@@ -173,9 +173,11 @@ export class ToolResponseStore {
      * fraction of the active model's context window so a small-context model
      * (gpt-4 8k → 2k effective) doesn't get crushed by a Claude-tuned default.
      */
-    effectiveBudget(model) {
+    effectiveBudget(model, windowOverride) {
         const configured = this.config.configuredInlineBudgetTokens;
-        const window = getContextWindowSize(model);
+        const window = getContextWindowSize(model, windowOverride);
+        if (window === 0)
+            return configured;
         return Math.min(configured, Math.floor(window * PER_MODEL_BUDGET_FRACTION));
     }
     cacheBudgetTokens() {

package/dist/agent/tools/pane.d.ts

@@ -1,10 +1,3 @@
-/**
- * Terminal pane management tools for zmux mode.
- *
- * These tools allow the agent to create, read, write to, close,
- * and list terminal panes when running inside zmux.
- * They communicate with the zmux Rust binary via the IPC socket.
- */
 import { Tool } from './types.js';
 import type { PaneCommandTransport } from '../../ui/ratatui/pane_relay.js';
 import type { RustEvent } from '../../ui/ratatui/protocol.js';

package/dist/agent/tools/pane.js

@@ -1,3 +1,4 @@
+import { configStore } from '../../config.js';
 /**
  * Terminal pane management tools for zmux mode.
  *
@@ -440,8 +441,8 @@ export function buildChildZtcPaneLaunch(extraArgs = [], childSessionId = generat
             i++;
         }
     }
-    const resolved = model ? resolveModelAndProvider(model, provider) : { model: undefined, provider };
-    const knownProvider = isPaneProvider(resolved.provider) ? resolved.provider : undefined;
+    const resolved = model ? resolveModelAndProvider(model, provider, configStore.getResolvedAuthMode()) : { model: undefined, provider };
+    const knownProvider = isPaneProvider(resolved.provider, configStore.getResolvedAuthMode()) ? resolved.provider : undefined;
     const fallbackArgs = [];
     if (provider && !knownProvider)
         fallbackArgs.push('--provider', provider);
@@ -681,7 +682,7 @@ export const createZtcPaneTool = {
         let provider = args.provider ? String(args.provider) : undefined;
         let model = args.model ? String(args.model) : undefined;
         if (model) {
-            const resolved = resolveModelAndProvider(model, provider);
+            const resolved = resolveModelAndProvider(model, provider, configStore.getResolvedAuthMode());
             model = resolved.model;
             provider = resolved.provider;
         }
@@ -725,7 +726,7 @@ export const createZtcPaneTool = {
             sessionMode: 'new',
             cwd,
             title,
-            providerOverride: isPaneProvider(provider) ? provider : undefined,
+            providerOverride: isPaneProvider(provider, configStore.getResolvedAuthMode()) ? provider : undefined,
             modelOverride: model,
             extraArgs: filterChildZtcArgs(allExtraArgs),
         });

package/dist/app/command_context.js

@@ -1,10 +1,5 @@
-/**
- * CommandContext Factory
- *
- * Shared helpers for building CommandContext objects used by command handlers.
- * Eliminates duplication between TUI (cli_ratatui.ts) and headless (headless.ts) renderers.
- */
-import { listModels } from '../utils/models.js';
+import { discoverRouterCatalog, readRouterCatalog, routerModelIds, routerCatalogScope } from '../utils/router_catalog.js';
+import { loadModelCatalog } from './model_catalog_cache.js';
 import { getSkills } from '../skills/registry.js';
 import { runShellCommand } from '../utils/shell.js';
 import { configStore } from '../config.js';
@@ -44,18 +39,46 @@ export function routeUserInput(text) {
  */
 export function buildModelsController(config) {
     return {
+        catalog: async (signal, options) => {
+            try {
+                const connection = config.getRouterCatalogConnection?.();
+                if (!connection)
+                    throw new Error('Router discovery requires a Router login. Run ztc auth login.');
+                const scope = routerCatalogScope(connection);
+                signal?.throwIfAborted();
+                const previous = readRouterCatalog(connection);
+                const age = previous === undefined ? Infinity : Date.now() - previous.fetchedAt;
+                const catalog = !options?.refresh && previous && !previous.authRequired && age >= 0 && age < 30_000
+                    ? previous : await discoverRouterCatalog(connection, signal);
+                signal?.throwIfAborted();
+                const active = config.getRouterCatalogConnection?.();
+                if (!active || routerCatalogScope(active) !== scope)
+                    throw new Error('Router discovery context changed. Retry model discovery.');
+                await config.adoptRouterCatalog?.(catalog);
+                return catalog;
+            }
+            catch (error) {
+                const cached = config.getRouterCatalog?.();
+                if (!signal?.aborted && cached)
+                    return { ...cached, ...(error instanceof Error && /authentication|expired|login|origin/i.test(error.message) ? { authRequired: true } : {}) };
+                throw error;
+            }
+        },
         list: async (provider, options) => {
+            if ((options?.authMode ?? config.getAuthMode?.()) === 'zrouter') {
+                const controller = buildModelsController(config);
+                return routerModelIds(await controller.catalog(options?.signal, options), provider ?? config.getProvider());
+            }
             const llm = config.resolveLLMBackendConfig({ provider,
                 config: options?.authMode ? { ...config.get(), authMode: options.authMode } : undefined });
-            // Preserve discovery failures so callers can distinguish an unavailable
-            // catalog from a successful provider response with zero supported models.
-            return listModels({
+            return loadModelCatalog({
                 signal: options?.signal,
                 provider: llm.provider,
                 apiKey: llm.apiKey,
                 baseUrl: llm.provider === 'openai_compatible' ? llm.compatBaseUrl : undefined,
                 proxyUrl: llm.useProxy ? llm.proxyUrl : undefined,
                 authToken: llm.useProxy ? llm.authToken : undefined,
+                workspaceId: llm.useProxy ? config.getRouterCatalogConnection?.()?.workspaceId : undefined,
                 codexAppServerCommand: llm.codexAppServerCommand,
                 codexAppServerArgs: llm.codexAppServerArgs,
                 codexHome: llm.codexHome,

package/dist/app/model_catalog_cache.d.ts

@@ -0,0 +1,5 @@
+import { listModels } from '../utils/models.js';
+type ListModelsOptions = Parameters<typeof listModels>[0];
+/** Shared discovery for all renderers. Disk rows are previews, not entitlements. */
+export declare function loadModelCatalog(options: ListModelsOptions, onVerified?: (models: string[]) => void): Promise<string[]>;
+export {};

package/dist/app/model_catalog_cache.js

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+import { profileConfigDir } from '../config/profiles.js';
+import { listModels } from '../utils/models.js';
+import { clearCachedModels, readCachedModels, readCachedModelsFetchedAt, writeCachedModels } from '../utils/model_cache.js';
+const FRESH_MS = 30_000;
+const OFFLINE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const MAX_SCOPES = 64;
+const MAX_CACHED_MODELS = 512;
+const catalogs = new Map();
+let writes = Promise.resolve();
+function scopeFor(options) {
+    // Never persist raw credentials. Profiles, endpoints and credential identities
+    // are separate catalogs; switching any of them must bypass the old entry.
+    const identity = [profileConfigDir(), options.provider, options.proxyUrl?.replace(/\/$/, ''),
+        options.authToken, options.workspaceId, options.baseUrl?.replace(/\/$/, ''), options.apiKey,
+        options.codexAppServerCommand, options.codexAppServerArgs, options.codexHome,
+        options.codexAuthFilePath, options.kimiCredsFilePath];
+    return `${options.provider}:${createHash('sha256').update(JSON.stringify(identity)).digest('hex')}`;
+}
+function persist(profile, action) {
+    writes = writes.then(async () => {
+        // A response can arrive after a profile switch. Do not write that response
+        // into the new profile's cache, even under an unreachable hashed scope.
+        if (profileConfigDir() === profile)
+            await action();
+    }).catch(() => { });
+}
+function joinRequest(entry, pending, signal) {
+    signal?.throwIfAborted();
+    entry.waiters++;
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return false;
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            entry.waiters--;
+            if (!entry.waiters && !entry.background)
+                entry.controller?.abort();
+            return true;
+        };
+        const abort = () => { if (finish())
+            reject(signal.reason); };
+        signal?.addEventListener('abort', abort, { once: true });
+        pending.then(models => { if (finish())
+            resolve([...models]); }, error => { if (finish())
+            reject(error); });
+    });
+}
+function freshModels(entry) {
+    if (entry.models === undefined || entry.checkedAt === null)
+        return undefined;
+    const age = Date.now() - entry.checkedAt;
+    return age >= 0 && age < FRESH_MS ? [...entry.models] : undefined;
+}
+/** Shared discovery for all renderers. Disk rows are previews, not entitlements. */
+export async function loadModelCatalog(options, onVerified) {
+    options.signal?.throwIfAborted();
+    const profile = profileConfigDir();
+    const scope = scopeFor(options);
+    let entry = catalogs.get(scope);
+    if (entry?.controller?.signal.aborted) {
+        catalogs.delete(scope);
+        entry = undefined;
+    }
+    if (!entry) {
+        if (catalogs.size >= MAX_SCOPES) {
+            const oldest = catalogs.keys().next().value;
+            catalogs.get(oldest).controller?.abort();
+            catalogs.delete(oldest);
+        }
+        entry = { checkedAt: null, waiters: 0, background: false, diskChecked: false };
+        catalogs.set(scope, entry);
+    }
+    // Keep the map in access order for bounded eviction.
+    catalogs.delete(scope);
+    catalogs.set(scope, entry);
+    const fresh = freshModels(entry);
+    if (fresh !== undefined) {
+        onVerified?.([...fresh]);
+        return fresh;
+    }
+    if (entry.models === undefined && !entry.pending && !entry.diskChecked) {
+        entry.diskChecked = true;
+        const [cached, fetchedAt] = await Promise.all([readCachedModels(scope), readCachedModelsFetchedAt(scope)]);
+        options.signal?.throwIfAborted();
+        const age = fetchedAt === undefined ? Infinity : Date.now() - fetchedAt;
+        if (entry.models === undefined && cached.length && age >= 0 && age < OFFLINE_MAX_AGE_MS)
+            entry.models = cached;
+    }
+    if (catalogs.get(scope) !== entry)
+        throw new DOMException('Model discovery was superseded', 'AbortError');
+    const afterRead = freshModels(entry);
+    if (afterRead !== undefined) {
+        onVerified?.([...afterRead]);
+        return afterRead;
+    }
+    const current = entry;
+    const refresh = () => {
+        if (current.pending)
+            return current.pending;
+        const controller = new AbortController();
+        current.controller = controller;
+        const pending = listModels({ ...options, signal: controller.signal }).then(models => {
+            controller.signal.throwIfAborted();
+            const cacheable = models.length <= MAX_CACHED_MODELS
+                && models.every(id => id.length <= 256 && !/[\r\n\0]/.test(id));
+            current.models = cacheable ? [...models] : undefined;
+            current.checkedAt = Date.now();
+            persist(profile, () => models.length && cacheable ? writeCachedModels(scope, models) : clearCachedModels(scope));
+            return models;
+        }).catch(error => {
+            // A denial invalidates the preview. Temporary transport errors retain it.
+            if (error instanceof Error && /\((401|403)\)/.test(error.message)) {
+                current.models = undefined;
+                persist(profile, () => clearCachedModels(scope));
+            }
+            throw error;
+        }).finally(() => {
+            if (current.pending === pending) {
+                current.pending = undefined;
+                current.controller = undefined;
+                current.background = false;
+            }
+        });
+        current.pending = pending;
+        return pending;
+    };
+    if (current.models !== undefined) {
+        current.background = true;
+        void refresh().then(models => onVerified?.([...models])).catch(() => { });
+        return [...current.models];
+    }
+    const models = await joinRequest(current, refresh(), options.signal);
+    onVerified?.([...models]);
+    return models;
+}

package/dist/app/restart.d.ts

@@ -69,7 +69,7 @@ export declare function reduceDesktopUpdateOwnerHandshake(phase: DesktopUpdateOw
  */
 export declare function prepareDesktopUpdateAuthorization(persistSession: (force: true) => Promise<void>, send: (command: DesktopUpdateRestartCommand) => boolean): Promise<DesktopUpdatePreparation>;
 export declare function buildHotRestartArgs(argv: readonly string[], sessionId: string): string[];
-export declare function buildHotRestartLaunch(argv: readonly string[], sessionId: string, execPath: string): HotRestartLaunch;
+export declare function buildHotRestartLaunch(argv: readonly string[], sessionId: string, execPath: string, cwd?: string): HotRestartLaunch;
 export declare function buildDesktopUpdateRelaunchContext(argv: readonly string[], sessionId: string, execPath: string, cwd: string, ownerPid: number): string;
 export declare function requestColonyCellRestart(env?: Record<string, string | undefined>, fetchImpl?: typeof fetch): Promise<void>;
 export {};

package/dist/app/restart.js

@@ -1,3 +1,5 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 const RESTART_SESSION_FLAGS = new Set(['--resume', '--continue', '-c', '--session-id']);
 /**
  * Reduce native updater protocol events and local persistence outcomes into
@@ -113,14 +115,23 @@ export function buildHotRestartArgs(argv, sessionId) {
     }
     return [...next, '--resume', sessionId];
 }
-export function buildHotRestartLaunch(argv, sessionId, execPath) {
+export function buildHotRestartLaunch(argv, sessionId, execPath, cwd) {
     const relaunchArgs = buildHotRestartArgs(argv, sessionId);
+    // The picker can switch workspaces. Override a launcher's original --cwd;
+    // cli_main deliberately uses the last occurrence of that flag.
+    if (cwd)
+        relaunchArgs.push('--cwd', cwd);
     const entryScript = relaunchArgs[0] || '';
-    const isTsEntry = entryScript.endsWith('.ts');
+    const isTsEntry = /\.[cm]?tsx?$/.test(entryScript);
+    // Resolve from this installation, not the selected session's working dir.
+    // Direct argv also preserves spaces/metacharacters without a shell or npx.
+    const loaderArgs = isTsEntry
+        ? ['--import', pathToFileURL(createRequire(import.meta.url).resolve('tsx')).href]
+        : [];
     return {
-        command: isTsEntry ? 'npx' : execPath,
-        args: isTsEntry ? ['tsx', ...relaunchArgs] : relaunchArgs,
-        shell: isTsEntry,
+        command: execPath,
+        args: [...loaderArgs, ...relaunchArgs],
+        shell: false,
     };
 }
 export function buildDesktopUpdateRelaunchContext(argv, sessionId, execPath, cwd, ownerPid) {

package/dist/app/selection_completion.d.ts

@@ -1,3 +1,6 @@
+import { type RouterCatalog } from '../utils/router_catalog.js';
+import { type ReasoningContract } from '../utils/reasoning.js';
+import type { CodexReasoningEffort } from '../config/types.js';
 import { type SlashCommandUsage } from '../agent/commands/usage_spec.js';
 export interface SelectionCandidate {
     value: string;
@@ -8,7 +11,9 @@ export interface SelectionCandidate {
     needsArgument?: boolean;
 }
 export interface SelectionCompletionView {
-    kind?: 'command' | 'provider' | 'model' | 'usage';
+    kind?: 'command' | 'provider' | 'model' | 'usage' | 'reasoning';
+    command?: 'effort' | 'thinking';
+    model?: string;
     query?: string;
     usage?: string;
     provider?: string;
@@ -22,6 +27,13 @@ export interface SelectionCompletionView {
     unavailable?: boolean;
     visibleRows?: number;
 }
+export interface ReasoningCompletionContext {
+    catalog?: RouterCatalog;
+    current?: CodexReasoningEffort;
+    contract?: ReasoningContract;
+    /** Opaque account/profile identity; invalidate definitions when it changes. */
+    scope?: string;
+}
 export declare function fuzzySelections(candidates: SelectionCandidate[], query: string): SelectionCandidate[];
 export declare function modelSelections(provider: string, discovered?: string[]): SelectionCandidate[];
 /** Static preview for renderers without a completion controller. Explicit null hides it. */
@@ -49,8 +61,10 @@ export declare class SelectionCompletion {
     private requestController;
     private commands;
     private currentModel?;
+    private routerCatalog?;
+    private reasoning;
     constructor(changed?: () => void);
-    update(text: string, provider: string, loadModels?: (signal: AbortSignal, provider: string, authMode?: 'direct' | 'zrouter') => Promise<string[]>, commands?: SlashCommandUsage[], currentModel?: string): void;
+    update(text: string, provider: string, loadModels?: (signal: AbortSignal, provider: string, authMode?: 'direct' | 'zrouter') => Promise<string[]>, commands?: SlashCommandUsage[], currentModel?: string, loadCatalog?: (signal: AbortSignal) => Promise<RouterCatalog>, activeRouted?: boolean, reasoning?: ReasoningCompletionContext): void;
     private filter;
     private revealSelection;
     setVisibleRows(rows: number): void;
@@ -73,6 +87,7 @@ export declare class SelectionCompletion {
     }): {
         handled: boolean;
         text?: string;
+        submit?: boolean;
     };
 }
 export declare const SELECTION_VISIBLE_ROWS = 4;