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

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

@@ -18,6 +18,8 @@ export interface ConfigController {
     clearSessionOverrides?: () => void;
     withConfigScope?: <T>(scope: ZTCConfigScope, fn: () => T | Promise<T>) => Promise<T>;
     refresh?: () => Promise<void>;
+    factoryReset?: () => Promise<void>;
+    switchProfile?: (name: string, activate: () => void | Promise<void>) => Promise<void>;
     hasApiKey: () => boolean;
     getApiKey: (provider?: string) => string | undefined;
     setApiKey: (key: string, provider?: string) => void;
@@ -92,6 +94,7 @@ export interface ClipboardController {
 export interface ModelsController {
     list: (provider?: string, options?: {
         signal?: AbortSignal;
+        authMode?: 'direct' | 'zrouter';
     }) => Promise<string[]>;
 }
 export interface SkillsController {
@@ -267,12 +270,14 @@ export interface CommandContext {
      */
     getContextWindow?: () => number | undefined;
     /**
-     * Provider-reported cached input tokens from the last turn, a subset of
-     * getContextTokens(). Undefined when the provider reported no cache
+     * Provider-reported cached input tokens from the last model call, a subset of
+     * getCacheInputTokens(). Undefined when the provider reported no cache
      * accounting — which is not the same as a 0% hit rate, so /context omits the
      * line rather than reporting a measured miss.
      */
     getCachedInputTokens?: () => number | undefined;
+    /** Raw provider input for the last model call, the cache rate denominator. */
+    getCacheInputTokens?: () => number | undefined;
     /**
      * Push a new context size to the bar/state after a CLIENT-side context change
      * that the backend won't report (e.g. /clear -> 0, /compact -> reduced size).
@@ -285,6 +290,8 @@ export interface CommandContext {
     reloadAgent: (options?: {
         defer?: boolean;
     }) => void;
+    /** Reconfigure this running session from another config profile. */
+    switchConfigProfile?: (name: string) => Promise<void>;
     /**
      * Apply a provider/model selection to the currently running process. This
      * updates any session-local runtime override before recreating the agent, so
@@ -407,9 +414,19 @@ export interface SettingItem {
     } | void;
 }
 export interface SettingsPanelController {
+    /** Release the panel before handing focus to a form or another widget. */
+    closeSettingsPanel?: () => void;
     showSettingsPanel: (options: {
         title?: string;
         categories: SettingCategory[];
+        /** Render one category as a compact interaction page, without navigation chrome. */
+        layout?: 'page';
+        /** Validation or save error displayed below the page title. */
+        notice?: string;
+        /** Select this row when opening the page, for example after validation. */
+        initialSetting?: string;
+        /** Select a category without narrowing the native category list. */
+        initialCategory?: string;
         initialFilter?: string;
         onSettingChange: (setting: string, value: string) => void | Promise<void>;
         /**

package/dist/agent/tools/ask_user.js

@@ -122,7 +122,7 @@ export const askUserTool = {
         name: 'ask_user',
         description: `Ask the user one or more questions with predefined options. Use this to get user preferences, clarify requirements, or confirm approach before proceeding.
 
-The user will see a selection widget (or multi-question form for multiple questions) with the options you provide, plus an "Other..." option for custom input. Wait for the user's response before continuing.
+The user will see a selection widget (or multi-question form for multiple questions) with the options you provide and a field for optional additional context. Wait for the user's response before continuing.
 
 ## Single question mode
 Use "question" and "options_json" parameters.
@@ -155,7 +155,7 @@ Example: [{"question": "Which framework?", "options": [{"label": "React", "descr
                 },
                 allow_other: {
                     type: 'boolean',
-                    description: 'Whether to show an "Other..." free-text input option. Defaults to true.',
+                    description: 'Legacy browser-mirror custom-answer setting. The terminal questionnaire uses an optional note with the selected option.',
                 },
             },
             required: [],

package/dist/app/agent_runner.d.ts

@@ -52,7 +52,7 @@ export declare class AgentRunLifecycle {
      *                  The callback should contain the renderer-specific event switch.
      * @returns The agent response and whether it was cancelled
      */
-    run(agent: Agent, messages: Message[], onEvent: (event: AgentEvent) => void): Promise<AgentRunResult>;
+    run(agent: Agent, messages: Message[], onEvent: (event: AgentEvent) => void, takeSteering?: () => Message[]): Promise<AgentRunResult>;
     /**
      * Cancel the currently active run (if any).
      * Aborts the in-flight API call and stops event delivery.

package/dist/app/agent_runner.js

@@ -140,7 +140,7 @@ export class AgentRunLifecycle {
      *                  The callback should contain the renderer-specific event switch.
      * @returns The agent response and whether it was cancelled
      */
-    async run(agent, messages, onEvent) {
+    async run(agent, messages, onEvent, takeSteering) {
         // Abort previous run if still in flight to avoid concurrent API calls
         if (this.abortController) {
             this.abortController.abort();
@@ -160,7 +160,7 @@ export class AgentRunLifecycle {
             // iterates. Renderers own their controller state and persist the visible
             // final turn themselves, so keep those API-only mutations off the live
             // transcript array.
-            const response = await agent.run(messages.slice(), controller.signal);
+            const response = await agent.run(messages.slice(), controller.signal, takeSteering);
             const cancelled = !isActive();
             return { response: cancelled ? null : response, cancelled };
         }

package/dist/app/ask_user_response.d.ts

@@ -0,0 +1,3 @@
+import type { AskUserQuestion } from '../agent/tools/ask_user.js';
+/** Keep the chosen option distinct from any prose the user adds. */
+export declare function formatAskUserResponse(questions: AskUserQuestion[], answers: Record<string, string | string[]>): string;

package/dist/app/ask_user_response.js

@@ -0,0 +1,16 @@
+/** Keep the chosen option distinct from any prose the user adds. */
+export function formatAskUserResponse(questions, answers) {
+    const values = questions.map((question, index) => {
+        const answer = answers[`q${index}`];
+        const note = answers[`q${index}_note`];
+        return {
+            question: question.question,
+            answer: Array.isArray(answer) ? answer.join(', ') : (answer || '(no answer)'),
+            ...(typeof note === 'string' && note.trim() ? { note } : {}),
+        };
+    });
+    if (values.length !== 1)
+        return JSON.stringify(values);
+    const { answer, note } = values[0];
+    return note ? `${answer}\n\nAdditional context: ${note}` : answer;
+}

package/dist/app/command_context.js

@@ -30,7 +30,7 @@ export function routeUserInput(text) {
     }
     // Slash commands (but not file paths)
     if (text.startsWith('/') && !FILE_PATH_PREFIXES.some(p => text.startsWith(p))) {
-        const parts = text.slice(1).split(/\s+/);
+        const parts = text.slice(1).trimEnd().split(/\s+/);
         const cmd = parts[0];
         if (!cmd.includes('/')) {
             return { type: 'command', cmd, args: parts.slice(1) };
@@ -45,7 +45,8 @@ export function routeUserInput(text) {
 export function buildModelsController(config) {
     return {
         list: async (provider, options) => {
-            const llm = config.resolveLLMBackendConfig({ provider });
+            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({
@@ -174,10 +175,36 @@ export function buildAutoSelectWidgets() {
         },
     };
 }
+/** Session controls do not execute the plan or change project files. */
+const PLAN_MODE_SESSION_COMMANDS = new Set([
+    'accounts',
+    'auth',
+    'config',
+    'context',
+    'effort',
+    'fast',
+    'help',
+    'keybindings',
+    'keymap',
+    'login',
+    'logout',
+    'model',
+    'models',
+    'permissions',
+    'profile',
+    'settings',
+    'shortcuts',
+    'skills',
+    'status',
+    'theme',
+    'thinking',
+]);
 export function getPlanModeCommandDenial(currentMode, cmd, args) {
     if (currentMode !== 'plan')
         return null;
     const normalizedCmd = cmd.toLowerCase();
+    if (PLAN_MODE_SESSION_COMMANDS.has(normalizedCmd))
+        return null;
     if (normalizedCmd === 'execute')
         return null;
     if (normalizedCmd === 'plan')
@@ -190,17 +217,6 @@ export function getPlanModeCommandDenial(currentMode, cmd, args) {
         return null;
     if (normalizedCmd === 'modes')
         return null;
-    if (normalizedCmd === 'auth') {
-        if (args.length === 1 && args[0].toLowerCase() === 'login')
-            return null;
-    }
-    if (normalizedCmd === 'config') {
-        const subcommand = args[0]?.toLowerCase();
-        if (subcommand === 'provider' && args.length === 2)
-            return null;
-        if (subcommand === 'key' && (args.length === 2 || args.length === 3))
-            return null;
-    }
     if (normalizedCmd === 'mode') {
         if (args.length === 0)
             return null;

package/dist/app/controller.d.ts

@@ -7,7 +7,7 @@
  * The state is a single immutable object that gets updated via dispatch().
  * Subscribers are notified whenever the state changes.
  */
-import type { Message, AgentState, InputMode, MessageInput, QueueEntry, TodoStatus } from '../types.js';
+import type { Message, AgentState, InputMode, MessageInput, QueueEntry, DeliveryIntent, TodoStatus } from '../types.js';
 import type { InputState } from '../ui/core/input_state.js';
 import type { ContextStatus } from '../utils/context.js';
 import type { Skill } from '../skills/types.js';
@@ -262,13 +262,28 @@ export declare class AppController {
     /**
      * Enqueue a message. Returns true if accepted, false if queue is full.
      * Single writer for queue mutations (together with dequeue/remove/clear).
+     *
+     * `delivery` records when the message should reach the model. It defaults to
+     * `end-of-turn`, the conservative choice: an entry whose intent was never
+     * stated must wait for the whole turn rather than slip into the middle of one.
      */
-    enqueueMessage(input: string | MessageInput): boolean;
+    enqueueMessage(input: string | MessageInput, delivery?: DeliveryIntent): boolean;
     /**
      * Remove the head of the queue and return it.
      * Called by the flush-on-idle path.
      */
     dequeueMessage(): QueueEntry | undefined;
+    /**
+     * Remove the OLDEST `subturn` entry and return it, leaving `end-of-turn`
+     * entries in place. Returns undefined when nothing is marked for sub-turn
+     * delivery.
+     *
+     * Enter-during-a-turn and Tab-during-a-turn are different promises: the first
+     * wants the next tool boundary, the second wants the end of the turn. Failing
+     * over to `dequeueMessage` here would let a Tab-queued prompt jump the queue
+     * and land mid-turn, so this returns nothing instead and lets the caller wait.
+     */
+    dequeueSubturnMessage(): QueueEntry | undefined;
     removeQueueEntry(id: string): void;
     /** Rewrite a queued entry's text in place. Returns false when the id is no longer queued. */
     updateQueueEntry(id: string, text: string): boolean;

package/dist/app/controller.js

@@ -413,8 +413,12 @@ export class AppController {
     /**
      * Enqueue a message. Returns true if accepted, false if queue is full.
      * Single writer for queue mutations (together with dequeue/remove/clear).
+     *
+     * `delivery` records when the message should reach the model. It defaults to
+     * `end-of-turn`, the conservative choice: an entry whose intent was never
+     * stated must wait for the whole turn rather than slip into the middle of one.
      */
-    enqueueMessage(input) {
+    enqueueMessage(input, delivery = 'end-of-turn') {
         if (this.state.queue.length >= MAX_QUEUE)
             return false;
         const text = typeof input === 'string' ? input : input.text;
@@ -423,6 +427,7 @@ export class AppController {
             text,
             attachments: typeof input === 'string' ? [] : input.attachments,
             queuedAt: new Date(),
+            delivery,
         };
         this.dispatch({ type: 'ENQUEUE_MESSAGE', entry });
         return true;
@@ -438,6 +443,24 @@ export class AppController {
         this.dispatch({ type: 'DEQUEUE_MESSAGE' });
         return head;
     }
+    /**
+     * Remove the OLDEST `subturn` entry and return it, leaving `end-of-turn`
+     * entries in place. Returns undefined when nothing is marked for sub-turn
+     * delivery.
+     *
+     * Enter-during-a-turn and Tab-during-a-turn are different promises: the first
+     * wants the next tool boundary, the second wants the end of the turn. Failing
+     * over to `dequeueMessage` here would let a Tab-queued prompt jump the queue
+     * and land mid-turn, so this returns nothing instead and lets the caller wait.
+     */
+    dequeueSubturnMessage() {
+        const index = this.state.queue.findIndex(entry => entry.delivery === 'subturn');
+        if (index < 0)
+            return undefined;
+        const entry = this.state.queue[index];
+        this.dispatch({ type: 'REMOVE_QUEUE_ENTRY', id: entry.id });
+        return entry;
+    }
     removeQueueEntry(id) {
         this.dispatch({ type: 'REMOVE_QUEUE_ENTRY', id });
     }

package/dist/app/selection_completion.d.ts

@@ -12,6 +12,9 @@ export interface SelectionCompletionView {
     query?: string;
     usage?: string;
     provider?: string;
+    mixed?: boolean;
+    /** True when this model branch dispatches through Router, not a direct key. */
+    routed?: boolean;
     candidates: SelectionCandidate[];
     selected: number;
     firstVisible?: number;
@@ -30,10 +33,13 @@ export declare class SelectionCompletion {
     private changed;
     private text;
     private provider;
+    private catalogProvider;
+    private catalogRoute;
     private parsed;
     private candidates;
     private selected;
     private firstVisible;
+    private visibleRows;
     private dismissedInput;
     private discovered;
     private loading;
@@ -44,9 +50,10 @@ export declare class SelectionCompletion {
     private commands;
     private currentModel?;
     constructor(changed?: () => void);
-    update(text: string, provider: string, loadModels?: (signal: AbortSignal) => 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): void;
     private filter;
     private revealSelection;
+    setVisibleRows(rows: number): void;
     /** Keep the menu closed for text the user did not type character by character
      * (a prompt recalled from history). The candidate list would otherwise capture
      * Up/Down, so the arrows could no longer walk history. Editing the text clears
@@ -66,8 +73,7 @@ export declare class SelectionCompletion {
     }): {
         handled: boolean;
         text?: string;
-        submit?: boolean;
     };
 }
 export declare const SELECTION_VISIBLE_ROWS = 4;
-export declare function selectionCompletionRows(view?: SelectionCompletionView | null): number;
+export declare function selectionCompletionRows(view?: SelectionCompletionView | null, availableRows?: number): number;

package/dist/app/selection_completion.js

@@ -1,5 +1,5 @@
 import { MODEL_CATALOG } from '../panes/model_catalog.js';
-import { canonicalProvider, PROVIDER_CHOICES, ROUTER_PROVIDERS } from '../agent/commands/provider_choices.js';
+import { canRouteThroughRouter, canonicalProvider, PROVIDER_CHOICES } from '../agent/commands/provider_choices.js';
 import { resolveSlashUsage } from '../agent/commands/usage_spec.js';
 import { splitInputArgs } from '../agent/commands/usage_parser.js';
 const fold = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
@@ -42,14 +42,6 @@ function commandUsage(text, commands) {
 function parseSelectionInput(text, commands) {
     if (commands.length && /^\/[\w-]*$/.test(text))
         return { kind: 'command', prefix: '/', query: text.slice(1) };
-    const provider = text.match(/^\/provider\s+([^\n]*)$/i);
-    if (provider) {
-        const routed = provider[1].match(/^(\S+)\s+(.*)$/);
-        if (routed && canonicalProvider(routed[1]) === 'zergrouter') {
-            return { kind: 'provider', prefix: `/provider ${routed[1]} `, query: routed[2], routerOnly: true };
-        }
-        return { kind: 'provider', prefix: '/provider ', query: provider[1] };
-    }
     const model = text.match(/^\/(model|models)\s+([^\n]*)$/i);
     if (!model)
         return commandUsage(text, commands);
@@ -60,7 +52,23 @@ function parseSelectionInput(text, commands) {
         return { kind: 'model', prefix: `/${model[1]} set `, query: arg.replace(/^set\s+/i, '') };
     if (model[1].toLowerCase() === 'models' || arg.toLowerCase() === 'set')
         return commandUsage(text, commands);
-    return { kind: 'model', prefix: '/model ', query: arg };
+    const first = arg.match(/^(\S+)(?:\s+(.*))?$/);
+    const choice = first && canonicalProvider(first[1]);
+    if (choice === 'zergrouter' && first?.[2] !== undefined) {
+        const upstream = first[2].match(/^(\S+)(?:\s+(.*))?$/);
+        // Router's catalog is the source of truth, so an upstream it serves is
+        // accepted even when ZTC ships no PROVIDER_CHOICES entry for it yet. Only
+        // the exclusion rule (local logins, nesting, private endpoints) blocks one.
+        const selected = upstream && (canonicalProvider(upstream[1]) ?? upstream[1]);
+        if (selected && canRouteThroughRouter(selected) && upstream?.[2] !== undefined) {
+            return { kind: 'model', prefix: `/model ${first[1]} ${upstream[1]} `, query: upstream[2], modelProvider: selected, routed: true };
+        }
+        return { kind: 'provider', prefix: `/model ${first[1]} `, query: first[2], routerOnly: true };
+    }
+    if (choice && first?.[2] !== undefined) {
+        return { kind: 'model', prefix: `/model ${first[1]} `, query: first[2], modelProvider: choice, routed: choice === 'modal' };
+    }
+    return { kind: 'provider', prefix: '/model ', query: arg, includeModels: true };
 }
 export function modelSelections(provider, discovered) {
     const normalized = canonicalProvider(provider) || provider;
@@ -102,10 +110,13 @@ export class SelectionCompletion {
     changed;
     text = '';
     provider = '';
+    catalogProvider = '';
+    catalogRoute;
     parsed = null;
     candidates = [];
     selected = 0;
     firstVisible = 0;
+    visibleRows = SELECTION_VISIBLE_ROWS;
     dismissedInput = null;
     discovered;
     loading = false;
@@ -122,7 +133,9 @@ export class SelectionCompletion {
         this.commands = commands;
         this.currentModel = currentModel;
         const parsed = parseSelectionInput(text, commands);
-        if (provider !== this.provider || parsed?.kind !== this.parsed?.kind) {
+        const catalogProvider = parsed?.modelProvider ?? provider;
+        if (provider !== this.provider || catalogProvider !== this.catalogProvider
+            || parsed?.routed !== this.catalogRoute || parsed?.kind !== this.parsed?.kind) {
             this.requestController?.abort();
             this.generation++;
             this.requested = false;
@@ -139,15 +152,18 @@ export class SelectionCompletion {
             this.dismissedInput = null;
         this.text = text;
         this.provider = provider;
+        this.catalogProvider = catalogProvider;
+        this.catalogRoute = parsed?.routed;
         this.parsed = parsed;
         this.filter();
-        if (parsed?.kind === 'model' && !this.requested && loadModels) {
+        if ((parsed?.kind === 'model' || parsed?.includeModels) && !this.requested && loadModels) {
             this.requested = true;
             this.loading = true;
             this.requestController = new AbortController();
             const signal = this.requestController.signal;
             const generation = this.generation;
-            void Promise.resolve().then(() => loadModels(signal)).then(models => {
+            const authMode = parsed?.routed === undefined ? undefined : parsed.routed ? 'zrouter' : 'direct';
+            void Promise.resolve().then(() => loadModels(signal, catalogProvider, authMode)).then(models => {
                 if (generation !== this.generation)
                     return;
                 this.discovered = models;
@@ -165,10 +181,14 @@ export class SelectionCompletion {
     }
     filter() {
         const selectedValue = this.candidates[this.selected]?.value;
+        const models = 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))
+            .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)
-            : this.parsed?.kind === 'model' ? modelSelections(this.provider, this.discovered).map(model => ({ ...model, current: model.value === this.currentModel }))
-                : PROVIDER_CHOICES.filter(p => !this.parsed?.routerOnly || ROUTER_PROVIDERS.includes(p.id))
-                    .map(p => ({ value: p.id, label: p.label, description: p.description, aliases: p.aliases, current: p.id === this.provider }));
+            : this.parsed?.kind === 'model' ? models
+                : this.parsed?.includeModels ? [...providers, ...models] : providers;
         this.candidates = this.parsed && this.parsed.kind !== 'usage' ? fuzzySelections(source, this.parsed.query) : [];
         const previousIndex = this.candidates.findIndex(c => c.value === selectedValue);
         this.selected = previousIndex >= 0 ? previousIndex : 0;
@@ -176,8 +196,13 @@ export class SelectionCompletion {
     }
     revealSelection() {
         this.firstVisible = Math.max(0, Math.min(this.firstVisible, this.selected));
-        if (this.selected >= this.firstVisible + SELECTION_VISIBLE_ROWS)
-            this.firstVisible = this.selected - SELECTION_VISIBLE_ROWS + 1;
+        if (this.selected >= this.firstVisible + this.visibleRows)
+            this.firstVisible = this.selected - this.visibleRows + 1;
+        this.firstVisible = Math.min(this.firstVisible, Math.max(0, this.candidates.length - this.visibleRows));
+    }
+    setVisibleRows(rows) {
+        this.visibleRows = Math.max(1, Math.floor(rows));
+        this.revealSelection();
     }
     /** Keep the menu closed for text the user did not type character by character
      * (a prompt recalled from history). The candidate list would otherwise capture
@@ -193,7 +218,9 @@ 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,
-            provider: this.parsed.kind === 'model' ? this.provider : undefined };
+            provider: this.parsed.kind === 'model' ? this.catalogProvider : undefined,
+            routed: this.parsed.kind === 'model' ? this.catalogRoute : undefined,
+            mixed: this.parsed.includeModels };
     }
     handleKey(key) {
         if (!this.parsed || key.shift || key.ctrl || key.meta)
@@ -225,15 +252,20 @@ export class SelectionCompletion {
             if (this.parsed.kind === 'command' && (key.tab || candidate.needsArgument)) {
                 return { handled: true, text: `${completed} ` };
             }
+            if (this.parsed.kind === 'provider' && candidate.needsArgument) {
+                return { handled: true, text: `${completed} ` };
+            }
+            if (key.return && completed === this.text)
+                return { handled: false };
             this.dismissedInput = completed;
-            return { handled: true, text: completed, ...(key.return ? { submit: true } : {}) };
+            return { handled: true, text: completed };
         }
         return { handled: false };
     }
 }
 export const SELECTION_VISIBLE_ROWS = 4;
-export function selectionCompletionRows(view) {
+export function selectionCompletionRows(view, availableRows = SELECTION_VISIBLE_ROWS + 1) {
     if (view?.kind === 'usage')
         return 1;
-    return view ? Math.max(1, Math.min(SELECTION_VISIBLE_ROWS, view.candidates.length)) + 1 : 0;
+    return view ? Math.min(availableRows, Math.max(1, view.candidates.length) + 1) : 0;
 }

package/dist/cli_args.js

@@ -1,10 +1,11 @@
 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', '--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', '--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. */
@@ -87,6 +88,14 @@ export function validateCliArgs(args) {
                     value: next,
                 };
             }
+            if (token === '--profile') {
+                try {
+                    validateProfileName(next);
+                }
+                catch (error) {
+                    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 };

package/dist/cli_main.js

@@ -30,13 +30,71 @@ import { computeHeadlessMirror } from './panes/headless_mode.js';
 import { parsePromptInvocation, requiresPlanSafeRenderer, validateCliArgs, } from './cli_args.js';
 import { parseHeadlessInteractionMode } from './app/headless_interaction.js';
 import { buildCliCommonStarts } from './onboarding/first_run.js';
+import { validateProfileName } from './config/profiles.js';
 // Parse command line args
 const args = process.argv.slice(2);
+const profileExplicitAtLaunch = args.includes('--profile') || process.env.ZTC_PROFILE !== undefined;
+const profileFlags = args.flatMap((arg, index) => arg === '--profile' ? [index] : []);
+if (profileFlags.length > 1) {
+    console.error('[ztc] Specify --profile only once.');
+    process.exit(2);
+}
+if (profileFlags.length === 1) {
+    const value = args[profileFlags[0] + 1];
+    try {
+        process.env.ZTC_PROFILE = validateProfileName(value || '');
+    }
+    catch (error) {
+        console.error(`[ztc] ${error.message}`);
+        process.exit(2);
+    }
+}
+try {
+    validateProfileName(process.env.ZTC_PROFILE || 'default');
+}
+catch (error) {
+    console.error(`[ztc] ${error.message}`);
+    process.exit(2);
+}
+const commandArgs = profileFlags.length === 0
+    ? args
+    : args.filter((_, index) => index !== profileFlags[0] && index !== profileFlags[0] + 1);
 // Device login must work without a TTY, provider credentials, or agent startup.
-if (args[0] === 'auth') {
+if (commandArgs[0] === 'auth') {
     try {
         const { runRouterAuthCommand } = await import('./router_auth.js');
-        await runRouterAuthCommand(args.slice(1));
+        await runRouterAuthCommand(commandArgs.slice(1));
+    }
+    catch (error) {
+        console.error(`[ztc] ${error.message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}
+if (commandArgs[0] === 'config' && commandArgs[1] === 'reset') {
+    if (commandArgs.length !== 2) {
+        console.error('Usage: ztc config reset [--profile <name>]');
+        process.exit(2);
+    }
+    try {
+        const { configStore } = await import('./config.js');
+        const { createInterface } = await import('node:readline/promises');
+        const path = configStore.getConfigPath();
+        console.log(`Factory reset settings and ZRouter sign-in for ${path}. This deletes the API keys, OpenAI-compatible endpoint, account registrations, voice keys and MCP servers saved there. Sessions and managed account directories will be kept.`);
+        const input = createInterface({ input: process.stdin, output: process.stdout });
+        let answer;
+        try {
+            answer = await input.question('Type RESET to confirm: ');
+        }
+        finally {
+            input.close();
+        }
+        if (answer !== 'RESET') {
+            console.log('Factory reset cancelled.');
+            process.exit(1);
+        }
+        await configStore.factoryReset();
+        console.log(`Factory reset complete: ${path}`);
     }
     catch (error) {
         console.error(`[ztc] ${error.message}`);
@@ -177,6 +235,7 @@ ZTC - Zerg Terminal Client v${version}
 
 Usage: ztc [options] [prompt]
        ztc auth <login|status|logout>
+       ztc config reset [--profile <name>]
        ztc resume [id]
        ztc --branch <workspace-name> [options]
 
@@ -239,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)
+  --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)
   --effort <level>     Override saved reasoning effort for this process
   --thinking <on|off>  Enable/disable reasoning when the model supports it
@@ -889,6 +950,27 @@ async function main() {
     // any non-colony-child process.
     if (installColonyParentWatchdog())
         debugLog('[main] Colony parent watchdog armed');
+    // Resolve a saved session's profile before loading config, credentials,
+    // skills, or MCP. An explicit --profile or ZTC_PROFILE always wins.
+    if (!profileExplicitAtLaunch && !explicitSessionFile) {
+        const lookup = resumeSessionId || explicitSessionId || nameFlag;
+        if (lookup) {
+            const { loadMostRecentSession, loadSessionByIdOrName } = await import('./session.js');
+            const saved = lookup === 'most-recent'
+                ? await loadMostRecentSession(process.cwd())
+                : await loadSessionByIdOrName(lookup, process.cwd());
+            if (saved?.metadata.configProfile) {
+                try {
+                    process.env.ZTC_PROFILE = validateProfileName(saved.metadata.configProfile);
+                }
+                catch (error) {
+                    console.error(`[ztc] Saved session has an invalid config profile: ${error.message}`);
+                    process.exitCode = 2;
+                    return;
+                }
+            }
+        }
+    }
     const { configStore, shouldRefreshSuperuserStatus } = await import('./config.js');
     // Raw (pre-load) config read, same as the historical module-scope read; the
     // --max-iterations flag parsed at module scope wins over the config value.
@@ -950,6 +1032,7 @@ async function main() {
     // Config-level opt-in mirrors the --colony flag (which set ZTC_COLONY_MCP).
     if (configStore.get().mcp?.colonyAutoAttach && !process.env.ZTC_COLONY_MCP) {
         process.env.ZTC_COLONY_MCP = '1';
+        process.env.ZTC_COLONY_MCP_CONFIG_OWNED = '1';
     }
     // Only load the MCP client (SDK + zod tree) when there is actually something
     // to connect: configured servers or a colony opt-in. initMcpServers with an