@zergai/ztc 0.5.0-beta.1 → 0.6.0-beta.1

package/dist/app/ask_user_response.js

@@ -14,3 +14,29 @@ export function formatAskUserResponse(questions, answers) {
     const { answer, note } = values[0];
     return note ? `${answer}\n\nAdditional context: ${note}` : answer;
 }
+/**
+ * The person's view of an answer message: one "question → answer" line per question. The model receives the JSON
+ * that formatAskUserResponse writes for several questions; drawn as is, it showed under "You" as raw JSON
+ * (2026-10-27). Content that is not that JSON is returned unchanged.
+ */
+export function displayAskUserResponse(content) {
+    let values;
+    try {
+        values = JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+    if (!Array.isArray(values) || values.length === 0)
+        return content;
+    const lines = [];
+    for (const value of values) {
+        if (!value || typeof value !== 'object')
+            return content;
+        const { question, answer, note } = value;
+        if (typeof question !== 'string' || typeof answer !== 'string')
+            return content;
+        lines.push(`${question} → ${answer}${typeof note === 'string' && note.trim() ? ` (${note.trim()})` : ''}`);
+    }
+    return lines.join('\n');
+}

package/dist/app/command_context.js

@@ -23,9 +23,11 @@ export function routeUserInput(text) {
         }
         return { type: 'message', text };
     }
-    // Slash commands (but not file paths)
-    if (text.startsWith('/') && !FILE_PATH_PREFIXES.some(p => text.startsWith(p))) {
-        const parts = text.slice(1).trimEnd().split(/\s+/);
+    // Slash commands (but not file paths). Leading whitespace does not hide one:
+    // redaction finds a key command after trimming, so routing does too.
+    const line = text.trimStart();
+    if (line.startsWith('/') && !FILE_PATH_PREFIXES.some(p => line.startsWith(p))) {
+        const parts = line.slice(1).trimEnd().split(/\s+/);
         const cmd = parts[0];
         if (!cmd.includes('/')) {
             if (cmd === 'job' && parts[1] === 'pin') {
@@ -36,7 +38,7 @@ export function routeUserInput(text) {
                 let quote = '';
                 let braces = 0;
                 let escaped = false;
-                const source = text.slice(1).trimEnd();
+                const source = line.slice(1).trimEnd();
                 for (let i = 0; i < source.length; i++) {
                     const char = source[i];
                     if (!quote && !braces && /\s/.test(char)) {
@@ -77,7 +79,7 @@ export function routeUserInput(text) {
             if (cmd.toLowerCase() === 'fork' || cmd.toLowerCase() === 'side') {
                 // A fork's body is authored task data, not tokenized command options.
                 // Remove exactly the command separator and retain the remaining bytes.
-                const task = text.slice(cmd.length + 2);
+                const task = line.slice(cmd.length + 2);
                 return { type: 'command', cmd, args: task.length ? [task] : [] };
             }
             return { type: 'command', cmd, args: parts.slice(1) };
@@ -225,6 +227,7 @@ export function buildAutoSelectWidgets() {
                 void Promise.resolve(callback(options.defaultValue || null));
             },
             cancelPrompt: () => { },
+            interactive: false,
         },
         form: {
             showForm: () => { },
@@ -275,18 +278,21 @@ const PLAN_MODE_SESSION_COMMANDS = new Set([
     'attention',
     'auth',
     'config',
+    'connect',
     'context',
     'effort',
     'fast',
     'help',
     'keybindings',
     'keymap',
+    'keys',
     'login',
     'logout',
     'model',
     'models',
     'permissions',
     'profile',
+    'reasoning',
     'rewind',
     'settings',
     'shortcuts',

package/dist/app/launch_notices.d.ts

@@ -0,0 +1,10 @@
+export interface LayoutRestoreResult {
+    restoredPanes: number;
+    skippedPanes: number;
+    diagnostic?: string;
+}
+/**
+ * The one notice a resumed mux layout earns: nothing when there was nothing
+ * to restore, otherwise how many panes came back and how to start them.
+ */
+export declare function layoutRestoreNotice(result: LayoutRestoreResult): string | null;

package/dist/app/launch_notices.js

@@ -0,0 +1,20 @@
+/**
+ * The one notice a resumed mux layout earns: nothing when there was nothing
+ * to restore, otherwise how many panes came back and how to start them.
+ */
+export function layoutRestoreNotice(result) {
+    if (result.diagnostic) {
+        return `Saved layout kept but not restored: ${result.diagnostic.replace(/\.$/, '')}.`;
+    }
+    const restored = Math.max(0, Math.floor(result.restoredPanes));
+    const skipped = Math.max(0, Math.floor(result.skippedPanes));
+    if (restored === 0 && skipped === 0)
+        return null;
+    const skippedNote = skipped > 0 ? ` (${skipped} skipped)` : '';
+    if (restored === 1) {
+        return `Restored 1 saved pane${skippedNote}. It starts stopped: /layout run <pane-id> starts it, /layout resume <pane-id> resumes its agent.`;
+    }
+    if (restored === 0)
+        return `No saved panes could be restored${skippedNote}.`;
+    return `Restored ${restored} saved panes${skippedNote}. They start stopped: /layout run <pane-id> starts one, /layout resume <pane-id> resumes its agent.`;
+}

package/dist/app/selection_completion.d.ts

@@ -1,6 +1,7 @@
 import { type RouterCatalog } from '../utils/router_catalog.js';
 import { type ReasoningContract } from '../utils/reasoning.js';
 import type { CodexReasoningEffort } from '../config/types.js';
+import { type ModelRoute, type ModelRouteStatus } from '../agent/commands/provider_choices.js';
 import { type SlashCommandUsage } from '../agent/commands/usage_spec.js';
 export interface SelectionCandidate {
     value: string;
@@ -9,6 +10,10 @@ export interface SelectionCandidate {
     description?: string;
     current?: boolean;
     needsArgument?: boolean;
+    /** Enter runs the input as typed instead of completing this row. */
+    submitsInput?: boolean;
+    /** Enter flips this setting and keeps the menu open. */
+    toggle?: 'openrouter.zdr';
 }
 export interface SelectionCompletionView {
     kind?: 'command' | 'provider' | 'model' | 'usage' | 'reasoning';
@@ -20,6 +25,10 @@ export interface SelectionCompletionView {
     mixed?: boolean;
     /** True when this model branch dispatches through Router, not a direct key. */
     routed?: boolean;
+    /** The route whose providers a provider list shows, when it shows only one. */
+    route?: ModelRoute;
+    /** When Router's list is an old saved copy (Router unreachable), the time it was fetched. */
+    savedAt?: number;
     candidates: SelectionCandidate[];
     selected: number;
     firstVisible?: number;
@@ -33,6 +42,8 @@ export interface ReasoningCompletionContext {
     contract?: ReasoningContract;
     /** Opaque account/profile identity; invalidate definitions when it changes. */
     scope?: string;
+    /** Whether OpenRouter models use zero-data-retention providers only; shown as a toggle while choosing one. */
+    openRouterZdr?: boolean;
 }
 export declare function fuzzySelections(candidates: SelectionCandidate[], query: string): SelectionCandidate[];
 export declare function modelSelections(provider: string, discovered?: string[]): SelectionCandidate[];
@@ -53,6 +64,8 @@ export declare class SelectionCompletion {
     private firstVisible;
     private visibleRows;
     private dismissedInput;
+    /** The person moved the highlight since the text last changed. */
+    private moved;
     private discovered;
     private loading;
     private unavailable;
@@ -63,9 +76,24 @@ export declare class SelectionCompletion {
     private currentModel?;
     private routerCatalog?;
     private reasoning;
+    private activeRouted;
+    /** Route status is read once per /model editing session; probing local logins is not free. */
+    private routeStatus?;
     constructor(changed?: () => 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;
+    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, loadRouteStatus?: () => ModelRouteStatus): void;
+    /**
+     * A list can change under the menu (discovery, Router's catalog arriving).
+     * The highlight follows its value only when the user moved it there;
+     * otherwise it stays on the top row.
+     */
     private filter;
+    /** Route status is known and has no current ZergAI login for Zerg Router. */
+    private routerLoginNeeded;
+    /** The one row Zerg Router choices show without a login: Enter runs /model, which asks. */
+    private routerLoginCandidate;
+    private routeSelections;
+    /** When Router's list on show is a saved copy over ten minutes old, the time it was fetched. */
+    private savedCopyAt;
     private revealSelection;
     setVisibleRows(rows: number): void;
     /** Keep the menu closed for text the user did not type character by character
@@ -88,6 +116,7 @@ export declare class SelectionCompletion {
         handled: boolean;
         text?: string;
         submit?: boolean;
+        toggle?: 'openrouter.zdr';
     };
 }
 export declare const SELECTION_VISIBLE_ROWS = 4;

package/dist/app/selection_completion.js

@@ -1,9 +1,11 @@
 import { routerModelIds, routerModelsForProvider, resolveRouterModel } from '../utils/router_catalog.js';
+import { formatPriceRange } from '../utils/openrouter_prices.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 { canRouteThroughRouter, canonicalProvider, canonicalRoute, describeDirectProvider, describeDirectRoute, describeRouterRoute, DIRECT_PROVIDER_CHOICES, isLocalSubscription, isRouterOnlyProvider, MODEL_ROUTE_CHOICES, PROVIDER_CHOICES, } from '../agent/commands/provider_choices.js';
 import { resolveSlashUsage } from '../agent/commands/usage_spec.js';
 import { parseSlashUsage, splitInputArgs } from '../agent/commands/usage_parser.js';
+import { ROUTER_MODELS_NEED_LOGIN, ZERGAI_LOGIN_PITCH } from '../onboarding/zergai_login.js';
 const fold = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
 function score(value, query) {
     const target = fold(value);
@@ -41,20 +43,34 @@ function commandUsage(text, commands) {
     return command && usage ? { kind: 'usage', prefix: '', query: '',
         usage: usage.startsWith(`/${command.name}`) ? usage : `/${command.name} ${usage}` } : null;
 }
+/** `/config` subcommands that take no value; the rest leave room to type one. */
+const CONFIG_BARE_SUBCOMMANDS = new Set(['show', 'reset', 'openai-compat', 'openai_compatible', 'compat']);
+/** Providers `/config key` accepts: every local one except the local logins. */
+const CONFIG_KEY_PROVIDERS = DIRECT_PROVIDER_CHOICES.filter(choice => !isLocalSubscription(choice.id));
 function parseSelectionInput(text, commands) {
     if (commands.length && /^\/[\w-]*$/.test(text))
         return { kind: 'command', prefix: '/', query: text.slice(1) };
-    const auth = text.match(/^\/auth[ \t]+([^\s]*)$/);
-    const authCommand = auth && commands.find(command => command.name === 'auth');
-    const actions = authCommand && parseSlashUsage(authCommand.usage)[0]?.choices;
-    if (auth && actions?.length) {
-        return { kind: 'command', prefix: '/', query: `auth ${auth[1]}`,
-            selections: actions.map(action => ({ value: `auth ${action}`, label: `/auth ${action}` })) };
+    // `/auth <action>`, and `/config <subcommand>` once one is started: a bare
+    // `/config ` keeps its usage hint so Enter still opens the settings panel.
+    const sub = text.match(/^\/(auth|config)[ \t]+([^\s]*)$/);
+    const subCommand = sub && (sub[1] === 'auth' || sub[2]) ? commands.find(command => command.name === sub[1]) : undefined;
+    const actions = subCommand && parseSlashUsage(subCommand.usage)[0]?.choices;
+    if (sub && actions?.length) {
+        return { kind: 'command', prefix: '/', query: `${sub[1]} ${sub[2]}`,
+            selections: actions.map(action => ({ value: `${sub[1]} ${action}`, label: `/${sub[1]} ${action}`,
+                needsArgument: sub[1] === 'config' && !CONFIG_BARE_SUBCOMMANDS.has(action) })) };
     }
-    const reasoning = text.match(/^\/(effort|thinking)\s+([^\s]*)\s*$/i);
+    const configProvider = text.match(/^\/config[ \t]+(key|provider)[ \t]+([^\s]*)$/);
+    if (configProvider && commands.some(command => command.name === 'config')) {
+        return { kind: 'provider', prefix: `/config ${configProvider[1]} `, query: configProvider[2],
+            keyProviders: configProvider[1] === 'key', submitOnPick: true };
+    }
+    const reasoning = text.match(/^\/(effort|thinking|reasoning)\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 typed = reasoning[1].toLowerCase();
+        // /reasoning takes the same levels as /effort.
+        const command = typed === 'thinking' ? 'thinking' : 'effort';
+        return { kind: 'reasoning', command, prefix: `/${typed} `, query: reasoning[2] };
     }
     const model = text.match(/^\/(model|models)\s+([^\n]*)$/i);
     if (!model)
@@ -67,6 +83,14 @@ function parseSelectionInput(text, commands) {
     if (model[1].toLowerCase() === 'models' || arg.toLowerCase() === 'set')
         return commandUsage(text, commands);
     const first = arg.match(/^(\S+)(?:\s+(.*))?$/);
+    if (first && canonicalRoute(first[1]) === 'direct' && first[2] !== undefined) {
+        const local = first[2].match(/^(\S+)(?:\s+(.*))?$/);
+        const selected = local && canonicalProvider(local[1]);
+        if (selected && !isRouterOnlyProvider(selected) && local?.[2] !== undefined) {
+            return { kind: 'model', prefix: `/model ${first[1]} ${local[1]} `, query: local[2], modelProvider: selected, routed: false };
+        }
+        return { kind: 'provider', prefix: `/model ${first[1]} `, query: first[2], directOnly: true };
+    }
     const choice = first && canonicalProvider(first[1]);
     if (choice === 'zergrouter' && first?.[2] !== undefined) {
         const upstream = first[2].match(/^(\S+)(?:\s+(.*))?$/);
@@ -103,6 +127,39 @@ export function modelSelections(provider, discovered) {
     }
     return candidates;
 }
+/**
+ * ZergRouter's chat providers in the order Router lists them: those the
+ * account has a key for first, then by Router's catalog priority. A provider
+ * counts as keyed when any of its models is available.
+ */
+function routerProviderChoices(catalog) {
+    const providers = new Map();
+    for (const row of catalog.models) {
+        if (catalog.version !== 0 && !row.capabilities?.chat)
+            continue;
+        const known = providers.get(row.owned_by);
+        providers.set(row.owned_by, {
+            label: known?.label ?? (row.provider_display_name || row.owned_by),
+            keyed: (known?.keyed ?? false) || row.available !== false,
+        });
+    }
+    return [...providers].map(([id, provider]) => ({
+        id, label: provider.label, aliases: [], description: provider.keyed ? 'Key set' : 'No key',
+    }));
+}
+/** What a Router model offers, for its row: context, reasoning, images, limits and its price across providers. */
+function routerModelFacts(row) {
+    const capabilities = row.capabilities;
+    const context = capabilities?.context_window;
+    return [
+        context ? `${context >= 1_000_000 ? `${Number((context / 1_000_000).toFixed(1))}M` : `${Math.round(context / 1000)}K`} context` : '',
+        capabilities?.reasoning?.choices.some(choice => choice !== 'none') ? 'Reasoning' : '',
+        capabilities?.images ? 'Images' : '',
+        capabilities?.tools === false ? 'Chat only' : '',
+        row.price_range ? formatPriceRange(row.price_range) : '',
+        row.available === false ? 'Access unavailable' : '',
+    ].filter(Boolean).join(' · ');
+}
 function commandSelections(commands) {
     return commands.map(command => ({
         value: command.name, label: `/${command.name}`, description: command.description,
@@ -135,6 +192,8 @@ export class SelectionCompletion {
     firstVisible = 0;
     visibleRows = SELECTION_VISIBLE_ROWS;
     dismissedInput = null;
+    /** The person moved the highlight since the text last changed. */
+    moved = false;
     discovered;
     loading = false;
     unavailable = false;
@@ -145,12 +204,20 @@ export class SelectionCompletion {
     currentModel;
     routerCatalog;
     reasoning = {};
+    activeRouted = false;
+    /** Route status is read once per /model editing session; probing local logins is not free. */
+    routeStatus;
     constructor(changed = () => { }) {
         this.changed = changed;
     }
-    update(text, provider, loadModels, commands = [], currentModel, loadCatalog, activeRouted = false, reasoning = {}) {
+    update(text, provider, loadModels, commands = [], currentModel, loadCatalog, activeRouted = false, reasoning = {}, loadRouteStatus) {
         this.commands = commands;
         const parsed = parseSelectionInput(text, commands);
+        this.activeRouted = activeRouted;
+        if (!parsed?.includeModels && !parsed?.directOnly && !parsed?.keyProviders && !parsed?.routerOnly && !parsed?.routed)
+            this.routeStatus = undefined;
+        else if (this.routeStatus === undefined && loadRouteStatus)
+            this.routeStatus = loadRouteStatus();
         const catalogProvider = parsed?.modelProvider ?? provider;
         const routed = parsed?.routed ?? ((parsed?.includeModels || parsed?.kind === 'reasoning') && activeRouted ? true : undefined);
         if (provider !== this.provider || catalogProvider !== this.catalogProvider
@@ -172,6 +239,7 @@ export class SelectionCompletion {
             this.selected = 0;
             this.firstVisible = 0;
             this.candidates = [];
+            this.moved = false;
         }
         if (text !== this.text && text !== this.dismissedInput)
             this.dismissedInput = null;
@@ -180,8 +248,10 @@ export class SelectionCompletion {
         this.catalogProvider = catalogProvider;
         this.catalogRoute = routed;
         this.parsed = parsed;
-        this.filter();
-        if ((parsed?.routerOnly || routed) && !this.requested && loadCatalog) {
+        // Zerg Router lists nothing without a login, so it is not asked.
+        const routerScoped = Boolean(parsed?.routerOnly || routed || (parsed?.includeModels && isRouterOnlyProvider(catalogProvider)));
+        const asked = !(routerScoped && this.routerLoginNeeded());
+        if (asked && (parsed?.routerOnly || routed) && !this.requested && loadCatalog) {
             this.requested = true;
             this.loading = true;
             this.requestController = new AbortController();
@@ -200,7 +270,7 @@ export class SelectionCompletion {
                 this.changed();
             });
         }
-        if ((parsed?.kind === 'model' || parsed?.includeModels) && !this.requested && loadModels) {
+        if (asked && (parsed?.kind === 'model' || parsed?.includeModels) && !this.requested && loadModels) {
             this.requested = true;
             this.loading = true;
             this.requestController = new AbortController();
@@ -222,7 +292,14 @@ export class SelectionCompletion {
                 this.changed();
             });
         }
+        // Listed once the loads above have started, so a list still on its way shows as loading.
+        this.filter();
     }
+    /**
+     * A list can change under the menu (discovery, Router's catalog arriving).
+     * The highlight follows its value only when the user moved it there;
+     * otherwise it stays on the top row.
+     */
     filter() {
         const selectedValue = this.candidates[this.selected]?.value;
         if (this.parsed?.kind === 'reasoning') {
@@ -239,31 +316,90 @@ export class SelectionCompletion {
                 .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.selected = this.moved && previousIndex >= 0 ? previousIndex : 0;
+            this.revealSelection();
+            return;
+        }
+        if (this.routerLoginNeeded() && (this.parsed?.routerOnly || (this.parsed?.kind === 'model' && this.catalogRoute))) {
+            this.candidates = [this.routerLoginCandidate()];
+            this.selected = 0;
             this.revealSelection();
             return;
         }
+        const routerModelsHidden = this.routerLoginNeeded() && isRouterOnlyProvider(this.catalogProvider);
         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(' · '),
+        const current = this.currentModel === undefined ? [] : [this.currentModel, `${this.catalogProvider}/${this.currentModel}`];
+        const models = routerModelsHidden ? [] : (routed ? routerModelsForProvider(this.routerCatalog, this.catalogProvider).map(row => ({
+            value: row.id, label: row.display_name || row.id, aliases: row.aliases ?? [], description: routerModelFacts(row),
         })) : modelSelections(this.catalogProvider, this.discovered))
-            .map(model => ({ ...model, current: this.catalogProvider === this.provider && model.value === this.currentModel }));
-        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;
+            // A model saved under an alias (a Modal hostname) is the current row too.
+            .map(model => ({ ...model, current: this.catalogProvider === this.provider
+                && [model.value, ...(model.aliases ?? [])].some(name => current.includes(name)) }));
+        // While Router's own list loads, ZTC's would be a different list in a
+        // different order; only an unreachable Router falls back to it.
+        const routerProviders = this.parsed?.routerOnly && this.routerCatalog ? routerProviderChoices(this.routerCatalog)
+            : this.parsed?.routerOnly && this.loading ? []
+                : this.parsed?.keyProviders ? CONFIG_KEY_PROVIDERS
+                    : this.parsed?.directOnly ? DIRECT_PROVIDER_CHOICES : PROVIDER_CHOICES;
+        const ready = this.routeStatus?.directProviders && new Set(this.routeStatus.directProviders);
         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 }));
+            // A picked /config provider runs at once; no trailing space invites a typed key.
+            .map(p => ({ value: p.id, label: p.label, aliases: p.aliases, needsArgument: !this.parsed?.submitOnPick,
+            // A ZergRouter row describes Router's key, never this machine's.
+            description: this.parsed?.routerOnly ? p.description
+                : ready && this.parsed?.keyProviders ? (ready.has(p.id) ? 'Key set' : 'No key')
+                    : ready && !isRouterOnlyProvider(p.id) ? describeDirectProvider(p.id, ready.has(p.id)) : p.description,
+            current: p.id === this.provider && (!this.parsed?.directOnly || !this.activeRouted) }));
+        // Configured local providers lead; sort is stable, so choice order holds within each group.
+        if (this.parsed?.directOnly && ready)
+            providers.sort((a, b) => Number(ready.has(b.value)) - Number(ready.has(a.value)));
         const source = this.parsed?.kind === 'command' ? this.parsed.selections ?? commandSelections(this.commands)
             : this.parsed?.kind === 'model' ? models
-                : this.parsed?.includeModels ? [...providers, ...models] : providers;
+                : this.parsed?.includeModels
+                    // The bare list offers the two routes; typed provider names still match as shortcuts.
+                    ? [...this.routeSelections(), ...(this.parsed.query.trim() ? providers.filter(p => p.value !== 'zergrouter') : []), ...models]
+                    : providers;
         this.candidates = this.parsed && this.parsed.kind !== 'usage' ? fuzzySelections(source, this.parsed.query) : [];
+        // OpenRouter's zero data retention is chosen with its model, so it leads the model list whatever is typed.
+        if (this.parsed?.kind === 'model' && routed && this.catalogProvider === 'openrouter') {
+            const on = this.reasoning.openRouterZdr === true;
+            this.candidates.unshift({ value: '_openrouter_zdr', label: `Zero data retention: ${on ? 'on' : 'off'}`, toggle: 'openrouter.zdr',
+                description: on ? 'Only providers that keep no prompt data · Enter turns it off' : 'Any provider · Enter keeps to providers that retain no data' });
+        }
         const previousIndex = this.candidates.findIndex(c => c.value === selectedValue);
-        this.selected = previousIndex >= 0 ? previousIndex : 0;
+        // A toggle is chosen only by moving to it: Enter after a typed model once flipped ZDR instead (2026-10-27).
+        const firstChoice = Math.max(0, this.candidates.findIndex(c => !c.toggle));
+        this.selected = this.moved && previousIndex >= 0 ? previousIndex : firstChoice;
         this.revealSelection();
     }
+    /** Route status is known and has no current ZergAI login for Zerg Router. */
+    routerLoginNeeded() {
+        return this.routeStatus?.routerSession !== undefined && this.routeStatus.routerSession !== 'signed_in';
+    }
+    /** The one row Zerg Router choices show without a login: Enter runs /model, which asks. */
+    routerLoginCandidate() {
+        return {
+            value: 'login', label: 'Log in with ZergAI', submitsInput: true,
+            description: this.routeStatus?.routerSession === 'expired'
+                ? 'Your ZergAI session expired · Enter to log in again' : `${ROUTER_MODELS_NEED_LOGIN} · Enter`,
+        };
+    }
+    routeSelections() {
+        const status = this.routeStatus;
+        return MODEL_ROUTE_CHOICES.map(route => ({
+            value: route.id, label: route.label, aliases: [...route.aliases], needsArgument: true,
+            current: route.id === 'zergrouter' ? this.activeRouted : !this.activeRouted,
+            description: route.id === 'zergrouter'
+                ? status?.routerSession ? describeRouterRoute(status.routerSession) : ZERGAI_LOGIN_PITCH
+                : status?.directProviders ? describeDirectRoute(status.directProviders) : 'Your own provider keys and local logins',
+        }));
+    }
+    /** When Router's list on show is a saved copy over ten minutes old, the time it was fetched. */
+    savedCopyAt() {
+        const catalog = this.routerCatalog;
+        const routerList = this.parsed?.routerOnly || (this.parsed?.kind === 'model' && this.catalogRoute);
+        return routerList && catalog?.cached && Date.now() - catalog.fetchedAt > 10 * 60 * 1000 ? catalog.fetchedAt : undefined;
+    }
     revealSelection() {
         this.firstVisible = Math.max(0, Math.min(this.firstVisible, this.selected));
         if (this.selected >= this.firstVisible + this.visibleRows)
@@ -291,7 +427,9 @@ export class SelectionCompletion {
             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 };
+            route: this.parsed.routerOnly ? 'zergrouter' : this.parsed.directOnly ? 'direct' : undefined,
+            mixed: this.parsed.includeModels,
+            ...(this.savedCopyAt() === undefined ? {} : { savedAt: this.savedCopyAt() }) };
     }
     handleKey(key) {
         if (!this.parsed || key.shift || key.ctrl || key.meta)
@@ -312,6 +450,7 @@ export class SelectionCompletion {
         if (key.upArrow || key.downArrow) {
             if (this.candidates.length)
                 this.selected = (this.selected + (key.downArrow ? 1 : -1) + this.candidates.length) % this.candidates.length;
+            this.moved = true;
             this.revealSelection();
             return { handled: true };
         }
@@ -319,10 +458,34 @@ export class SelectionCompletion {
             const candidate = this.candidates[this.selected];
             if (!candidate)
                 return { handled: key.tab === true };
+            // Nothing else matched and the person did not move to the toggle: run the command as typed.
+            if (candidate.toggle && key.return && !this.moved)
+                return { handled: false };
+            if (candidate.toggle)
+                return key.return ? { handled: true, toggle: candidate.toggle } : { handled: true };
+            if (candidate.submitsInput) {
+                if (key.tab)
+                    return { handled: true };
+                this.dismissedInput = this.text;
+                return { handled: true, text: this.text.trimEnd(), submit: true };
+            }
             const completed = this.parsed.prefix + candidate.value;
+            // A subcommand typed in full runs on Enter; only partial input is filled.
+            if (key.return && this.parsed.selections && completed === this.text)
+                return { handled: false };
             if (this.parsed.kind === 'command' && (key.tab || candidate.needsArgument)) {
                 return { handled: true, text: `${completed} ` };
             }
+            if (key.return && this.parsed.submitOnPick) {
+                // Nothing typed or chosen yet: run the command as typed, not the first row.
+                if (!this.parsed.query && !this.moved)
+                    return { handled: false };
+                this.dismissedInput = this.text;
+                return { handled: true, text: completed, submit: true };
+            }
+            // Nothing typed or chosen in a reasoning menu: run the command, which opens the picker.
+            if (key.return && this.parsed.kind === 'reasoning' && !this.parsed.query && !this.moved)
+                return { handled: false };
             if (this.parsed.kind === 'provider' && candidate.needsArgument) {
                 return { handled: true, text: `${completed} ` };
             }

package/dist/app/session_manager.d.ts

@@ -8,6 +8,7 @@ import { type UsageSnapshot } from '../usage_snapshot.js';
 import { type DiagnosticSnapshot, type DiagnosticEventKind, type DiagnosticJsonObject } from '../diagnostics/session_export.js';
 import type { CommandReceipt } from '../agent/runtime/command_jobs.js';
 import type { Session, SessionRuntimeState } from '../session.js';
+import { type CompactionSummarizer } from '../utils/compaction.js';
 import type { Message } from '../types.js';
 import type { ModelUsageObserver } from '../types.js';
 import type { MuxSessionState } from '../ui/ratatui/protocol.js';
@@ -36,12 +37,14 @@ export interface SessionManagerDeps {
      * so the bar and the auto-compact decision agree.
      */
     getContextTokens?: () => number;
+    setContextUsage?: (used: number, estimated?: boolean) => void;
     /** The context window the bar last used (provider-reported when available, else
      *  static). Auto-compact uses it so it triggers at the same percentage the bar
      *  shows — not a stale static window that would compact too early/late. */
     getContextWindow?: () => number | undefined;
     /** Capture the originating prompt before an asynchronous compaction starts. */
     getUsageObserver?: () => ModelUsageObserver | undefined;
+    getHandoffSummarizer?: (signal?: AbortSignal, messages?: Message[]) => CompactionSummarizer | undefined;
     /** Optional renderer-specific state to persist alongside the conversation. */
     getMuxState?: () => Promise<MuxSessionState | undefined>;
     getPaneSpecs?: () => PaneSessionSpec[];
@@ -125,6 +128,7 @@ export declare class SessionManager {
      * Used when API returns "prompt too long" error.
      */
     forceCompact(): Promise<boolean>;
+    compactHistory(percent?: number, keepRecentMin?: number, signal?: AbortSignal, sourceMessages?: Message[], historyMode?: 'handoff' | 'target'): Promise<Message[] | null>;
     /**
      * Start periodic auto-save.
      */
@@ -139,4 +143,5 @@ export declare class SessionManager {
     /** Preserve current invocation and correction sources without restoring old settled history. */
     private preserveCheckpointSources;
     private buildSummarizer;
+    private cheapSummarizer;
 }