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

package/dist/cli_ratatui.js

@@ -14,6 +14,7 @@ import { join } from 'path';
 import { execFile, spawn as spawnChild } from 'child_process';
 import { promisify } from 'util';
 import { configStore } from './config.js';
+import { withActiveProfileArg } from './config/profiles.js';
 import { CODEX_REASONING_EFFORTS } from './config/types.js';
 import { getSupportedCodexReasoningEfforts, isCodexReasoningEffortSupported, unsupportedEffortMessage, } from './utils/models.js';
 import { getVersion } from './utils/version.js';
@@ -36,7 +37,7 @@ import { runtimePluginRegistry } from './plugin/runtime_registry.js';
 import { getMirrorCommandUsages, isRichSlashUsage } from './agent/commands/mirror_usages.js';
 import { createModeContext } from './agent/commands/mode_commands.js';
 import { goalManager, goalPinTask, detectGoalCompletion, detectGoalBlocked, goalBlockedReason, goalFinalNote, turnProducedText, turnToolOutcomes, shouldAccountFinalTurn, snapshotGoalForTurn } from './agent/commands/goal.js';
-import { allocatePlanArtifact, findPlanContent, generatePlanPath, commitPlan, PlanFileCreationError, } from './agent/commands/plan.js';
+import { allocatePlanArtifact, askPlanApproval, findPlanContent, generatePlanPath, commitPlan, PlanFileCreationError, } from './agent/commands/plan.js';
 import { setTodoUpdateCallback, clearTodoUpdateCallback, setPaneToolsTuiProcess, clearPaneToolsTuiProcess, setPaneToolsOwnId, setPaneToolsExitCallback, setPaneToolsMirrorCallback, setPaneToolsZdeLiteCallback, setPaneToolsPendingLaunchCallback, clearPaneToolsPendingLaunchCallback, setSupervisionManager, clearSupervisionManager, setBusTransport, clearBusTransport, getBusTransport, setEvolutionTuiProcess, clearEvolutionTuiProcess, resetAskUserTurnFlag } from './agent/tools/index.js';
 import { shutdownLSPManager } from './lsp/index.js';
 import { zmuxKeymapPayload } from './config/keybindings.js';
@@ -56,6 +57,7 @@ import { completePath } from './utils/path_complete.js';
 import { togglePlanMode } from './app/modes.js';
 import { isMeaningfulUserInput } from './app/input_validation.js';
 import { headlessInteractionPolicy } from './app/headless_interaction.js';
+import { formatAskUserResponse } from './app/ask_user_response.js';
 import { connectStartupZerg } from './zerg/startup_connect.js';
 import { showSettingsPage } from './app/settings_page.js';
 import { readRepoConfig, writeRepoConfig } from './config/repo_config.js';
@@ -180,6 +182,21 @@ const RESUME_INTERRUPT_CONFIRM_MS = 5000;
  * match `paddedWidgetView` in `ui/views/app.ts`.
  */
 const WIDGET_SURFACE_PADDING_X = 1;
+/**
+ * Spaces a full-page surface painted before its first frame cell.
+ *
+ * A panel that caps its frame centres it, so its margin is data the panel
+ * produced, not something the host can recompute without duplicating the cap
+ * and the split. Reading it off the painted line keeps the two in step: whatever
+ * the panel decided is what the wheel undoes.
+ */
+function leadingSurfaceMargin(content) {
+    if (!content)
+        return 0;
+    const first = content.split('\n', 1)[0];
+    const frameAt = first.search(/[╭╰│]/);
+    return frameAt > 0 ? frameAt : 0;
+}
 /**
  * Notice that appears in the status line when the user cancels a run. It reports
  * a run that is already over, so it is feedback rather than state; the
@@ -393,7 +410,10 @@ export class RatatuiApp {
     nativeDictationModule = null;
     legacyDictationModule = null;
     dictationFilterModule = null;
-    messageQueue = []; // Queue for messages when agent is busy
+    /** Busy Enter prompts waiting for the next completed tool batch. */
+    pendingSteering = [];
+    nativeSteeringInFlight = [];
+    nativeSteeringTail = Promise.resolve();
     pendingBusTrigger = false; // Bus message arrived while agent was busy — trigger runAgent after current run
     // Queue state lives in the controller; this latch guards single-flight flush.
     flushingQueue = false;
@@ -482,6 +502,15 @@ export class RatatuiApp {
      * only the render path knows which layout the frame actually used.
      */
     widgetSurfaceOriginY = null;
+    /**
+     * Columns between the ZTC pane's left edge and the surface's first column.
+     *
+     * A full-page panel caps its frame and centres it, so the frame no longer
+     * starts at the pane's own gutter: the margin is whatever the panel did not
+     * spend. Recorded from the surface it just painted, because only the panel
+     * knows how wide its frame ended up.
+     */
+    widgetSurfaceOriginX = 0;
     /** Last value pushed to zmux's wheel capture, to send only on change. */
     wheelCaptureActive = false;
     promptViewer;
@@ -530,6 +559,7 @@ export class RatatuiApp {
     // Pending widget callbacks from mirror browser (keyed by widget ID)
     pendingWidgetCallbacks = new Map();
     widgetIdCounter = 0;
+    activeSettingsWidgetId = null;
     // zmux multiplexer mode
     muxMode = false;
     /**
@@ -967,8 +997,7 @@ export class RatatuiApp {
         if (this.muxMode) {
             process.env.ZTC_PANE_RELAY = generateRelaySocketPath();
         }
-        // Don't set ZTC_TUI_VIEWPORT_HEIGHT — let Rust compute it from terminal rows
-        // Both sides use min(rows-1, 20) independently.
+        // Don't set ZTC_TUI_VIEWPORT_HEIGHT — let Rust compute it from terminal rows.
         // Colony children: use real zmux in headless mode so sub-panes get real
         // PTYs (shells run interactively, ZTC sub-panes work properly).
         // Parent --headless-mirror keeps HeadlessPaneManager (pure-Node, no PTY)
@@ -1548,6 +1577,101 @@ export class RatatuiApp {
         // Sync mirror superuser state after auth changes (login/logout/status).
         this.mirrorServer?.setSuperuser(configStore.isSuperuser());
     }
+    /** Change the active config while retaining this renderer's session and transcript. */
+    async switchConfigProfileInPlace(name) {
+        if (this.isHostedRuntime()) {
+            throw new Error('Hosted thread settings cannot be replaced by a local config profile.');
+        }
+        const status = this.controller.getState().agentState.status;
+        if (status !== 'idle' && status !== 'error') {
+            throw new Error('Wait for the current turn to finish before switching profiles.');
+        }
+        const previousOverseerOverride = this.overseerModelOverride;
+        const previousConfig = configStore.get();
+        const previousMcp = JSON.stringify(previousConfig.mcpServers ?? {});
+        const previousColonyMcp = process.env.ZTC_COLONY_MCP;
+        const previousColonyOwned = process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+        let mcpChanged = false;
+        let touchedRuntime = false;
+        const applyColonyOptIn = () => {
+            if (process.env.ZTC_COLONY_MCP_CONFIG_OWNED === '1') {
+                delete process.env.ZTC_COLONY_MCP;
+                delete process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+            }
+            if (configStore.get().mcp?.colonyAutoAttach && !process.env.ZTC_COLONY_MCP) {
+                process.env.ZTC_COLONY_MCP = '1';
+                process.env.ZTC_COLONY_MCP_CONFIG_OWNED = '1';
+            }
+        };
+        const reloadMcp = async () => {
+            const { closeMcpServers, colonyOptIn } = await import('./mcp/registry.js');
+            await closeMcpServers();
+            const servers = configStore.get().mcpServers;
+            if ((servers && Object.keys(servers).length > 0) || colonyOptIn()) {
+                const { initMcpServers } = await import('./mcp/client.js');
+                await initMcpServers(servers);
+            }
+        };
+        const reloadSkills = async () => {
+            const { invalidateSkillsCache, preloadSkillsManifest } = await import('./skills/registry.js');
+            invalidateSkillsCache();
+            await preloadSkillsManifest();
+        };
+        try {
+            await configStore.switchProfile(name, async () => {
+                touchedRuntime = true;
+                applyColonyOptIn();
+                mcpChanged = previousMcp !== JSON.stringify(configStore.get().mcpServers ?? {})
+                    || previousColonyMcp !== process.env.ZTC_COLONY_MCP;
+                if (mcpChanged)
+                    await reloadMcp();
+                await reloadSkills();
+                this.overseerModelOverride = null;
+                const nextAgent = this.createAgent();
+                this.replaceAgent(nextAgent);
+                if (nextAgent)
+                    await this.awaitAgentBind();
+                this.hookLifecycle.ensureWatcher();
+                if (this.shouldPersistSession())
+                    await this.saveCurrentSession(true);
+            });
+        }
+        catch (error) {
+            this.overseerModelOverride = previousOverseerOverride;
+            if (previousColonyMcp === undefined)
+                delete process.env.ZTC_COLONY_MCP;
+            else
+                process.env.ZTC_COLONY_MCP = previousColonyMcp;
+            if (previousColonyOwned === undefined)
+                delete process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+            else
+                process.env.ZTC_COLONY_MCP_CONFIG_OWNED = previousColonyOwned;
+            try {
+                if (touchedRuntime) {
+                    if (mcpChanged)
+                        await reloadMcp();
+                    await reloadSkills();
+                    const restoredAgent = this.createAgent();
+                    this.replaceAgent(restoredAgent);
+                    if (restoredAgent)
+                        await this.awaitAgentBind();
+                }
+            }
+            catch (restoreError) {
+                throw new Error(`Profile switch failed: ${error.message}. Restoring the previous runtime also failed: ${restoreError.message}`);
+            }
+            throw error;
+        }
+        if (this.muxMode)
+            this.tui.send({ type: 'set_keybindings', keymap: zmuxKeymapPayload(configStore.get().keybindings) });
+        this.mirrorServer?.setSfxConfig(configStore.get().sfx ?? { enabled: false });
+        this.mirrorServer?.setSuperuser(configStore.isSuperuser());
+        const { notifyAccountsChanged } = await import('./agent/backends/account_events.js');
+        notifyAccountsChanged();
+        if (!this.agent)
+            this.addSystemMessage('This profile has no usable provider yet. Configure one in /settings.');
+        this.render();
+    }
     /**
      * Environment handed to the renderer so zmux boots with the user's rebinds.
      * Live changes are pushed over the socket afterwards (`set_keybindings`).
@@ -1587,6 +1711,7 @@ export class RatatuiApp {
             // and auto-compact onto the char/4 estimate while the bar stayed real.
             getContextTokens: () => this.controller.getState().contextLength ?? 0,
             getCachedInputTokens: () => this.controller.getState().agentState.cachedInputTokens,
+            getCacheInputTokens: () => this.controller.getState().agentState.cacheInputTokens,
             // The window the bar last used (status.total) — provider-reported (Codex's
             // modelContextWindow) when available, else the static guess. Keeps /context
             // + auto-compact on the SAME denominator the bar shows.
@@ -1594,6 +1719,7 @@ export class RatatuiApp {
             setContextUsage: (used, estimated) => this.publishContextUsage(used, estimated),
             setAgentState: (state) => this.controller.setAgentState(state),
             reloadAgent: (options) => this.reloadAgentInPlace(options?.defer),
+            switchConfigProfile: (name) => this.switchConfigProfileInPlace(name),
             setRuntimeModelOverride: (provider, model) => {
                 configStore.setCliOverride('provider', provider);
                 configStore.setCliOverride('model', model);
@@ -2044,14 +2170,36 @@ export class RatatuiApp {
                 },
             } : {}),
             settingsPanel: {
+                closeSettingsPanel: () => {
+                    if (this.settingsPanelWidget.isActive()) {
+                        this.settingsPanelWidget.cancel();
+                    }
+                    else if (this.activeSettingsWidgetId) {
+                        this.pendingWidgetCallbacks.delete(this.activeSettingsWidgetId);
+                        if (this.mirrorServer)
+                            this.mirrorServer.publishWidgetDismiss(this.activeSettingsWidgetId);
+                        else if (this.mirrorClient)
+                            this.mirrorClient.publishWidgetDismiss(this.activeSettingsWidgetId);
+                        this.activeSettingsWidgetId = null;
+                    }
+                    this.render();
+                },
                 showSettingsPanel: (options) => {
+                    if (this.activeSettingsWidgetId) {
+                        this.pendingWidgetCallbacks.delete(this.activeSettingsWidgetId);
+                        if (this.mirrorServer)
+                            this.mirrorServer.publishWidgetDismiss(this.activeSettingsWidgetId);
+                        else if (this.mirrorClient)
+                            this.mirrorClient.publishWidgetDismiss(this.activeSettingsWidgetId);
+                    }
                     const widgetId = `settings_${++this.widgetIdCounter}`;
+                    this.activeSettingsWidgetId = widgetId;
                     // The full settings page replaced the widget_settings modal in the
                     // web mirror: navigate watching clients to it. A headless child
                     // (mux child or colony cell) posts to the PARENT mirror — the
                     // colony singleton's page is the colony-wide config surface, its
                     // edits landing in the shared config every cell reads.
-                    showSettingsPage({ title: options.title, initialFilter: options.initialFilter }, {
+                    showSettingsPage({ title: options.title, initialFilter: options.initialFilter ?? options.initialCategory?.toLowerCase() }, {
                         mirrorServer: this.mirrorServer,
                         mirrorClient: this.headlessMirror ? this.mirrorClient : null,
                     });
@@ -2059,12 +2207,19 @@ export class RatatuiApp {
                     this.pendingWidgetCallbacks.set(widgetId, (answer) => {
                         if (answer._closed) {
                             this.pendingWidgetCallbacks.delete(widgetId);
-                            this.settingsPanelWidget.cancel();
-                            if (this.mirrorServer)
-                                this.mirrorServer.publishWidgetDismiss(widgetId);
-                            else if (this.mirrorClient)
-                                this.mirrorClient.publishWidgetDismiss(widgetId);
-                            options.onClose?.();
+                            if (this.activeSettingsWidgetId === widgetId)
+                                this.activeSettingsWidgetId = null;
+                            if (this.settingsPanelWidget.isActive()) {
+                                // Its onClose owns dismissal and the user callback.
+                                this.settingsPanelWidget.cancel();
+                            }
+                            else {
+                                if (this.mirrorServer)
+                                    this.mirrorServer.publishWidgetDismiss(widgetId);
+                                else if (this.mirrorClient)
+                                    this.mirrorClient.publishWidgetDismiss(widgetId);
+                                options.onClose?.();
+                            }
                             return;
                         }
                         if (typeof answer.setting === 'string' && typeof answer.value === 'string') {
@@ -2080,10 +2235,16 @@ export class RatatuiApp {
                         this.settingsPanelWidget.show({
                             title: options.title,
                             categories: options.categories,
+                            layout: options.layout,
+                            notice: options.notice,
+                            initialSetting: options.initialSetting,
+                            initialCategory: options.initialCategory,
                             initialFilter: options.initialFilter,
                             onSettingChange: (setting, value) => options.onSettingChange(setting, value),
                             onClose: () => {
                                 this.pendingWidgetCallbacks.delete(widgetId);
+                                if (this.activeSettingsWidgetId === widgetId)
+                                    this.activeSettingsWidgetId = null;
                                 if (this.mirrorServer)
                                     this.mirrorServer.publishWidgetDismiss(widgetId);
                                 options.onClose?.();
@@ -3055,7 +3216,7 @@ export class RatatuiApp {
             debugLog('[start] Calling tui.start()');
             // Start the TUI process
             const desktopUpdateRelaunch = this.desktopMode
-                ? buildDesktopUpdateRelaunchContext(process.argv.slice(1), this.sessionId, process.execPath, process.cwd(), process.pid)
+                ? buildDesktopUpdateRelaunchContext(withActiveProfileArg(process.argv.slice(1)), this.sessionId, process.execPath, process.cwd(), process.pid)
                 : undefined;
             const size = await this.tui.start({
                 mux: this.muxMode,
@@ -3070,6 +3231,7 @@ export class RatatuiApp {
             // rather than zmux scrolling history under a panel it thinks is closed.
             this.wheelCaptureActive = false;
             this.widgetSurfaceOriginY = null;
+            this.widgetSurfaceOriginX = 0;
             const normalized = normalizeTerminalSize(size.cols, size.rows);
             this.cols = normalized.cols;
             this.rows = normalized.rows;
@@ -4736,7 +4898,10 @@ export class RatatuiApp {
         const status = contextStatusFromUsed(used, model, windowOverride);
         this.controller.dispatch({ type: 'SET_CONTEXT', length: used, estimated, status });
         const agentState = this.controller.getState().agentState;
-        this.controller.setAgentState({ ...agentState, contextTokens: used, tokensEstimated: estimated });
+        this.controller.setAgentState({
+            ...agentState, contextTokens: used, tokensEstimated: estimated,
+            cacheInputTokens: undefined, cachedInputTokens: undefined,
+        });
         this.mirror?.publishTokenUsage(used, 0, status.total, status.percentage, { reset: true });
     }
     clearTranscript() {
@@ -5237,8 +5402,9 @@ export class RatatuiApp {
      * used to give up a row here anyway, which left one blank line at the bottom
      * of every spawned ZTC pane.
      *
-     * Inline keeps rows above the viewport for the shell's scrollback, and desktop
-     * is left reserving one because ZTerm's own reservation is unverified.
+     * Inline fills the terminal except for one shell row. The transcript remains
+     * in terminal scrollback when it no longer fits the live view. Desktop is
+     * left reserving one because ZTerm's own reservation is unverified.
      */
     viewportHeightFor(rows, size) {
         if (this.muxMode)
@@ -5247,7 +5413,7 @@ export class RatatuiApp {
             return rows;
         if (this.desktopMode)
             return rows - 1;
-        return Math.min(rows - 1, 20);
+        return rows - 1;
     }
     handleTuiEvent(event) {
         debugLog(`[handleTuiEvent] type=${event.type}`);
@@ -5447,7 +5613,7 @@ export class RatatuiApp {
             ? this.inputState.segments[0].text : '';
         if (textCursorIndex(this.inputState.segments, this.inputState.cursor) !== text.length)
             text = '';
-        this.selectionCompletion.update(text, configStore.getProvider(), signal => buildModelsController(configStore).list(undefined, { signal }), commands, configStore.getModel());
+        this.selectionCompletion.update(text, configStore.getProvider(), (signal, provider, authMode) => buildModelsController(configStore).list(provider, { signal, authMode }), commands, configStore.getModel());
         return this.selectionCompletion.view();
     }
     handleInput(input, key) {
@@ -5543,8 +5709,7 @@ export class RatatuiApp {
                 this.setInputToText(selection.text, selection.text.length);
             else
                 this.render();
-            if (!selection.submit)
-                return;
+            return;
         }
         // Handle Ctrl+C — priority order:
         //   1. If a generation is running, cancel it.
@@ -5951,7 +6116,7 @@ export class RatatuiApp {
             }
             return;
         }
-        // Slash/model/provider completion is handled above; Tab here completes paths.
+        // Slash and model completion is handled above; Tab here completes paths.
         if (key.tab && !key.shift) {
             const currentText = getPlainText(this.inputState.segments);
             // @-mention file completion (ZTC-12): repeated Tab cycles candidates.
@@ -6973,27 +7138,35 @@ export class RatatuiApp {
             this.addErrorMessage(buildCredentialSetupMessage());
             return;
         }
-        // Check if agent is busy - queue message if in queue mode
+        // Enter during a run steers the current turn at its next tool boundary.
+        // Tab remains the explicit after-turn queue.
         const state = this.controller.getState();
         const busy = state.agentState.status !== 'idle' && state.agentState.status !== 'error';
         const inputMode = state.inputMode || 'queue';
         if (busy) {
             if (inputMode === 'queue') {
-                const accepted = this.controller.enqueueMessage({ text, attachments });
-                // The queue entry stores only text/attachments, so a queued goal prompt
-                // loses its "goal-launched" marker. Drop the pending marker rather than
-                // let it leak onto whichever turn the queue starts next.
-                this.nextTurnAutomaticGoal = false;
-                if (accepted) {
-                    // Durable audit alongside the live queue panel; mirror publish
-                    // is explicit because controller.addMessage is terminal-only.
-                    const breadcrumb = `Queued (${this.controller.getQueue().length})`;
-                    this.controller.addMessage({ role: 'system', content: breadcrumb });
-                    this.mirror?.publishMessage('system', breadcrumb);
-                }
-                else {
-                    this.controller.setToast(`Queue full (${MAX_QUEUE}). Cancel or wait.`);
+                this.controller.addMessage({ role: 'user', content: text, attachments, metadata: { steering: true } });
+                const message = this.controller.getState().messages.at(-1);
+                if (message) {
+                    this.pendingSteering.push(message);
+                    if (this.agent) {
+                        const activeAgent = this.agent;
+                        // Serial requests preserve the submitted order on a provider-owned
+                        // thread and in the thread-reuse prefix recorded by that backend.
+                        const attempt = this.nativeSteeringTail.then(() => activeAgent.steerUserMessage(message)).then(accepted => {
+                            if (accepted) {
+                                this.pendingSteering = this.pendingSteering.filter(pending => pending.id !== message.id);
+                            }
+                        }).catch(() => undefined);
+                        this.nativeSteeringTail = attempt;
+                        this.nativeSteeringInFlight.push(attempt);
+                    }
                 }
+                this.nextTurnAutomaticGoal = false;
+                this.mirror?.publishMessage('user', text, attachments.length > 0 ? { attachments } : undefined);
+                this.controller.setToast(this.pendingSteering.length > 1
+                    ? `Sending ${this.pendingSteering.length} messages after the current tool finishes`
+                    : 'Sending after the current tool finishes');
                 return;
             }
             // In interrupt mode, show warning but continue
@@ -7082,6 +7255,11 @@ export class RatatuiApp {
         }
         // Snapshot message count before the run so we can roll back on cancel
         const preRunMessageCount = this.controller.getState().messages.length;
+        // Any steering retained across a prior interrupted or widget-ended turn
+        // is already present in this snapshot. It must not be injected twice.
+        this.pendingSteering = [];
+        this.nativeSteeringInFlight = [];
+        this.nativeSteeringTail = Promise.resolve();
         // Auto-continue and queue flushes re-enter runAgent without going through
         // handleSubmit, so cancel any stale recap here too.
         if (!isRetry) {
@@ -7232,7 +7410,8 @@ export class RatatuiApp {
                             // Unreported clears to undefined rather than holding the previous
                             // turn's value, which would pair a stale cache count with this
                             // turn's input size.
-                            cachedInputTokens: event.usage.cachedInputTokens,
+                            cacheInputTokens: event.cacheInputTokens,
+                            cachedInputTokens: event.contextCachedInputTokens,
                         });
                         this.controller.dispatch({
                             type: 'SET_CONTEXT',
@@ -7243,7 +7422,7 @@ export class RatatuiApp {
                         // Publish token usage to observer
                         this.mirror?.publishTokenUsage(used, event.usage.outputTokens || 0, total, percentage, {
                             reset: contextReset,
-                            cached: event.usage.cachedInputTokens,
+                            cached: event.contextCachedInputTokens,
                         });
                         break;
                     }
@@ -7259,7 +7438,15 @@ export class RatatuiApp {
                         break;
                     }
                 }
-            }));
+            }, () => this.pendingSteering.splice(0)));
+            if (!cancelled) {
+                while (this.nativeSteeringInFlight.length > 0) {
+                    await Promise.allSettled(this.nativeSteeringInFlight.splice(0));
+                }
+            }
+            else {
+                this.nativeSteeringInFlight = [];
+            }
         }
         catch (err) {
             this.flushLocalStreamDelta();
@@ -7283,6 +7470,7 @@ export class RatatuiApp {
                 }
             }
             this.addErrorMessage(`Error: ${errorMsg}`);
+            this.movePendingSteeringToEnd();
             this.controller.setAgentState({ status: 'error', error: errorMsg });
             this.stopSpinner();
             this.mirror?.publishStreamEnd();
@@ -7296,6 +7484,8 @@ export class RatatuiApp {
                     contextTokens: this.controller.getState().agentState.contextTokens,
                     tokensUsed: this.controller.getState().agentState.tokensUsed,
                     tokensEstimated: this.controller.getState().agentState.tokensEstimated,
+                    cacheInputTokens: this.controller.getState().agentState.cacheInputTokens,
+                    cachedInputTokens: this.controller.getState().agentState.cachedInputTokens,
                 });
                 this.mirror?.publishStatus('idle');
             }, 3000);
@@ -7314,6 +7504,7 @@ export class RatatuiApp {
             // with a correction. Use Esc while idle to rewind to an earlier prompt
             // when the whole exchange should come out of context.
             this.addInterruptedNotice();
+            this.movePendingSteeringToEnd();
             this.controller.setAgentState({
                 status: 'idle',
                 // Preserve the token accounting across the idle flip — a wholesale
@@ -7322,6 +7513,8 @@ export class RatatuiApp {
                 contextTokens: this.controller.getState().agentState.contextTokens,
                 tokensUsed: this.controller.getState().agentState.tokensUsed,
                 tokensEstimated: this.controller.getState().agentState.tokensEstimated,
+                cacheInputTokens: this.controller.getState().agentState.cacheInputTokens,
+                cachedInputTokens: this.controller.getState().agentState.cachedInputTokens,
             });
             this.stopSpinner();
             this.mirror?.publishStreamEnd();
@@ -7336,70 +7529,113 @@ export class RatatuiApp {
             return;
         }
         if (result) {
-            // Add final response if not already streamed
-            const state = this.controller.getState();
-            const hasStreamedResponse = this.currentRunStreamed;
-            // Hoist finalMeta so all branches can use it
-            const finalMode = this.controller.getMode();
-            const finalMeta = {
-                ...(finalMode === 'swarm' ? { conductorMode: true } : {}),
-                ...(result.toolCalls.length > 0 ? { toolCallsInTranscript: true } : {}),
-            };
-            // Strip .result/.error from toolCalls before persisting on the assistant —
-            // the explicit tool_result user message (below) carries that data. Keeping
-            // both doubles the context size and the token estimate.
-            const lightToolCalls = result.toolCalls.map(tc => {
-                const { result: _r, error: _e, ...rest } = tc;
-                return rest;
-            });
-            if (!hasStreamedResponse && (result.content || result.toolCalls.length > 0)) {
-                this.controller.addMessage({
-                    role: 'assistant',
-                    content: result.content || '[Using tools...]',
-                    toolCalls: lightToolCalls.length > 0 ? lightToolCalls : undefined,
-                    // Carry the provider's reasoning trace so the next turn replays this
-                    // assistant message intact; reasoning models expect it back as-is.
-                    metadata: result.reasoning ? { ...finalMeta, reasoningContent: result.reasoning } : finalMeta,
-                });
-                if (result.content)
-                    this.maybeSpeakText(result.content);
-            }
-            else if (hasStreamedResponse) {
-                const lastAssistantIdx = state.messages.reduce((last, m, i) => isPersistableAssistantMessage(m) ? i : last, -1);
-                // A streamed turn already has its assistant message in state, so the
-                // reasoning trace has to be attached here too — otherwise it is kept only
-                // for buffered responses and streamed turns replay a stripped history.
-                if (lastAssistantIdx >= 0 && (lightToolCalls.length > 0 || result.reasoning)) {
-                    const updatedMessages = state.messages.map((m, i) => i === lastAssistantIdx
-                        ? {
-                            ...m,
-                            ...(lightToolCalls.length > 0 ? { toolCalls: lightToolCalls } : {}),
-                            metadata: { ...m.metadata, ...finalMeta,
-                                ...(result.reasoning ? { reasoningContent: result.reasoning } : {}),
-                            },
-                        }
-                        : m);
-                    this.controller.setMessages(updatedMessages);
-                }
-            }
-            // Persist tool_result messages for all completed/errored tool calls.
-            // The agent's internal loop pushes these to its local messages array,
-            // but that array is detached from the controller state (immutable reducer).
-            // Without this, repairConversationHistory injects phantom "interrupted"
-            // errors for every tool call, poisoning the context on the next turn.
-            if (result.toolCalls.length > 0) {
-                const toolResultContent = result.toolCalls
-                    .filter(tc => tc.status === 'complete' || tc.status === 'error')
-                    .map(tc => ({
-                    tool_use_id: tc.id,
-                    content: tc.error ? `Error: ${tc.error}` : (tc.result || ''),
+            // The agent's ordered tool-use/result/steering messages are the source of
+            // truth for a steered turn. The normal display path collapses all tool
+            // calls onto the final assistant message, which would replay a steering
+            // prompt before the tool result it followed.
+            const turnMessages = result.turnMessages ?? [];
+            const steeredTurn = turnMessages.some(message => message.metadata?.steering === true);
+            if (steeredTurn) {
+                const live = this.controller.getState().messages;
+                // A steering message the turn actually consumed is replayed from
+                // `turnMessages`, so keeping the live copy would duplicate it. One still
+                // in `pendingSteering` never met a tool boundary: dropping it here loses
+                // the prompt from both the transcript and every request. Keep it, and
+                // `movePendingSteeringToEnd` will place it after the answer and take the
+                // follow-up turn.
+                const unconsumedSteering = new Set(this.pendingSteering.map(message => message.id));
+                const retainedMessages = live.slice(preRunMessageCount)
+                    .filter(message => message.role === 'system' || message.role === 'tool'
+                    || (message.role === 'user'
+                        && (message.metadata?.steering !== true || unconsumedSteering.has(message.id))));
+                const orderedMessages = turnMessages.map(message => ({
+                    ...message,
+                    ...(message.toolCalls ? {
+                        toolCalls: message.toolCalls.map(toolCall => {
+                            const { result: _result, error: _error, ...lightCall } = toolCall;
+                            return lightCall;
+                        }),
+                        metadata: { ...message.metadata, toolCallsInTranscript: true },
+                    } : {}),
                 }));
-                if (toolResultContent.length > 0) {
+                const finalAssistant = result.content.trim()
+                    ? {
+                        id: generateId(), role: 'assistant', content: result.content,
+                        timestamp: new Date(),
+                        ...(result.reasoning ? { metadata: { reasoningContent: result.reasoning } } : {}),
+                    }
+                    : null;
+                this.controller.setMessages([
+                    ...live.slice(0, preRunMessageCount), ...orderedMessages,
+                    ...(finalAssistant ? [finalAssistant] : []), ...retainedMessages,
+                ]);
+            }
+            else {
+                // Add final response if not already streamed
+                const state = this.controller.getState();
+                const hasStreamedResponse = this.currentRunStreamed;
+                // Hoist finalMeta so all branches can use it
+                const finalMode = this.controller.getMode();
+                const finalMeta = {
+                    ...(finalMode === 'swarm' ? { conductorMode: true } : {}),
+                    ...(result.toolCalls.length > 0 ? { toolCallsInTranscript: true } : {}),
+                };
+                // Strip .result/.error from toolCalls before persisting on the assistant —
+                // the explicit tool_result user message (below) carries that data. Keeping
+                // both doubles the context size and the token estimate.
+                const lightToolCalls = result.toolCalls.map(tc => {
+                    const { result: _r, error: _e, ...rest } = tc;
+                    return rest;
+                });
+                if (!hasStreamedResponse && (result.content || result.toolCalls.length > 0)) {
                     this.controller.addMessage({
-                        role: 'user',
-                        content: JSON.stringify(toolResultContent),
-                        metadata: { toolResult: true },
+                        role: 'assistant',
+                        content: result.content || '[Using tools...]',
+                        toolCalls: lightToolCalls.length > 0 ? lightToolCalls : undefined,
+                        // Carry the provider's reasoning trace so the next turn replays this
+                        // assistant message intact; reasoning models expect it back as-is.
+                        metadata: result.reasoning ? { ...finalMeta, reasoningContent: result.reasoning } : finalMeta,
                     });
+                    if (result.content)
+                        this.maybeSpeakText(result.content);
+                }
+                else if (hasStreamedResponse) {
+                    const lastAssistantIdx = state.messages.reduce((last, m, i) => isPersistableAssistantMessage(m) ? i : last, -1);
+                    // A streamed turn already has its assistant message in state, so the
+                    // reasoning trace has to be attached here too — otherwise it is kept only
+                    // for buffered responses and streamed turns replay a stripped history.
+                    if (lastAssistantIdx >= 0 && (lightToolCalls.length > 0 || result.reasoning)) {
+                        const updatedMessages = state.messages.map((m, i) => i === lastAssistantIdx
+                            ? {
+                                ...m,
+                                ...(lightToolCalls.length > 0 ? { toolCalls: lightToolCalls } : {}),
+                                metadata: { ...m.metadata, ...finalMeta,
+                                    ...(result.reasoning ? { reasoningContent: result.reasoning } : {}),
+                                },
+                            }
+                            : m);
+                        this.controller.setMessages(updatedMessages);
+                    }
+                }
+                // Persist tool_result messages for all completed/errored tool calls.
+                // The agent's internal loop pushes these to its local messages array,
+                // but that array is detached from the controller state (immutable reducer).
+                // Without this, repairConversationHistory injects phantom "interrupted"
+                // errors for every tool call, poisoning the context on the next turn.
+                if (result.toolCalls.length > 0) {
+                    const toolResultContent = result.toolCalls
+                        .filter(tc => tc.status === 'complete' || tc.status === 'error')
+                        .map(tc => ({
+                        tool_use_id: tc.id,
+                        content: tc.error ? `Error: ${tc.error}` : (tc.result || ''),
+                    }));
+                    if (toolResultContent.length > 0) {
+                        this.controller.addMessage({
+                            role: 'user',
+                            content: JSON.stringify(toolResultContent),
+                            metadata: { toolResult: true },
+                        });
+                    }
                 }
             }
             // Progress text is not completion. Explicit caps must remain visible even
@@ -7441,8 +7677,13 @@ export class RatatuiApp {
             contextTokens: this.controller.getState().agentState.contextTokens,
             tokensUsed: this.controller.getState().agentState.tokensUsed,
             tokensEstimated: this.controller.getState().agentState.tokensEstimated,
+            cacheInputTokens: this.controller.getState().agentState.cacheInputTokens,
+            cachedInputTokens: this.controller.getState().agentState.cachedInputTokens,
         });
         this.stopSpinner();
+        // The idle-edge subscriber sees pending steering and leaves the Tab queue
+        // alone. Move the prompt after the answer before starting its fallback turn.
+        const needsSteeringTurn = this.movePendingSteeringToEnd();
         // Fold in the final turn when the goal went terminal during this turn (the
         // agent ran `/goal complete` / `/goal pause` via ztc_command, which carries no
         // turn facts). This sits above every early return below — ask_user, plan
@@ -7512,9 +7753,24 @@ export class RatatuiApp {
             setTimeout(() => void this.runAgent(), 0);
             return;
         }
+        // A prompt sent during inference had no later tool boundary. Its user
+        // message is already in the transcript; start a fresh turn with it now.
+        if (needsSteeringTurn) {
+            setTimeout(() => void this.runAgent(), 0);
+            return;
+        }
+        // A `subturn` entry that never met a tool boundary (the model answered
+        // without calling one, or the turn ended right after its last call) must not
+        // be stranded behind Tab entries. Promote it now and take the next turn, in
+        // queue order, so Enter's "send it soon" promise still resolves.
+        const strandedSubturn = this.controller.dequeueSubturnMessage();
         this.maybeTriggerRecap(endOfTurnTokens);
         // Flushing is also subscribed to idle transitions in start().
         const processedQueue = this.maybeFlushQueue();
+        if (strandedSubturn) {
+            void this.handleSubmit({ text: strandedSubturn.text, attachments: strandedSubturn.attachments || [] });
+            return;
+        }
         // If nothing the user queued is taking the next turn, let an active /goal
         // drive the next step. Queued user input always wins, so the goal only
         // continues when the queue is empty.
@@ -7678,25 +7934,49 @@ export class RatatuiApp {
     maybeFlushQueue() {
         if (this.flushingQueue)
             return false;
-        const state = this.controller.getState();
-        if (state.inputMode !== 'queue')
+        if (this.pendingSteering.length > 0)
             return false;
+        const state = this.controller.getState();
+        // Deliberately NOT gated on `inputMode`. `/inputmode interrupt` selects what
+        // Enter does while busy; it must never strand a prompt the user queued with
+        // Tab, which promised delivery at the end of the turn regardless.
         if (state.queue.length === 0)
             return false;
         if (state.agentState.status !== 'idle')
             return false;
         this.flushingQueue = true;
-        const next = this.controller.dequeueMessage();
-        if (!next) {
+        // End-of-turn entries only. A `subturn` entry still waiting here means no
+        // tool boundary arrived before the turn ended; runAgent's idle path starts a
+        // fresh turn for it, so picking it up here too would double-send it.
+        const index = state.queue.findIndex(entry => entry.delivery !== 'subturn');
+        if (index < 0) {
             this.flushingQueue = false;
             return false;
         }
+        const next = this.controller.getQueue()[index];
+        this.controller.removeQueueEntry(next.id);
         void this.handleSubmit({ text: next.text, attachments: next.attachments || [] }).finally(() => {
             this.flushingQueue = false;
             this.maybeFlushQueue();
         });
         return true;
     }
+    /** Put steering that missed a tool boundary after the finished answer. */
+    movePendingSteeringToEnd() {
+        if (this.pendingSteering.length === 0)
+            return false;
+        const ids = new Set(this.pendingSteering.map(message => message.id));
+        const messages = this.controller.getState().messages;
+        const pending = messages.filter(message => ids.has(message.id));
+        this.pendingSteering = [];
+        if (pending.length === 0)
+            return false;
+        this.controller.setMessages([
+            ...messages.filter(message => !ids.has(message.id)),
+            ...pending,
+        ]);
+        return true;
+    }
     /** True while an agent turn is active (same definition as handleSubmit's busy check). */
     isAgentBusy() {
         const status = this.controller.getState().agentState.status;
@@ -7775,11 +8055,15 @@ export class RatatuiApp {
         const serializedText = serializeSegments(this.inputState.segments);
         if (!isMeaningfulUserInput(serializedText))
             return;
-        if (this.controller.enqueueMessage(serializedText)) {
+        // `end-of-turn`: a Tab-queued prompt waits for the WHOLE turn to finish.
+        // Marking the intent on the entry (instead of relying on the busy-state
+        // `inputMode` at flush time) keeps the promise even if the user later runs
+        // /inputmode interrupt, which only governs what Enter does.
+        if (this.controller.enqueueMessage(serializedText, 'end-of-turn')) {
             this.clearComposerAfterSubmit(plainText);
             // Durable audit alongside the live queue panel; mirror publish is
             // explicit because controller.addMessage is terminal-only.
-            const breadcrumb = `Queued (${this.controller.getQueue().length})`;
+            const breadcrumb = `Queued (${this.controller.getQueue().length}) — sends when the turn finishes`;
             this.controller.addMessage({ role: 'system', content: breadcrumb });
             this.mirror?.publishMessage('system', breadcrumb);
         }
@@ -8674,39 +8958,28 @@ export class RatatuiApp {
         // the next rebuild and break the streaming-line accounting).
         this.flushTranscriptState();
         const ctx = this.buildCommandContext((msg) => this.controller.addMessage(msg));
-        // Show approval select widget
-        ctx.select.showSelect({
-            title: 'Plan Approval',
-            question: 'Ready to begin implementation?',
-            type: 'select',
-            options: [
-                { value: 'approve', label: 'Yes, begin implementation (Recommended)', description: 'Approve the plan, create tasks, and start coding' },
-                { value: 'edit', label: 'Edit plan first', description: 'Return to plan mode and continue editing' },
-            ],
-            allowOther: true,
-        }, (value) => {
-            if (value === null) {
+        askPlanApproval(ctx, decision => {
+            if (decision.kind === 'cancel') {
                 this.controller.addMessage({ role: 'system', content: 'Plan execution cancelled. Still in plan mode.' });
                 return;
             }
-            const selection = typeof value === 'string' ? value : '';
-            if (selection === 'approve') {
+            if (decision.kind === 'approve') {
                 this.planApprovedRecently = true;
                 commitPlan(planFile, planContent, tasks, ctx, false);
                 ctx.triggerAgentTurn?.();
             }
-            else if (selection === 'edit') {
+            else if (decision.kind === 'edit') {
                 this.controller.addMessage({ role: 'system', content: 'Returning to plan mode. Continue editing your plan, then run /execute when ready.' });
             }
             else {
-                this.controller.addMessage({ role: 'system', content: `Feedback noted. Still in plan mode.\n\nFeedback: ${selection}` });
-                this.controller.addMessage({ role: 'user', content: `Please update the plan based on this feedback: ${selection}` });
+                this.controller.addMessage({ role: 'system', content: `Feedback noted. Still in plan mode.\n\nFeedback: ${decision.text}` });
+                this.controller.addMessage({ role: 'user', content: `Please update the plan based on this feedback: ${decision.text}` });
             }
         });
     }
     /**
      * Show ask_user widget after ask_user tool is called.
-     * Presents the agent's question with predefined options + "Other..." for custom input.
+     * Presents options with an optional note for additional context.
      */
     showAskUserWidget() {
         const data = this.askUserData;
@@ -8769,6 +9042,7 @@ export class RatatuiApp {
                 })),
             })),
             allowOther,
+            allowOptionNotes: true,
             callback: (answers) => {
                 debugLog(`[askUser multi] callback fired, answers=${JSON.stringify(answers)?.slice(0, 200)}, mutex=${this.askUserAnswerPending}`);
                 if (this.askUserAnswerPending)
@@ -8780,20 +9054,15 @@ export class RatatuiApp {
                     return;
                 }
                 if (data.questions.length === 1) {
-                    const value = answers.q0;
-                    const answerText = Array.isArray(value) ? value.join(', ') : (value || '');
+                    const answerText = formatAskUserResponse(data.questions, answers);
                     this.controller.addMessage({ role: 'user', content: answerText });
                     this.mirror?.publishMessage('user', answerText, { isAskUserAnswer: true });
                     setTimeout(() => void this.runAgent(), 0);
                     return;
                 }
-                // Preserve the existing multi-question wire format.
-                const jsonAnswers = data.questions.map((q, i) => {
-                    const val = answers[`q${i}`];
-                    const answerStr = Array.isArray(val) ? val.join(', ') : (val || '(no answer)');
-                    return { question: q.question, answer: answerStr };
-                });
-                const answerText = JSON.stringify(jsonAnswers);
+                // Preserve the existing multi-question wire format, adding note only
+                // when the user supplied one.
+                const answerText = formatAskUserResponse(data.questions, answers);
                 debugLog(`[askUser multi] sending answer: ${answerText.slice(0, 200)}`);
                 this.controller.addMessage({ role: 'user', content: answerText });
                 this.mirror?.publishMessage('user', answerText, { isAskUserAnswer: true });
@@ -9052,11 +9321,9 @@ export class RatatuiApp {
                 keepPrintedInPane: this.muxMode || this.paneMode,
             });
         }
-        // Plain inline mode can display terminal scrollback and the live frame at
-        // the same time. Once the first-run banner has reached scrollback, remove
-        // only that explicitly-marked message from the live frame so it appears
-        // exactly once. Mux/pane modes retain their existing fallback because
-        // their printed scrollback may not be visible without user navigation.
+        // Once the first-run banner has reached scrollback, remove only that
+        // explicitly-marked message from the live frame so it appears once when
+        // the user scrolls. Mux/pane modes retain their existing fallback.
         if (!externalTranscriptActive && !this.muxMode && !this.paneMode) {
             liveMessages = excludePrintedFirstRunWelcome(liveMessages, this.printedMessageIds);
         }
@@ -9076,15 +9343,15 @@ export class RatatuiApp {
             || this.formWidget.isActive()
             || this.selectWidget.isActive()
             || this.textInputWidget.isActive();
-        // The question form is a transient overlay, not a work surface: it sizes to
-        // its own content and keeps the recent transcript visible above it.
-        const compactWidget = questionnaireActive;
-        // Use liveViewportHeight (not effectiveViewportHeight which is
-        // computed later + expanded for widgets). scroll_region must match
-        // the BASE viewport so it doesn't overflow into the activity_line.
         const agentActive = state.agentState.status === 'thinking'
             || state.agentState.status === 'streaming'
             || state.agentState.status === 'tool_use';
+        const completionView = widgetActive ? null : this.updateSelectionCompletion();
+        // The question form is a transient overlay, not a work surface: it sizes to
+        // its own content and keeps the recent transcript visible above it.
+        const compactWidget = questionnaireActive;
+        // The transcript region must stay above the activity line as the
+        // completion menu expands or contracts.
         // Settings is a full work surface. Unlike transient questions and pickers,
         // it replaces the transcript while open so small terminals still provide
         // enough rows for browsing and editing.
@@ -9094,7 +9361,7 @@ export class RatatuiApp {
             cols: this.cols,
             inputState: this.inputState,
             commands,
-            completion: widgetActive ? null : this.updateSelectionCompletion(),
+            completion: completionView,
             showHeader: false,
             showTodos: state.showTodos,
             todoCount: state.todos.length,
@@ -9105,6 +9372,8 @@ export class RatatuiApp {
             agentActive,
             statusLine: configStore.get().statusLine,
         });
+        if (completionView)
+            this.selectionCompletion.setVisibleRows(Math.max(1, widgetLayout.completionHeight - 1));
         // Determine if a widget is active and get its content
         let widgetContent = null;
         let widgetView = null;
@@ -9224,6 +9493,7 @@ export class RatatuiApp {
             model: configStore.get().model,
             emulationId: configStore.getEmulationId(),
             effort: configStore.getCodexEffort(),
+            unsupportedEffort: configStore.getUnsupportedCodexEffort(),
             inputMode: state.inputMode,
             toast: state.toast,
             spinnerLabel: state.spinnerLabel,
@@ -9326,6 +9596,10 @@ export class RatatuiApp {
         this.widgetSurfaceOriginY = widgetContent && !compactWidget
             ? frameLayout.contentAreaY
             : null;
+        // The panel decides its own left edge, so read it off the line it painted
+        // rather than re-deriving it: a panel that capped its frame starts further
+        // right, and the wheel has to land in the same columns the frame occupies.
+        this.widgetSurfaceOriginX = WIDGET_SURFACE_PADDING_X + leadingSurfaceMargin(widgetContent);
         // Tell zmux whether this process is claiming the wheel. While a panel owns
         // it, zmux forwards notches instead of scrolling the transcript history
         // underneath the panel — otherwise closing the panel would reveal a
@@ -9410,7 +9684,7 @@ export class RatatuiApp {
         if (!owner || originY === null)
             return;
         const y = row - originY;
-        const x = col - WIDGET_SURFACE_PADDING_X;
+        const x = col - this.widgetSurfaceOriginX;
         if (x < 0 || y < 0)
             return;
         owner.handleMouse({ wheel: direction, x, y });
@@ -10112,7 +10386,7 @@ export class RatatuiApp {
             await this.tui.stop();
             // Build relaunch args: preserve runtime flags but force the target session
             // as the only resume target.
-            const { command, args, shell } = buildHotRestartLaunch(process.argv.slice(1), options.sessionId, process.execPath);
+            const { command, args, shell } = buildHotRestartLaunch(withActiveProfileArg(process.argv.slice(1)), options.sessionId, process.execPath);
             const spawnCwd = existsSync(options.cwd) ? options.cwd : process.cwd();
             debugLog(`[${options.label}] Spawning new process: ${command} ${args.join(' ')} (cwd=${spawnCwd})`);
             const child = spawnChild(command, args, {
@@ -10209,6 +10483,7 @@ export class RatatuiApp {
             model: configStore.get().model,
             emulationId: configStore.getEmulationId(),
             effort: configStore.getCodexEffort(),
+            unsupportedEffort: configStore.getUnsupportedCodexEffort(),
             inputMode: state.inputMode,
             toast: state.toast,
             mode: state.mode,