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

package/dist/App.js

@@ -1,14 +1,21 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PromptTurn } from './app/prompt_turn.js';
 import React, { useState, useCallback, useMemo, useRef } from 'react';
 import { Box, Text, useApp, useInput, Static } from 'ink';
 import { Header, MessageList, SingleMessage, InputArea, StatusBar, FullScreen, ActivityLine, useScreenSize, FormWidget, QueuePanel } from './components/index.js';
 import { AgentError } from './agent/index.js';
 import { commands } from './agent/commands/index.js';
+import { goalManager } from './agent/commands/goal.js';
+import { listCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
+import { normalizeInputMode } from './types.js';
 import { DEFAULT_TOAST_MS, MAX_QUEUE } from './app/controller.js';
 import { getQueuePreview } from './ui/views/queue_panel.js';
 import { estimateInputLines } from './ui/views/input_area.js';
 import { configStore } from './config.js';
+import { applyAccountOp } from './web/accounts_mirror.js';
+import { createUsageSnapshot, mergeUsageSnapshots, recordUsageReceipt } from './usage_snapshot.js';
 import { resolveMessageDisplaySettings } from './config/message_display.js';
+import { initialStreamTypewriterState, planStreamTypewriterSample, STREAM_TYPEWRITER_DEFAULTS } from './ui/stream_typewriter.js';
 import { createInputBus, isControlKey } from './ui/core/input.js';
 import { loadEmulationProfiles, getEmulationProfile } from './emulation/catalog.js';
 import { getTraceStyle } from './emulation/trace_style.js';
@@ -21,6 +28,20 @@ import { formatToolStart, formatToolError, buildToolOutputMessage } from './util
 import { autoActivateSkills, buildSkillPrompt } from './skills/index.js';
 import { getSkills } from './skills/registry.js';
 import { createAgentFromConfig } from './agent/factory.js';
+import { hasWorkspaceCollisionRisk, LocalWorkspaceCoordinator, inspectWorkspaceSessions, prepareWorkspaceIsolation, WorkspaceIsolationError } from './workspace_collision.js';
+import { generateSessionId, saveSession } from './session.js';
+import { prepareSessionMessages } from './app/session_messages.js';
+import { captureSessionDiagnosticSnapshot } from './diagnostics/session_export.js';
+import { runtimePluginRegistry } from './plugin/runtime_registry.js';
+import { classifyBusyInput } from './app/task_scope_router.js';
+import { formatWorkspaceAdmissionDetails } from './app/workspace_admission_details.js';
+import { reconcileOrderedTranscript } from './app/ordered_transcript.js';
+import { advanceEscapeStop, isEscapeStopArmed, ESCAPE_STOP_WINDOW_MS } from './app/escape_stop.js';
+import { SelectWidget } from './ui/widgets/select.js';
+import { QuestionnaireWidget } from './ui/widgets/questionnaire.js';
+import { setAskUserCallback, clearAskUserCallback, resetAskUserTurnFlag } from './agent/tools/ask_user.js';
+import { formatAskUserResponse } from './app/ask_user_response.js';
+import { InkNode } from './ui/ink/render.js';
 import { getModeConfig, getNextMode, } from './app/modes.js';
 import { getModeRegistry } from './modes/index.js';
 import { isMeaningfulUserInput } from './app/input_validation.js';
@@ -35,10 +56,11 @@ import { isNativeDictationAvailable, onDictationEvent } from './utils/dictation_
 import { getContextStatus, contextStatusFromUsed } from './utils/context.js';
 import { compactMessages, localSummarizer } from './utils/compaction.js';
 import { speak, optionsFromConfig, isProviderAvailable } from './utils/tts.js';
-import { applyAgentEventToState, buildActivityDisplayState, getAgentActivityPlaceholder } from './app/activity.js';
+import { applyAgentEventToState, buildActivityDisplayState, formatApiRetryNotice, getAgentActivityPlaceholder } from './app/activity.js';
 import { buildCredentialSetupMessage, buildNoCredentialsWelcome, buildReadyWelcome, createFirstRunLaunchMessage, isFirstRunWelcomeMessage, } from './onboarding/first_run.js';
 // --- Utilities ---
 const generateId = () => Math.random().toString(36).slice(2, 11);
+const ESCAPE_CONFIRMATION_HINT = 'Esc again to stop';
 /**
  * Render a VU meter from dB level
  * @param db Audio level in dB (-60 to 0)
@@ -116,7 +138,7 @@ function getWelcomeMessage(runtime) {
     };
 }
 // --- Create agent if possible ---
-function createAgent(mode) {
+function createAgent(mode, skillPrompt, workspace) {
     // Can create agent if we have an API key OR are authenticated
     const hasKey = configStore.hasApiKey();
     const isAuthenticated = configStore.isAuthenticated();
@@ -132,7 +154,9 @@ function createAgent(mode) {
         openaiCompatibleBaseUrl: configStore.getOpenAICompatibleBaseUrl(),
         emulationId: configStore.getEmulationId(),
         mode,
+        skillPrompt,
         allowSelfPlanTransition: false,
+        ...workspace,
     });
 }
 // --- Main App ---
@@ -146,30 +170,111 @@ export const App = () => {
     const messageDisplay = resolveMessageDisplaySettings(configStore.get());
     const shellCwdRef = React.useRef(process.cwd());
     // State
-    const [messages, setMessages] = useState([getWelcomeMessage()]);
+    const [messages, updateMessages] = useState([getWelcomeMessage()]);
     const messagesRef = useRef(messages);
-    const [agentState, setAgentState] = useState({ status: 'idle' });
+    const readingStatesRef = useRef(new Map());
+    const bypassedReadingIdsRef = useRef(new Set());
+    const [readingTick, refreshReadingDisplay] = useState(0);
+    const [, refreshActivityClock] = useState(0);
+    const flushReadingDisplay = useCallback(() => {
+        for (const id of readingStatesRef.current.keys())
+            bypassedReadingIdsRef.current.add(id);
+        readingStatesRef.current.clear();
+        refreshReadingDisplay(tick => tick + 1);
+    }, []);
+    const setMessages = useCallback((next) => {
+        const value = typeof next === 'function' ? next(messagesRef.current) : next;
+        messagesRef.current = value;
+        updateMessages(value);
+    }, []);
+    const [agentState, updateAgentState] = useState({ status: 'idle' });
+    const setAgentState = useCallback((next) => {
+        updateAgentState(previous => {
+            const value = typeof next === 'function' ? next(previous) : next;
+            return { ...value, evidence: value.evidence ?? previous.evidence,
+                workspaceCollision: value.workspaceCollision ?? previous.workspaceCollision };
+        });
+    }, []);
     // Latest agentState for closures that must not capture a stale snapshot (the
     // command context getters below read the real per-call context count live).
     const agentStateRef = useRef(agentState);
     agentStateRef.current = agentState;
-    const [sessionId] = useState(generateId());
+    const [sessionId, setSessionId] = useState(generateSessionId);
+    const sessionIdRef = useRef(sessionId);
+    sessionIdRef.current = sessionId;
+    const readingSessionRef = useRef(sessionId);
+    const [sessionName, setSessionName] = useState();
     const [agentMode, setAgentMode] = useState('normal');
-    const [agent, setAgent] = useState(createAgent);
+    const [agent, setAgent] = useState(null);
+    const diagnosticAgentRef = useRef(null);
+    diagnosticAgentRef.current = agent;
+    const retainedUsageRef = useRef({ sessionId, snapshot: createUsageSnapshot() });
+    const [routingUsageRevision, setRoutingUsageRevision] = useState(0);
+    const getUsageSnapshot = useCallback(() => {
+        if (retainedUsageRef.current.sessionId !== sessionId)
+            retainedUsageRef.current = { sessionId, snapshot: createUsageSnapshot() };
+        const current = diagnosticAgentRef.current;
+        if (current?.getUsageSessionId() === sessionId)
+            retainedUsageRef.current.snapshot = mergeUsageSnapshots(retainedUsageRef.current.snapshot, current.getUsageSnapshot());
+        return structuredClone(retainedUsageRef.current.snapshot);
+    }, [sessionId]);
+    const usageSaveQueueRef = useRef(Promise.resolve());
+    const lastUsageSaveRef = useRef('');
+    const retiredAgentsRef = useRef(new WeakSet());
     const [expandToolOutputs, setExpandToolOutputs] = useState(false);
     const [skills, setSkills] = useState([]);
-    const [inputMode, setInputMode] = useState('queue');
+    const [inputMode, setInputMode] = useState('steer');
     const [queue, setQueue] = useState([]);
     const queueRef = useRef(queue);
-    React.useEffect(() => { queueRef.current = queue; }, [queue]);
+    const queuePausedRef = useRef(false);
     const flushingRef = useRef(false);
+    const [flushing, setFlushing] = useState(false);
     const prevStatusRef = useRef('idle');
     const activeRunIdRef = useRef(null);
     const runCounterRef = useRef(0);
     const abortControllerRef = useRef(null);
+    const runtimeMutationRef = useRef(false);
+    const accountReloadPendingRef = useRef(false);
+    const [escapeStopArm, setEscapeStopArm] = useState(null);
+    const escapeStopArmRef = useRef(null);
+    const escapeStopTimerRef = useRef(null);
     const lastRunDurationRef = useRef(null);
     const pendingPromptRef = useRef(null);
     const formCallbacksRef = useRef(new Map());
+    const questionnaireWidgetRef = useRef(null);
+    const questionnaireInputReadyRef = useRef(false);
+    const questionnaireEventOwnedRef = useRef(false);
+    const agentQuestionRef = useRef(null);
+    const [questionnaireVersion, renderQuestionnaireWidget] = useState(0);
+    const scopeWidgetRef = useRef(null);
+    const [, renderScopeWidget] = useState(0);
+    const routingEpochRef = useRef(0);
+    const routingTailRef = useRef(Promise.resolve());
+    const routingControllersRef = useRef(new Map());
+    const routingDraftsRef = useRef(new Map());
+    const routingChoiceCancelRef = useRef(null);
+    const workspaceWidgetRef = useRef(null);
+    const [, renderWorkspaceWidget] = useState(0);
+    const workspaceChoiceCancelRef = useRef(null);
+    const workspaceAdmissionTailRef = useRef(Promise.resolve());
+    const workspacePausedRef = useRef(false);
+    const pausedWorkspaceInputRef = useRef(null);
+    const pausedWorkspaceOperationRef = useRef(null);
+    const isolatedWorkspaceResumeRef = useRef(null);
+    const workspaceIsolationRunningRef = useRef(false);
+    const [workspaceResumeVersion, setWorkspaceResumeVersion] = useState(0);
+    const workspaceSubmitRef = useRef(async () => { throw new Error('Workspace input is not initialized.'); });
+    const workspaceClosedRef = useRef(false);
+    const workspaceCoordinator = useMemo(() => new LocalWorkspaceCoordinator({
+        sessionId, getCwd: () => shellCwdRef.current, kind: 'interactive',
+        getWork: () => ({ sessionId: sessionIdRef.current, messages: messagesRef.current,
+            goal: goalManager.get(), jobs: listCommandJobs(sessionIdRef.current) }),
+        onSnapshot: snapshot => {
+            if (!workspaceClosedRef.current && snapshot.current.sessionId === sessionIdRef.current)
+                setAgentState(previous => ({ ...previous, workspaceCollision: snapshot }));
+        },
+    }), [sessionId, setAgentState]);
+    const workspaceReadyRef = useRef(null);
     React.useEffect(() => {
         let active = true;
         let runtimeTimer;
@@ -184,7 +289,9 @@ export const App = () => {
                 return prev;
             });
         };
-        configStore.load(true).then(() => {
+        // Mount reuses settings already loaded by the host. A forced disk reload
+        // can overwrite a newer interactive selection while its save is pending.
+        configStore.load(false).then(() => {
             if (!active)
                 return;
             refreshUntouchedWelcome();
@@ -211,10 +318,27 @@ export const App = () => {
         history: [],
         historyIdx: -1
     });
+    const [clearDraftVersion, setClearDraftVersion] = useState(0);
     const lastRequestRef = useRef(null);
+    const promptTurnRef = useRef(null);
+    const [, setPromptClock] = useState(0);
     const [retryAvailable, setRetryAvailable] = useState(false);
     const [toast, setToast] = useState(null);
     const toastTimerRef = useRef(null);
+    const resetEscapeStop = useCallback(() => {
+        if (escapeStopTimerRef.current)
+            clearTimeout(escapeStopTimerRef.current);
+        escapeStopTimerRef.current = null;
+        escapeStopArmRef.current = null;
+        setEscapeStopArm(null);
+        setToast(current => current === ESCAPE_CONFIRMATION_HINT ? null : current);
+    }, []);
+    React.useEffect(() => () => {
+        if (escapeStopTimerRef.current)
+            clearTimeout(escapeStopTimerRef.current);
+        if (toastTimerRef.current)
+            clearTimeout(toastTimerRef.current);
+    }, []);
     const [isRecording, setIsRecording] = useState(false);
     const [recordingDevice, setRecordingDevice] = useState(null);
     const [isTranscribing, setIsTranscribing] = useState(false);
@@ -237,8 +361,8 @@ export const App = () => {
     // the provider-reported window (Codex) as the denominator. Only before the
     // first API response (no real count yet) do we fall back to the char/4 estimate.
     const contextStatus = useMemo(() => (agentState.contextTokens && agentState.contextTokens > 0)
-        ? contextStatusFromUsed(agentState.contextTokens, currentModel, agentState.contextWindow)
-        : getContextStatus(messages, currentModel), [agentState.contextTokens, agentState.contextWindow, messages, currentModel]);
+        ? contextStatusFromUsed(agentState.contextTokens, currentModel, agentState.contextWindow ?? configStore.getModelContextWindow(currentModel))
+        : getContextStatus(messages, currentModel, configStore.getModelContextWindow(currentModel)), [agentState.contextTokens, agentState.contextWindow, messages, currentModel]);
     const spinnerVerbs = configStore.get().spinnerVerbs || DEFAULT_SPINNER_VERBS;
     const spinnerVerbsKey = spinnerVerbs.join('|');
     const queuePreview = useMemo(() => getQueuePreview(queue), [queue]);
@@ -246,10 +370,8 @@ export const App = () => {
         renderCount.current += 1;
         debugLog(`App render #${renderCount.current} (messages=${messages.length}, state=${agentState.status})`);
     });
-    React.useEffect(() => {
-        messagesRef.current = messages;
-    }, [messages]);
     const [debug, setDebug] = useState(false);
+    const [transcriptGeneration, setTranscriptGeneration] = useState(0);
     const scrollback = process.env.ZTC_SCROLLBACK === '1' || process.env.ZTC_ALT_SCREEN !== '1';
     // Spinner label effect - picks a random verb when agent starts working
     React.useEffect(() => {
@@ -274,7 +396,7 @@ export const App = () => {
             return;
         }
         setSpinnerLabel(label);
-    }, [agentState.status, agentState.currentTool, spinnerVerbsKey]);
+    }, [agentState.status, agentState.currentTool, agentState.requestRetry, agentState.waiting, spinnerVerbsKey]);
     // Spinner frame animation effect
     React.useEffect(() => {
         const isActive = agentState.status === 'thinking' || agentState.status === 'streaming' || agentState.status === 'tool_use';
@@ -299,6 +421,14 @@ export const App = () => {
             clearInterval(interval);
         };
     }, [agentState.status, scrollback]);
+    // Scrollback keeps a static spinner, but elapsed time must advance even when
+    // the provider or tool emits nothing. Idle/unmounted apps own no clock timer.
+    React.useEffect(() => {
+        if (!scrollback || !['thinking', 'streaming', 'tool_use'].includes(agentState.status))
+            return;
+        const timer = setInterval(() => refreshActivityClock(tick => tick + 1), 1_000);
+        return () => clearInterval(timer);
+    }, [agentState.status, scrollback]);
     const headerHeight = scrollback ? 0 : 4; // border (2) + content (1) + margin (1)
     const statusHeight = 1;
     const suggestionLines = 4;
@@ -323,10 +453,6 @@ export const App = () => {
     }, [columns, estimateBadgePreviewLines, inputSnapshot, rows]);
     // Calculate content height (total - header - input - status)
     const contentHeight = useMemo(() => scrollback ? undefined : Math.max(rows - (headerHeight + inputHeight + statusHeight), 5), [rows, scrollback, inputHeight]);
-    // Reload agent when config changes
-    const reloadAgent = useCallback(() => {
-        setAgent(createAgent());
-    }, []);
     React.useEffect(() => {
         let active = true;
         getSkills()
@@ -339,27 +465,66 @@ export const App = () => {
         return () => { active = false; };
     }, []);
     // Keyboard shortcuts
+    const ownsLocalForm = formCallbacksRef.current.size > 0;
     useInput((input, key) => {
-        if (isControlKey(input, key, 'c')) {
-            if (!cancelGeneration())
-                exit();
+        if (!key.escape)
+            resetEscapeStop();
+        if (workspaceWidgetRef.current?.isActive()) {
+            if (key.escape)
+                resetEscapeStop();
+            workspaceWidgetRef.current.handleInput(input, key);
+            return;
+        }
+        if (questionnaireWidgetRef.current?.isActive()) {
+            // Every subscriber to this same key must respect its widget owner,
+            // even when answering closes the widget before the composer sees it.
+            questionnaireEventOwnedRef.current = true;
+            queueMicrotask(() => { questionnaireEventOwnedRef.current = false; });
+            resetEscapeStop();
+            if (questionnaireInputReadyRef.current)
+                questionnaireWidgetRef.current.handleInput(input, key);
+            return;
+        }
+        if (scopeWidgetRef.current?.isActive()) {
+            if (key.escape)
+                resetEscapeStop();
+            scopeWidgetRef.current.handleInput(input, key);
+            return;
         }
         if (key.escape) {
-            // Esc precedence: active run → cancel; else idle + empty composer +
-            // non-empty queue → drop newest; else cancel (no-op).
-            const hasActiveRun = abortControllerRef.current !== null;
-            const composerEmpty = inputSnapshot.segments.length === 0;
-            if (hasActiveRun) {
-                cancelGeneration();
+            if (ownsLocalForm) {
+                resetEscapeStop();
+                // The focused FormWidget consumes this same key locally.
+                return;
             }
-            else if (composerEmpty && queueRef.current.length > 0) {
-                const newest = queueRef.current[queueRef.current.length - 1];
-                removeQueueEntry(newest.id);
-                showToastRef.current?.('Dropped queued message');
+            if (pendingPromptRef.current) {
+                resetEscapeStop();
+                retireRouting();
+                pendingPromptRef.current = null;
+                setClearDraftVersion(version => version + 1);
+                addMessage({ role: 'system', content: 'Cancelled.' });
+                return;
             }
-            else {
+            const next = advanceEscapeStop(escapeStopArmRef.current, abortControllerRef.current, Date.now());
+            resetEscapeStop();
+            if (next.confirmed) {
+                queuePausedRef.current = true;
                 cancelGeneration();
+                return;
+            }
+            if (next.arm) {
+                const arm = next.arm;
+                escapeStopArmRef.current = arm;
+                setEscapeStopArm(arm);
+                // The policy includes the exact 2000ms boundary.
+                escapeStopTimerRef.current = setTimeout(() => {
+                    if (escapeStopArmRef.current !== arm)
+                        return;
+                    resetEscapeStop();
+                }, ESCAPE_STOP_WINDOW_MS + 1);
+                showToastRef.current?.(ESCAPE_CONFIRMATION_HINT, ESCAPE_STOP_WINDOW_MS);
             }
+            return;
         }
         if (isControlKey(input, key, 'l')) {
             setMessages([{
@@ -377,50 +542,542 @@ export const App = () => {
     const addMessage = useCallback((msg) => {
         setMessages(prev => [...prev, {
                 ...msg,
+                ...(msg.role === 'assistant' && !msg.turn && promptTurnRef.current ? { turn: promptTurnRef.current.snapshot() } : {}),
                 id: generateId(),
                 timestamp: new Date()
             }]);
     }, []);
     const showToastRef = useRef(null);
+    const questionnaireWidget = useMemo(() => new QuestionnaireWidget({
+        render: () => renderQuestionnaireWidget(version => version + 1),
+        addSystemMessage: content => addMessage({ role: 'system', content }),
+        setToast: (content, durationMs) => {
+            if (content)
+                showToastRef.current?.(content, durationMs);
+            else
+                setToast(null);
+        },
+        writeClipboard,
+    }), [addMessage]);
+    questionnaireWidgetRef.current = questionnaireWidget;
+    React.useEffect(() => () => {
+        questionnaireInputReadyRef.current = false;
+        questionnaireWidget.cancel();
+    }, [questionnaireWidget]);
+    const retireAgentQuestion = useCallback(() => {
+        if (!agentQuestionRef.current)
+            return;
+        agentQuestionRef.current = null;
+        questionnaireInputReadyRef.current = false;
+        questionnaireWidget.cancel();
+        renderQuestionnaireWidget(version => version + 1);
+    }, [questionnaireWidget]);
+    React.useEffect(() => {
+        setAskUserCallback(questions => {
+            const runId = activeRunIdRef.current;
+            const owner = lastRequestRef.current?.agent;
+            if (!runId || !owner || workspaceClosedRef.current || !abortControllerRef.current
+                || abortControllerRef.current.signal.aborted || retiredAgentsRef.current.has(owner))
+                return 'Question input has no active owning agent turn.';
+            if (pendingPromptRef.current || formCallbacksRef.current.size > 0 || questionnaireWidget.isActive())
+                return 'Another interactive input owns this session.';
+            const pending = agentQuestionRef.current;
+            if (pending && (pending.runId !== runId || pending.agent !== owner))
+                return 'Another agent turn owns the pending question.';
+            if (pending)
+                pending.questions.push(...structuredClone(questions));
+            else
+                agentQuestionRef.current = { runId, sessionId: sessionIdRef.current, agent: owner,
+                    questions: structuredClone(questions), shown: false };
+            return null;
+        });
+        return () => {
+            clearAskUserCallback();
+            agentQuestionRef.current = null;
+            questionnaireInputReadyRef.current = false;
+            questionnaireWidget.cancel();
+        };
+    }, [questionnaireWidget]);
+    React.useEffect(() => { retireAgentQuestion(); }, [agent, sessionId, retireAgentQuestion]);
+    const presentAgentQuestion = useCallback((runId) => {
+        const owner = agentQuestionRef.current;
+        if (!owner || owner.runId !== runId || owner.shown)
+            return;
+        if (workspaceClosedRef.current || owner.sessionId !== sessionIdRef.current
+            || owner.agent !== diagnosticAgentRef.current || retiredAgentsRef.current.has(owner.agent)) {
+            retireAgentQuestion();
+            return;
+        }
+        owner.shown = true;
+        questionnaireInputReadyRef.current = false;
+        questionnaireWidget.show({
+            title: owner.questions.length === 1 ? 'Question' : 'Questions',
+            questions: owner.questions.map((question, index) => ({ name: `q${index}`,
+                header: owner.questions.length > 1 ? `Q${index + 1}` : undefined,
+                question: question.question, type: 'select', required: true,
+                options: question.options.map(option => ({ value: option.label, ...option })),
+            })),
+            allowOther: owner.questions[0]?.allow_other ?? true,
+            allowOptionNotes: true,
+            callback: async (answers) => {
+                if (agentQuestionRef.current !== owner || workspaceClosedRef.current
+                    || owner.sessionId !== sessionIdRef.current || owner.agent !== diagnosticAgentRef.current
+                    || retiredAgentsRef.current.has(owner.agent))
+                    return;
+                agentQuestionRef.current = null;
+                questionnaireInputReadyRef.current = false;
+                await workspaceSubmitRef.current(answers === null ? '__SKIP__' : formatAskUserResponse(owner.questions, answers), undefined, undefined, true);
+            },
+        });
+        queueMicrotask(() => { if (agentQuestionRef.current === owner)
+            questionnaireInputReadyRef.current = true; });
+    }, [questionnaireWidget, retireAgentQuestion]);
+    const scopeWidget = useMemo(() => new SelectWidget({
+        render: () => renderScopeWidget(version => version + 1),
+        addSystemMessage: content => addMessage({ role: 'system', content }),
+        setToast: content => { if (content)
+            showToastRef.current?.(content); },
+        writeClipboard,
+    }), [addMessage]);
+    scopeWidgetRef.current = scopeWidget;
+    const retireRouting = useCallback((restore = true) => {
+        resetEscapeStop();
+        routingEpochRef.current += 1;
+        for (const controller of routingControllersRef.current.values())
+            controller.abort();
+        routingControllersRef.current.clear();
+        if (restore)
+            for (const draft of routingDraftsRef.current.values())
+                draft?.restore();
+        routingDraftsRef.current.clear();
+        routingChoiceCancelRef.current?.();
+        routingChoiceCancelRef.current = null;
+        scopeWidget.cancel();
+        routingTailRef.current = Promise.resolve();
+        renderScopeWidget(version => version + 1);
+    }, [resetEscapeStop, scopeWidget]);
+    React.useEffect(() => () => { retireRouting(false); }, [retireRouting]);
     /** Returns the post-enqueue size, or null if the queue was full. */
-    const enqueueMessage = useCallback((text, delivery = 'end-of-turn') => {
+    const enqueueMessage = useCallback((text, delivery = 'end-of-turn', submitted) => {
         const current = queueRef.current;
-        if (current.length >= MAX_QUEUE) {
+        const reserved = routingDraftsRef.current.size
+            - (submitted && routingDraftsRef.current.has(submitted.id) ? 1 : 0);
+        if (current.length + reserved >= MAX_QUEUE) {
             showToastRef.current?.(`Queue full (${MAX_QUEUE}). Cancel or wait.`);
             return null;
         }
-        const entry = {
+        const entry = submitted ?? {
             id: generateId(),
             text,
             queuedAt: new Date(),
             delivery,
         };
         const nextSize = current.length + 1;
-        setQueue(prev => (prev.length >= MAX_QUEUE ? prev : [...prev, entry]));
+        queueRef.current = [...current, entry];
+        setQueue(queueRef.current);
         return nextSize;
     }, []);
     const dequeueMessage = useCallback(() => {
         const current = queueRef.current;
         if (current.length === 0)
             return undefined;
-        const head = current[0];
-        setQueue(prev => prev.slice(1));
-        return head;
-    }, []);
-    const removeQueueEntry = useCallback((id) => {
-        setQueue(prev => prev.filter(e => e.id !== id));
+        // A steering correction that missed its tool boundary gets the next
+        // request before Tab's explicit after-turn work.
+        const index = Math.max(0, current.findIndex(entry => entry.delivery === 'subturn'));
+        const entry = current[index];
+        queueRef.current = current.filter(candidate => candidate.id !== entry.id);
+        setQueue(queueRef.current);
+        return entry;
     }, []);
     const cancelGeneration = useCallback(() => {
+        retireAgentQuestion();
+        resetEscapeStop();
+        flushReadingDisplay();
         if (abortControllerRef.current) {
+            retireRouting();
+            if (lastRequestRef.current)
+                retiredAgentsRef.current.add(lastRequestRef.current.agent);
             activeRunIdRef.current = null;
             abortControllerRef.current.abort();
             abortControllerRef.current = null;
+            streamingMessageId.current = null;
+            streamedResponse.current = false;
+            setMessages(previous => previous.map(message => message.isStreaming
+                ? { ...message, isStreaming: false } : message));
             setAgentState({ status: 'idle' });
-            addMessage({ role: 'system', content: 'Generation cancelled' });
+            showToastRef.current?.('Stopped by you');
             return true;
         }
         return false;
-    }, [addMessage]);
+    }, [resetEscapeStop, retireRouting, flushReadingDisplay, retireAgentQuestion]);
+    const workspaceWidget = useMemo(() => new SelectWidget({
+        render: () => renderWorkspaceWidget(version => version + 1),
+        addSystemMessage: content => addMessage({ role: 'system', content }),
+        setToast: content => { if (content)
+            showToastRef.current?.(content); },
+        writeClipboard,
+    }), [addMessage]);
+    workspaceWidgetRef.current = workspaceWidget;
+    React.useEffect(() => {
+        workspaceClosedRef.current = false;
+        workspaceReadyRef.current = workspaceCoordinator.start();
+        const unsubscribeJobs = subscribeCommandJobs(sessionId, () => {
+            if (!workspaceClosedRef.current && sessionIdRef.current === sessionId)
+                void workspaceCoordinator.refresh().catch(error => debugLog(`[workspace.jobs] ${String(error)}`));
+        });
+        void workspaceReadyRef.current.catch(error => {
+            if (!workspaceClosedRef.current)
+                addMessage({ role: 'system', content: `Workspace discovery unavailable: ${error instanceof Error ? error.message : String(error)}` });
+        });
+        return () => {
+            workspaceClosedRef.current = true;
+            unsubscribeJobs();
+            workspaceChoiceCancelRef.current?.();
+            pausedWorkspaceOperationRef.current?.cancel();
+            pausedWorkspaceOperationRef.current = null;
+            workspaceWidget.cancel();
+            void workspaceCoordinator.close().catch(error => debugLog(`[workspace.close] ${String(error)}`));
+        };
+    }, [sessionId, workspaceCoordinator, workspaceWidget, addMessage]);
+    const refreshWorkspace = useCallback(async () => {
+        if (workspaceReadyRef.current)
+            await workspaceReadyRef.current;
+        return workspaceCoordinator.refresh();
+    }, [workspaceCoordinator]);
+    const readWorkspace = useCallback(async (cwd) => {
+        const snapshot = await refreshWorkspace();
+        return cwd === undefined ? snapshot : inspectWorkspaceSessions(cwd, sessionId);
+    }, [refreshWorkspace, sessionId]);
+    const admitWorkspace = useCallback((signal, cwd) => {
+        const admission = workspaceAdmissionTailRef.current.then(async () => {
+            let snapshot = await readWorkspace(cwd);
+            if (workspacePausedRef.current || workspaceClosedRef.current || signal?.aborted)
+                return { allowed: false, snapshot };
+            while (hasWorkspaceCollisionRisk(snapshot) && !workspaceCoordinator.isAcknowledged(snapshot)) {
+                resetEscapeStop();
+                const choice = await new Promise(resolve => {
+                    let settled = false;
+                    const finish = (value) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        signal?.removeEventListener('abort', abort);
+                        workspaceChoiceCancelRef.current = null;
+                        workspaceWidget.cancel();
+                        renderWorkspaceWidget(version => version + 1);
+                        resolve(value);
+                    };
+                    const abort = () => finish(null);
+                    workspaceChoiceCancelRef.current = () => finish(null);
+                    if (signal?.aborted || workspaceClosedRef.current) {
+                        finish(null);
+                        return;
+                    }
+                    signal?.addEventListener('abort', abort, { once: true });
+                    workspaceWidget.show({ title: 'Workspace overlap',
+                        question: formatWorkspaceAdmissionDetails(snapshot),
+                        type: 'select', allowOther: false,
+                        options: [{ value: 'continue', label: 'Continue here' },
+                            { value: 'isolate', label: 'Isolate this session' }, { value: 'pause', label: 'Pause this session' }],
+                        callback: value => finish(typeof value === 'string' ? value : null),
+                    });
+                });
+                if (signal?.aborted || workspaceClosedRef.current)
+                    return { allowed: false, snapshot };
+                if (choice === 'continue') {
+                    const checked = await readWorkspace(cwd);
+                    if (checked.fingerprint !== snapshot.fingerprint) {
+                        snapshot = checked;
+                        continue;
+                    }
+                    workspaceCoordinator.acknowledge(checked);
+                    return { allowed: true, snapshot: checked };
+                }
+                workspacePausedRef.current = true;
+                queuePausedRef.current = true;
+                const paused = await workspaceCoordinator.setActivity('paused');
+                if (cwd === undefined)
+                    snapshot = paused;
+                return { allowed: false, snapshot, isolate: choice === 'isolate' };
+            }
+            return { allowed: true, snapshot };
+        });
+        workspaceAdmissionTailRef.current = admission.then(() => { }, () => { });
+        return admission;
+    }, [readWorkspace, workspaceCoordinator, workspaceWidget, resetEscapeStop, addMessage]);
+    const workspaceFactoryOptions = useCallback(() => ({
+        cwd: shellCwdRef.current, sessionId,
+        toolEffectObserver: async (event) => {
+            if (event.effect === 'read')
+                return;
+            const admission = await admitWorkspace(event.signal, event.cwd);
+            if (!admission.allowed) {
+                if (workspaceClosedRef.current || event.signal?.aborted)
+                    throw new AgentError('Workspace execution cancelled before this managed effect.', 'CANCELLED');
+                if (pausedWorkspaceOperationRef.current)
+                    throw new AgentError('Workspace paused with an earlier operation retained.', 'CANCELLED');
+                const owner = abortControllerRef.current?.signal === event.signal ? abortControllerRef.current : null;
+                await new Promise((resolve, reject) => {
+                    let settled = false;
+                    let resuming = false;
+                    const finish = (error) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        event.signal?.removeEventListener('abort', abort);
+                        if (pausedWorkspaceOperationRef.current === operation)
+                            pausedWorkspaceOperationRef.current = null;
+                        if (error)
+                            reject(error);
+                        else
+                            resolve();
+                    };
+                    const abort = () => finish(new AgentError('Workspace execution cancelled before this managed effect.', 'CANCELLED'));
+                    const operation = {
+                        kind: 'tool', cwd: event.cwd ?? shellCwdRef.current,
+                        fingerprint: admission.snapshot.fingerprint,
+                        resume: async () => {
+                            if (settled || resuming)
+                                return;
+                            resuming = true;
+                            try {
+                                const checked = await admitWorkspace(event.signal, event.cwd);
+                                if (workspaceClosedRef.current || event.signal?.aborted) {
+                                    abort();
+                                    return;
+                                }
+                                if (!checked.allowed) {
+                                    operation.fingerprint = checked.snapshot.fingerprint;
+                                    return;
+                                }
+                                await workspaceCoordinator.setActivity('running');
+                                if (workspaceClosedRef.current || event.signal?.aborted) {
+                                    abort();
+                                    return;
+                                }
+                                finish();
+                            }
+                            catch (error) {
+                                if (!settled) {
+                                    workspacePausedRef.current = true;
+                                    queuePausedRef.current = true;
+                                }
+                                throw error;
+                            }
+                            finally {
+                                resuming = false;
+                            }
+                        },
+                        cancel: () => { owner?.abort(); abort(); },
+                    };
+                    pausedWorkspaceOperationRef.current = operation;
+                    event.signal?.addEventListener('abort', abort, { once: true });
+                    if (event.signal?.aborted || workspaceClosedRef.current) {
+                        abort();
+                        return;
+                    }
+                    addMessage({ role: 'system', content: 'Workspace session paused. The managed operation is retained; use /sessions continue.' });
+                });
+            }
+        },
+        onLocalFileChange: async (paths, cwd) => { await workspaceCoordinator.recordObservedPaths(paths, cwd); },
+    }), [admitWorkspace, addMessage, sessionId, workspaceCoordinator]);
+    const createBoundAgent = useCallback((mode, skillPrompt) => {
+        const next = createAgent(mode, skillPrompt, workspaceFactoryOptions());
+        const previous = diagnosticAgentRef.current;
+        if (next) {
+            next.restoreUsageSnapshot(getUsageSnapshot());
+            if (previous?.getDiagnosticSessionId() === next.getDiagnosticSessionId()) {
+                next.restoreDiagnosticSnapshot(captureSessionDiagnosticSnapshot({
+                    messages: messagesRef.current, diagnostics: previous.getDiagnosticSnapshot(),
+                }));
+            }
+            next.recordDiagnosticEvent('runtime', { renderer: 'ink', rendererVersion: null, nativeCapabilities: null });
+            next.recordDiagnosticEvent('mode', { mode: mode ?? 'normal', source: 'agent_construction' });
+            diagnosticAgentRef.current = next;
+        }
+        return next;
+    }, [workspaceFactoryOptions, getUsageSnapshot]);
+    // Every reconstruction retains workspace admission and successful-file observation.
+    const reloadAgent = useCallback(() => {
+        retireAgentQuestion();
+        const previous = diagnosticAgentRef.current;
+        const next = createBoundAgent();
+        diagnosticAgentRef.current = next;
+        if (previous && previous !== next) {
+            retiredAgentsRef.current.add(previous);
+            previous.dispose();
+        }
+        if (lastRequestRef.current && next)
+            lastRequestRef.current = { ...lastRequestRef.current, agent: next };
+        setAgent(next);
+    }, [createBoundAgent, retireAgentQuestion]);
+    const applyAccountOperation = useCallback(async (body) => {
+        if (runtimeMutationRef.current || abortControllerRef.current
+            || (agentStateRef.current.status !== 'idle' && agentStateRef.current.status !== 'error'))
+            return { ok: false, blocked: true, error: 'An agent turn or tool is active; wait before switching accounts.' };
+        runtimeMutationRef.current = true;
+        let operationOpen = true;
+        try {
+            return await applyAccountOp(body, configStore, () => {
+                if (!operationOpen && (abortControllerRef.current || runtimeMutationRef.current)) {
+                    accountReloadPendingRef.current = true;
+                    addMessage({ role: 'system', content: 'Account sign-in completed; reload will apply after this turn finishes.' });
+                    return;
+                }
+                reloadAgent();
+            });
+        }
+        finally {
+            operationOpen = false;
+            runtimeMutationRef.current = false;
+        }
+    }, [reloadAgent, addMessage]);
+    React.useEffect(() => { setAgent(createBoundAgent()); }, [createBoundAgent]);
+    React.useEffect(() => {
+        if ((agentState.status !== 'idle' && agentState.status !== 'error') || abortControllerRef.current)
+            return;
+        if (accountReloadPendingRef.current && !runtimeMutationRef.current) {
+            accountReloadPendingRef.current = false;
+            reloadAgent();
+        }
+        const usage = getUsageSnapshot();
+        if (!usage.receipts.length && !usage.omittedReceipts)
+            return;
+        const signature = JSON.stringify([sessionId, usage]);
+        if (signature === lastUsageSaveRef.current)
+            return;
+        const messages = structuredClone(messagesRef.current);
+        const runtime = { mode: agentMode, usage, evidence: agent?.getEvidenceSnapshot(),
+            diagnostics: captureSessionDiagnosticSnapshot({ messages, diagnostics: agent?.getDiagnosticSnapshot() }) };
+        const cwd = shellCwdRef.current;
+        usageSaveQueueRef.current = usageSaveQueueRef.current.then(async () => {
+            await saveSession(sessionId, cwd, prepareSessionMessages(messages), configStore.getModel(), configStore.getProvider(), undefined, undefined, runtime);
+            lastUsageSaveRef.current = signature;
+        }).catch(error => { addMessage({ role: 'system', content: `Usage checkpoint could not be saved: ${String(error)}` }); });
+    }, [agentState.status, agent, agentMode, sessionId, getUsageSnapshot, reloadAgent, addMessage, routingUsageRevision]);
+    const isolateWorkspace = useCallback(async () => {
+        if (workspaceIsolationRunningRef.current || workspaceClosedRef.current)
+            return false;
+        if (pausedWorkspaceOperationRef.current) {
+            addMessage({ role: 'system', content: 'The paused operation belongs to the current execution context. Use /sessions continue to finish it, then isolate a fresh task; the original operation is retained.' });
+            return false;
+        }
+        if (configStore.get().remoteResources !== undefined || process.env.ZTC_HOST_RUNTIME !== undefined
+            || runtimePluginRegistry.resolveHostRuntime({ mode: agentMode })) {
+            addMessage({ role: 'system', content: 'This host or guarded remote session owns its execution context. Local isolation cannot transfer its conversation or remote lease. Your input is retained; use /sessions continue here or open a separate local session.' });
+            return false;
+        }
+        workspaceIsolationRunningRef.current = true;
+        workspacePausedRef.current = true;
+        queuePausedRef.current = true;
+        const oldSessionId = sessionId;
+        let retainedTarget = null;
+        try {
+            cancelGeneration();
+            retireRouting();
+            const snapshot = await workspaceCoordinator.setActivity('paused');
+            await saveSession(oldSessionId, shellCwdRef.current, prepareSessionMessages(structuredClone(messagesRef.current)), configStore.getModel(), configStore.getProvider(), undefined, undefined, { mode: agentMode, usage: getUsageSnapshot(), evidence: agent?.getEvidenceSnapshot(), diagnostics: captureSessionDiagnosticSnapshot({ messages: messagesRef.current, diagnostics: agent?.getDiagnosticSnapshot() }) });
+            const isolated = await prepareWorkspaceIsolation(snapshot);
+            retainedTarget = isolated.cwd;
+            const nextSessionId = generateSessionId();
+            await saveSession(nextSessionId, isolated.cwd, [], configStore.getModel(), configStore.getProvider(), undefined, undefined, { mode: agentMode });
+            if (workspaceClosedRef.current || sessionIdRef.current !== oldSessionId)
+                return false;
+            const pending = pausedWorkspaceInputRef.current;
+            isolatedWorkspaceResumeRef.current = { sessionId: nextSessionId,
+                ...(pending ? { text: pending.text, queuedEntry: pending.queuedEntry, askUserAnswer: pending.askUserAnswer } : {}) };
+            if (agent) {
+                retiredAgentsRef.current.add(agent);
+                agent.dispose();
+            }
+            lastRequestRef.current = null;
+            activeSkillIds.current = [];
+            toolStartTimes.current.clear();
+            streamingMessageId.current = null;
+            streamedResponse.current = false;
+            shellCwdRef.current = isolated.cwd;
+            sessionIdRef.current = nextSessionId;
+            setAgent(null);
+            setMessages([]);
+            updateAgentState({ status: 'idle' });
+            setClearDraftVersion(version => version + 1);
+            setSessionId(nextSessionId);
+            addMessage({ role: 'system', content: `Workspace isolated: ${isolated.cwd}\nSession: ${nextSessionId}\nPrevious session saved: ${oldSessionId}. Source edits and index preserved.` });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof WorkspaceIsolationError)
+                retainedTarget = error.retainedTarget;
+            if (!workspaceClosedRef.current)
+                addMessage({ role: 'system', content: `Workspace isolation failed: ${error instanceof Error ? error.message : String(error)}${retainedTarget ? `\nRetained target: ${retainedTarget}` : ''}\nYour current session, input and queued work are retained; use /sessions continue.` });
+            return false;
+        }
+        finally {
+            workspaceIsolationRunningRef.current = false;
+        }
+    }, [addMessage, agent, agentMode, cancelGeneration, retireRouting, sessionId, setMessages, workspaceCoordinator]);
+    React.useEffect(() => {
+        const pending = isolatedWorkspaceResumeRef.current;
+        if (!pending || pending.sessionId !== sessionId)
+            return;
+        // This effect runs after the fresh coordinator and Agent bindings are installed.
+        // Keep the queue paused until the new session owns the submitted input.
+        void refreshWorkspace().then(async () => {
+            if (workspaceClosedRef.current || sessionIdRef.current !== pending.sessionId)
+                return;
+            isolatedWorkspaceResumeRef.current = null;
+            pausedWorkspaceInputRef.current = null;
+            workspacePausedRef.current = false;
+            queuePausedRef.current = false;
+            if (pending.text !== undefined) {
+                flushingRef.current = true;
+                setFlushing(true);
+                try {
+                    await workspaceSubmitRef.current(pending.text, undefined, pending.queuedEntry, pending.askUserAnswer);
+                }
+                finally {
+                    flushingRef.current = false;
+                    setFlushing(false);
+                }
+            }
+            setWorkspaceResumeVersion(version => version + 1);
+        }).catch(error => {
+            if (!workspaceClosedRef.current)
+                addMessage({ role: 'system', content: `The isolated session could not resume: ${error instanceof Error ? error.message : String(error)}. Use /sessions continue.` });
+        });
+    }, [sessionId, refreshWorkspace, addMessage]);
+    const continueWorkspace = useCallback(async () => {
+        const pending = pausedWorkspaceInputRef.current;
+        const operation = pausedWorkspaceOperationRef.current;
+        const snapshot = await readWorkspace(operation?.cwd);
+        if ((operation?.fingerprint ?? pending?.fingerprint) === snapshot.fingerprint)
+            workspaceCoordinator.acknowledge(snapshot);
+        workspacePausedRef.current = false;
+        queuePausedRef.current = false;
+        await workspaceCoordinator.setActivity('idle');
+        if (pending || operation) {
+            pausedWorkspaceInputRef.current = null;
+            // A suspended tool stays reachable for cancellation until its owner resolves.
+            if (operation?.kind !== 'tool')
+                pausedWorkspaceOperationRef.current = null;
+            flushingRef.current = true;
+            setFlushing(true);
+            try {
+                if (operation?.kind === 'tool')
+                    await operation.resume();
+                if (pending)
+                    await workspaceSubmitRef.current(pending.text, undefined, pending.queuedEntry, pending.askUserAnswer);
+                if (operation && operation.kind !== 'tool')
+                    await operation.resume();
+            }
+            finally {
+                flushingRef.current = false;
+                setFlushing(false);
+            }
+        }
+        setWorkspaceResumeVersion(version => version + 1);
+    }, [readWorkspace, workspaceCoordinator]);
     React.useEffect(() => {
         if (process.env.ZTC_DISABLE_UPDATE === '1')
             return;
@@ -495,8 +1152,13 @@ export const App = () => {
         });
     }, [contextStatus, agentState.status, messages, currentModel, addMessage]);
     const clearMessages = useCallback(() => {
+        retireAgentQuestion();
+        resetEscapeStop();
+        retireRouting();
+        flushReadingDisplay();
         setMessages([]);
-    }, []);
+        setTranscriptGeneration(generation => generation + 1);
+    }, [resetEscapeStop, retireRouting, setMessages, flushReadingDisplay, retireAgentQuestion]);
     const getMessages = useCallback(() => messages, [messages]);
     const shellController = useMemo(() => ({
         getCwd: () => shellCwdRef.current,
@@ -507,156 +1169,245 @@ export const App = () => {
             if (agent) {
                 agent.setCwd(next);
             }
+            await refreshWorkspace();
             return next;
         },
-        run: async (command) => runShellCommand(command, shellCwdRef.current)
-    }), [agent]);
+        run: (command) => {
+            const cwd = shellCwdRef.current;
+            return new Promise((resolve, reject) => {
+                const execute = async () => {
+                    const admission = await admitWorkspace(undefined, cwd);
+                    if (workspaceClosedRef.current)
+                        throw new Error('Workspace command cancelled when the session closed.');
+                    if (!admission.allowed) {
+                        if (pausedWorkspaceOperationRef.current)
+                            throw new Error('Workspace paused with an earlier operation retained. Continue that operation, then resubmit this command.');
+                        pausedWorkspaceOperationRef.current = { kind: 'shell', cwd,
+                            fingerprint: admission.snapshot.fingerprint, resume: execute,
+                            cancel: () => reject(new Error('Workspace command cancelled when the session closed.')) };
+                        addMessage({ role: 'system', content: 'Workspace session paused. The shell command is retained; use /sessions continue.' });
+                        return;
+                    }
+                    resolve(await runShellCommand(command, cwd));
+                };
+                void execute().catch(reject);
+            });
+        }
+    }), [agent, refreshWorkspace, admitWorkspace, addMessage]);
     const isRetryableError = useCallback((message) => {
         const lower = message.toLowerCase();
         return lower.includes('overloaded') || lower.includes('529') || lower.includes('429') || lower.includes('rate limit');
     }, []);
-    const runWithRetry = useCallback(async (requestMessages, runAgent, isManual = false, isActive, signal) => {
+    const runWithRetry = useCallback(async (requestMessages, runAgent, isManual = false, isActive, signal, takeSteering, promptTurn = promptTurnRef.current) => {
         const maxRetries = 3;
         let attempt = 0;
         setRetryAvailable(false);
-        while (attempt < maxRetries) {
-            attempt += 1;
-            if (isActive && !isActive())
-                return;
-            if (signal?.aborted)
-                return;
-            try {
-                streamedResponse.current = false;
-                const priorIds = new Set(requestMessages.map(message => message.id));
-                const stopCheckpoints = runAgent.on(event => {
-                    if (event.type !== 'history_checkpoint')
-                        return;
-                    const ordered = event.messages;
-                    setMessages(prev => [...prev.filter(message => priorIds.has(message.id)), ...ordered,
-                        ...prev.filter(message => !priorIds.has(message.id) && (message.role === 'system' || message.role === 'tool'))]);
-                });
-                let result;
-                try {
-                    result = await runAgent.run(requestMessages, signal);
-                }
-                finally {
-                    stopCheckpoints();
-                }
+        promptTurn?.start();
+        try {
+            while (attempt < maxRetries) {
+                attempt += 1;
                 if (isActive && !isActive())
                     return;
-                if (!streamedResponse.current) {
-                    // Only add assistant message if there's actual text content.
-                    // Tool calls are already displayed via tool_start/tool_end events.
-                    // When the model returns empty content after tool execution, don't show empty message.
-                    const hasContent = result.content && result.content.trim().length > 0;
-                    if (hasContent) {
-                        addMessage({
-                            role: 'assistant',
-                            content: result.content,
-                            toolCalls: result.turnMessages?.length ? undefined : result.toolCalls.length > 0 ? result.toolCalls : undefined,
-                            // Keep the provider's reasoning trace alongside usage: reasoning
-                            // models expect the assistant message replayed with its
-                            // reasoning_content, and dropping it here strips every later turn.
-                            metadata: (result.usage || result.reasoning)
-                                ? {
-                                    ...(result.usage ? { usage: result.usage } : {}),
-                                    ...(result.reasoning ? { reasoningContent: result.reasoning } : {}),
-                                }
-                                : undefined
+                if (signal?.aborted)
+                    return;
+                try {
+                    streamedResponse.current = false;
+                    const iterations = [];
+                    const toolIterations = new Map();
+                    const stopCheckpoints = runAgent.on(event => {
+                        if (isActive && !isActive())
+                            return;
+                        if (event.type === 'thinking_start')
+                            iterations.push({ start: messagesRef.current.length });
+                        if (event.type === 'tool_start') {
+                            const iteration = iterations.length - 1;
+                            if (iteration >= 0) {
+                                // The live listener has just painted this tool's start trace.
+                                iterations[iteration].toolStart ??= messagesRef.current.length - 1;
+                                toolIterations.set(event.toolCallId, iteration);
+                            }
+                        }
+                        if (event.type !== 'history_checkpoint')
+                            return;
+                        setMessages(live => reconcileOrderedTranscript({ live, ordered: event.messages, iterations, toolIterations }));
+                    });
+                    let result;
+                    try {
+                        result = await runAgent.run(requestMessages, signal, takeSteering, undefined, undefined, promptTurn?.observe);
+                    }
+                    finally {
+                        stopCheckpoints();
+                    }
+                    if (isActive && !isActive())
+                        return;
+                    if (!streamedResponse.current) {
+                        // Only add assistant message if there's actual text content.
+                        // Tool calls are already displayed via tool_start/tool_end events.
+                        // When the model returns empty content after tool execution, don't show empty message.
+                        const hasContent = result.content && result.content.trim().length > 0;
+                        if (hasContent) {
+                            addMessage({
+                                role: 'assistant',
+                                content: result.content,
+                                ...(result.nativeContent ? { nativeContent: result.nativeContent, nativeModel: result.nativeModel, nativeContextId: result.nativeContextId } : {}),
+                                toolCalls: result.turnMessages?.length ? undefined : result.toolCalls.length > 0 ? result.toolCalls : undefined,
+                                // Keep the provider's reasoning trace alongside usage: reasoning
+                                // models expect the assistant message replayed with its
+                                // reasoning_content, and dropping it here strips every later turn.
+                                metadata: (result.usage || result.reasoning)
+                                    ? {
+                                        ...(result.usage ? { usage: result.usage } : {}),
+                                        ...(result.reasoning ? { reasoningContent: result.reasoning } : {}),
+                                    }
+                                    : undefined
+                            });
+                        }
+                    }
+                    else if (result.reasoning || result.nativeContent) {
+                        // A streamed turn already put its assistant message in state, so the
+                        // reasoning trace has to be attached after the fact. Without this,
+                        // only buffered replies keep it and streamed turns — the common case —
+                        // replay a stripped history.
+                        setMessages(prev => {
+                            const lastIdx = prev.reduce((last, m, i) => (isPersistableAssistantMessage(m) ? i : last), -1);
+                            if (lastIdx < 0)
+                                return prev;
+                            return prev.map((m, i) => i === lastIdx
+                                ? { ...m, ...(result.nativeContent ? { nativeContent: result.nativeContent, nativeModel: result.nativeModel, nativeContextId: result.nativeContextId } : {}),
+                                    metadata: { ...m.metadata, ...(result.reasoning ? { reasoningContent: result.reasoning } : {}) } }
+                                : m);
                         });
                     }
+                    // Idle publication can synchronously flush queued work. Retire the
+                    // completed owner's confirmation before publishing that transition.
+                    if (abortControllerRef.current?.signal === signal) {
+                        abortControllerRef.current = null;
+                        resetEscapeStop();
+                    }
+                    setAgentState(s => ({
+                        status: 'idle',
+                        tokensUsed: result.usage?.totalTokens || 0,
+                        // Carry the PER-CALL context the last token_usage event set; do NOT use
+                        // result.usage.inputTokens — it is the cumulative cross-iteration sum
+                        // (mergeUsage) and would inflate the bar. (currentTool/error/startedAt
+                        // are intentionally dropped on idle, as before.)
+                        contextTokens: s.contextTokens,
+                        contextWindow: s.contextWindow,
+                        cacheInputTokens: s.cacheInputTokens,
+                        cachedInputTokens: s.cachedInputTokens,
+                        tokensEstimated: s.tokensEstimated,
+                        authError: false
+                    }));
+                    return;
                 }
-                else if (result.reasoning) {
-                    // A streamed turn already put its assistant message in state, so the
-                    // reasoning trace has to be attached after the fact. Without this,
-                    // only buffered replies keep it and streamed turns — the common case —
-                    // replay a stripped history.
-                    setMessages(prev => {
-                        const lastIdx = prev.reduce((last, m, i) => (isPersistableAssistantMessage(m) ? i : last), -1);
-                        if (lastIdx < 0)
-                            return prev;
-                        return prev.map((m, i) => i === lastIdx
-                            ? { ...m, metadata: { ...m.metadata, reasoningContent: result.reasoning } }
-                            : m);
+                catch (err) {
+                    const errorMsg = err.message || 'Agent error';
+                    if ((err instanceof AgentError && err.code === 'CANCELLED') || signal?.aborted)
+                        return;
+                    if (isActive && !isActive())
+                        return;
+                    if (!isRetryableError(errorMsg) || attempt >= maxRetries) {
+                        throw err;
+                    }
+                    const delayMs = 500 * Math.pow(2, attempt - 1);
+                    addMessage({
+                        role: 'system',
+                        content: `Overloaded. Retrying in ${Math.round(delayMs / 100) / 10}s... (attempt ${attempt + 1}/${maxRetries})`
                     });
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
                 }
-                setAgentState(s => ({
-                    status: 'idle',
-                    tokensUsed: result.usage?.totalTokens || 0,
-                    // Carry the PER-CALL context the last token_usage event set; do NOT use
-                    // result.usage.inputTokens — it is the cumulative cross-iteration sum
-                    // (mergeUsage) and would inflate the bar. (currentTool/error/startedAt
-                    // are intentionally dropped on idle, as before.)
-                    contextTokens: s.contextTokens,
-                    contextWindow: s.contextWindow,
-                    cacheInputTokens: s.cacheInputTokens,
-                    cachedInputTokens: s.cachedInputTokens,
-                    tokensEstimated: s.tokensEstimated,
-                    authError: false
-                }));
-                return;
-            }
-            catch (err) {
-                const errorMsg = err.message || 'Agent error';
-                if ((err instanceof AgentError && err.code === 'CANCELLED') || signal?.aborted)
-                    return;
-                if (isActive && !isActive())
-                    return;
-                if (!isRetryableError(errorMsg) || attempt >= maxRetries) {
-                    throw err;
-                }
-                const delayMs = 500 * Math.pow(2, attempt - 1);
-                addMessage({
-                    role: 'system',
-                    content: `Overloaded. Retrying in ${Math.round(delayMs / 100) / 10}s... (attempt ${attempt + 1}/${maxRetries})`
-                });
-                await new Promise(resolve => setTimeout(resolve, delayMs));
             }
         }
-    }, [addMessage, isRetryableError, setAgentState]);
+        finally {
+            promptTurn?.finish();
+        }
+    }, [addMessage, isRetryableError, resetEscapeStop, setAgentState]);
     const retryLast = useCallback(() => {
         const last = lastRequestRef.current;
         if (!last) {
             addMessage({ role: 'system', content: 'No previous request to retry.' });
             return;
         }
-        const runId = `${Date.now()}_${runCounterRef.current++}`;
-        activeRunIdRef.current = runId;
-        const isActive = () => activeRunIdRef.current === runId;
-        const retryController = new AbortController();
-        abortControllerRef.current = retryController;
-        void runWithRetry(last.messages, last.agent, true, isActive, retryController.signal).catch((err) => {
-            const message = err.message || 'Agent error';
-            if (!isActive())
+        const replay = async () => {
+            const cwd = last.agent.getCwd();
+            const admission = await admitWorkspace(undefined, cwd);
+            if (workspaceClosedRef.current)
+                return;
+            if (!admission.allowed) {
+                if (!pausedWorkspaceOperationRef.current)
+                    pausedWorkspaceOperationRef.current = {
+                        kind: 'retry', cwd, fingerprint: admission.snapshot.fingerprint, resume: replay, cancel: () => { },
+                    };
+                addMessage({ role: 'system', content: 'Workspace session paused. The original retry request is retained; use /sessions continue.' });
                 return;
-            addMessage({ role: 'system', content: `Error: ${message}` });
-            if (isRetryableError(message)) {
-                addMessage({ role: 'system', content: 'Retries exhausted. Use /retry to try again.' });
-                setRetryAvailable(true);
             }
-            setAgentState({ status: 'error', error: message });
-        }).finally(() => {
-            if (abortControllerRef.current === retryController)
-                abortControllerRef.current = null;
+            const runId = `${Date.now()}_${runCounterRef.current++}`;
+            flushReadingDisplay();
+            activeRunIdRef.current = runId;
+            resetAskUserTurnFlag();
+            const isActive = () => activeRunIdRef.current === runId;
+            const retryController = new AbortController();
+            resetEscapeStop();
+            queuePausedRef.current = false;
+            abortControllerRef.current = retryController;
+            await workspaceCoordinator.setActivity('running');
+            try {
+                await runWithRetry(last.messages, last.agent, true, isActive, retryController.signal);
+            }
+            catch (err) {
+                const message = err.message || 'Agent error';
+                if (!isActive())
+                    return;
+                addMessage({ role: 'system', content: `Error: ${message}` });
+                if (isRetryableError(message)) {
+                    addMessage({ role: 'system', content: 'Retries exhausted. Use /retry to try again.' });
+                    setRetryAvailable(true);
+                }
+                setAgentState({ status: 'error', error: message });
+            }
+            finally {
+                if (abortControllerRef.current === retryController) {
+                    abortControllerRef.current = null;
+                    resetEscapeStop();
+                }
+                if (isActive() && !workspaceClosedRef.current && !workspacePausedRef.current)
+                    await workspaceCoordinator.setActivity('idle');
+                if (isActive()) {
+                    activeRunIdRef.current = null;
+                    presentAgentQuestion(runId);
+                }
+            }
+        };
+        void replay().catch(error => {
+            if (!workspaceClosedRef.current)
+                addMessage({ role: 'system', content: `Unable to retry: ${error instanceof Error ? error.message : String(error)}` });
         });
-    }, [addMessage, isRetryableError, runWithRetry, setAgentState]);
+    }, [addMessage, isRetryableError, resetEscapeStop, runWithRetry, setAgentState, admitWorkspace, workspaceCoordinator, flushReadingDisplay, presentAgentQuestion]);
     // Prompt controller for interactive commands
     const promptController = useMemo(() => ({
-        prompt: (message, callback) => {
-            pendingPromptRef.current = { message, callback, isPassword: false };
+        prompt: (message, callback, options) => {
+            retireRouting();
+            pendingPromptRef.current = { message, callback, isPassword: false, allowEmptySubmit: options?.allowEmptySubmit };
             addMessage({ role: 'system', content: message });
         },
         promptPassword: (message, callback) => {
+            retireRouting();
             pendingPromptRef.current = { message, callback, isPassword: true };
             addMessage({ role: 'system', content: message });
         },
         hasPending: () => pendingPromptRef.current !== null,
         getPending: () => pendingPromptRef.current,
-        clearPending: () => { pendingPromptRef.current = null; },
-    }), [addMessage]);
+        clearPending: () => {
+            const passwordDismissed = pendingPromptRef.current?.isPassword === true;
+            pendingPromptRef.current = null;
+            if (passwordDismissed)
+                setClearDraftVersion(version => version + 1);
+        },
+    }), [addMessage, retireRouting]);
     // Form controller for inline form widgets
     const formController = useMemo(() => ({
         showForm: (options, callback) => {
+            retireRouting();
             const formId = generateId();
             formCallbacksRef.current.set(formId, callback);
             setMessages(prev => [...prev, {
@@ -676,7 +1427,7 @@ export const App = () => {
         cancelForm: (formId) => {
             formCallbacksRef.current.delete(formId);
         }
-    }), []);
+    }), [retireRouting, setMessages]);
     // Handle form submission from FormWidget
     const handleFormSubmit = useCallback(async (formId, values) => {
         const callback = formCallbacksRef.current.get(formId);
@@ -700,19 +1451,44 @@ export const App = () => {
     const appContext = useMemo(() => ({
         addMessage,
         clearMessages,
+        getEvidenceSnapshot: () => agent?.getEvidenceSnapshot(),
+        getDiagnostics: () => {
+            const snapshot = captureSessionDiagnosticSnapshot({ messages: messagesRef.current, diagnostics: agent?.getDiagnosticSnapshot() });
+            agent?.restoreDiagnosticSnapshot(snapshot);
+            return snapshot;
+        },
+        clearTransientState: () => {
+            agent?.clearPinnedTask();
+            if (agent) {
+                agent.toolResponseStore.evidence.clear();
+                const snapshot = agent.getEvidenceSnapshot();
+                setAgentState(previous => applyAgentEventToState(previous, { type: 'evidence', sessionId: previous.evidence?.sessionId ?? sessionId, snapshot }));
+            }
+        },
         getMessages,
         setMessages,
         setAgentState,
         reloadAgent,
+        applyAccountOperation,
+        getUsageSnapshot,
         setDebug,
         retry: retryLast,
         exit,
+        getSessionId: () => sessionId,
+        getSessionName: () => sessionName,
+        setSessionName,
+        setPaneLabels: async (labels) => { setSessionName(labels.manual_title); },
         config: configStore,
         emulation: {
             list: loadEmulationProfiles,
             get: getEmulationProfile
         },
         shell: shellController,
+        workspace: {
+            getSnapshot: refreshWorkspace,
+            continue: continueWorkspace,
+            isolate: async () => { await isolateWorkspace(); },
+        },
         clipboard: {
             writeText: writeClipboard
         },
@@ -745,11 +1521,21 @@ export const App = () => {
             cancelSelect: () => { },
         },
         questionnaire: {
-            showQuestionnaire: () => { },
-            cancelQuestionnaire: () => { },
+            showQuestionnaire: (options, callback) => {
+                retireRouting();
+                // Ink subscribers share the current key dispatch; the opening Enter belongs to the composer.
+                questionnaireInputReadyRef.current = false;
+                questionnaireWidget.show({ ...options, callback });
+                queueMicrotask(() => { questionnaireInputReadyRef.current = true; });
+            },
+            cancelQuestionnaire: () => {
+                questionnaireInputReadyRef.current = false;
+                questionnaireWidget.cancel();
+                renderQuestionnaireWidget(version => version + 1);
+            },
         },
         getInputMode: () => inputMode,
-        setInputMode: (mode) => setInputMode(mode),
+        setInputMode: (mode) => setInputMode(normalizeInputMode(mode)),
         triggerAgentTurn: () => { },
         // Authoritative context getters for /context + /compact: the real per-call
         // provider count + window (read live via the ref so commands never see a
@@ -763,10 +1549,15 @@ export const App = () => {
             cacheInputTokens: undefined, cachedInputTokens: undefined,
         })),
         model: configStore.get().model
-    }), [addMessage, clearMessages, getMessages, setMessages, reloadAgent, exit, shellController, retryLast, inputMode, promptController, formController]);
+    }), [addMessage, clearMessages, getMessages, setMessages, reloadAgent, exit, shellController, retryLast, inputMode, promptController, formController, questionnaireWidget, retireRouting, agent, sessionId, sessionName, setAgentState, refreshWorkspace, continueWorkspace, isolateWorkspace]);
     // Handle commands
     const handleCommand = useCallback((cmd, args) => {
         const normalizedCommand = cmd.toLowerCase();
+        if (normalizedCommand === 'model' && (runtimeMutationRef.current || abortControllerRef.current
+            || (agentStateRef.current.status !== 'idle' && agentStateRef.current.status !== 'error'))) {
+            addMessage({ role: 'system', content: 'Cannot switch model while an active agent turn or account change is running.' });
+            return;
+        }
         let resolvedPlanMode = false;
         if (normalizedCommand === 'mode' && args[0]) {
             try {
@@ -804,13 +1595,93 @@ export const App = () => {
             });
         }
     }, [appContext, addMessage]);
+    const routeBusyInput = useCallback((text, draft) => {
+        if (routingDraftsRef.current.size + queueRef.current.length >= MAX_QUEUE) {
+            showToastRef.current?.(`Queue full (${MAX_QUEUE}). Cancel or wait.`);
+            // InputArea clears after this callback, so restoration waits for that
+            // submission's empty-composer revision.
+            queueMicrotask(() => draft?.restore());
+            return Promise.resolve();
+        }
+        const submitted = { id: generateId(), text, queuedAt: new Date(), delivery: 'subturn' };
+        const epoch = routingEpochRef.current;
+        const controller = new AbortController();
+        const config = structuredClone(configStore.get());
+        const backendOptions = { config, provider: configStore.getProvider(), model: configStore.getModel(),
+            openaiCompatibleBaseUrl: configStore.getOpenAICompatibleBaseUrl(), emulationId: configStore.getEmulationId(),
+            mode: agentMode, cwd: shellCwdRef.current, sessionId, allowSelfPlanTransition: false };
+        const currentTask = lastRequestRef.current?.messages.filter(message => message.role === 'user'
+            && !message.metadata?.toolResult).at(-1)?.content ?? text;
+        getUsageSnapshot();
+        const routingUsage = retainedUsageRef.current;
+        routingControllersRef.current.set(submitted.id, controller);
+        routingDraftsRef.current.set(submitted.id, draft);
+        const owns = () => routingEpochRef.current === epoch && !controller.signal.aborted;
+        // Serial decisions preserve submission FIFO even when a parent completes
+        // or the first decision needs an explicit choice.
+        const routed = routingTailRef.current.then(async () => {
+            if (!owns())
+                return;
+            const decision = await classifyBusyInput({ backendOptions, currentTask, inputText: text,
+                hosted: false, signal: controller.signal, onUsage: receipt => {
+                    routingUsage.snapshot = recordUsageReceipt(routingUsage.snapshot, receipt);
+                    if (sessionIdRef.current === receipt.sessionId)
+                        setRoutingUsageRevision(revision => revision + 1);
+                } });
+            if (!owns())
+                return;
+            if (pendingPromptRef.current || formCallbacksRef.current.size > 0 || questionnaireWidget.isActive()) {
+                draft?.restore();
+                return;
+            }
+            if (decision.route === 'divergent') {
+                const choice = await new Promise(resolve => {
+                    routingChoiceCancelRef.current = () => resolve(null);
+                    scopeWidget.show({ title: 'Separate task', question: 'This input appears to start different work.', type: 'select',
+                        options: [{ value: 'pane', label: 'New pane' }, { value: 'session', label: 'New session' },
+                            { value: 'steer', label: 'Steer anyway' }, { value: 'cancel', label: 'Cancel' }],
+                        callback: value => { routingChoiceCancelRef.current = null; resolve(typeof value === 'string' ? value : null); } });
+                });
+                if (!owns())
+                    return;
+                if (choice !== 'steer') {
+                    if (choice === 'pane' || choice === 'session')
+                        addMessage({ role: 'system', content: `The Ink renderer cannot open a ${choice === 'pane' ? 'new pane' : 'new session'}. Use the Ratatui renderer (run ./scripts/build-rust.sh), or start a separate ZTC terminal. Your unsent draft is retained.` });
+                    const restored = draft?.restore();
+                    if (draft && !restored)
+                        addMessage({ role: 'system', content: 'Your newer composer draft was kept. The earlier separate-task input was not sent.' });
+                    return;
+                }
+            }
+            if (enqueueMessage(text, 'subturn', submitted) === null)
+                draft?.restore();
+            else
+                showToastRef.current?.('Steering current task · Sending after the current tool finishes');
+        }).catch(error => {
+            if (!owns())
+                return;
+            draft?.restore();
+            addMessage({ role: 'system', content: `Unable to route this input: ${error instanceof Error ? error.message : String(error)}` });
+        }).finally(() => {
+            routingControllersRef.current.delete(submitted.id);
+            routingDraftsRef.current.delete(submitted.id);
+        });
+        routingTailRef.current = routed;
+        return routed;
+    }, [addMessage, agentMode, enqueueMessage, scopeWidget, questionnaireWidget, getUsageSnapshot, sessionId]);
     // Handle message submission
-    const handleSubmit = useCallback(async (text) => {
+    const handleSubmit = useCallback(async (text, draft, queuedEntry, askUserAnswer = false) => {
         // Reject empty / whitespace-only prompts before any downstream work.
         // Interactive pending prompts (password, etc.) may legitimately want
         // blank input, so bypass this check when one is pending.
         if (!pendingPromptRef.current && !isMeaningfulUserInput(text))
             return;
+        if (runtimeMutationRef.current && !pendingPromptRef.current) {
+            const position = enqueueMessage(text, 'end-of-turn');
+            addMessage({ role: 'system', content: position === null ? 'Account change in progress; the queue is full. Retry when it finishes.'
+                    : 'Account change in progress; input retained in the queue.' });
+            return;
+        }
         // Check for pending prompts first (interactive command flow)
         const pending = pendingPromptRef.current;
         if (pending) {
@@ -831,7 +1702,7 @@ export const App = () => {
             }
             return;
         }
-        if (text.startsWith('!')) {
+        if (!askUserAnswer && text.startsWith('!')) {
             const commandText = text.slice(1).trim();
             if (commandText) {
                 // Intercept 'cd' commands to use the proper /cd handler that persists
@@ -855,22 +1726,48 @@ export const App = () => {
             });
             return;
         }
-        const busy = agentState.status !== 'idle' && agentState.status !== 'error';
+        const admission = await admitWorkspace();
+        if (!admission.allowed) {
+            if (!workspaceClosedRef.current) {
+                if (!pausedWorkspaceInputRef.current)
+                    pausedWorkspaceInputRef.current = {
+                        text, draft, queuedEntry, askUserAnswer, fingerprint: admission.snapshot.fingerprint,
+                    };
+                if (admission.isolate && await isolateWorkspace())
+                    return;
+                draft?.restore();
+                addMessage({ role: 'system', content: 'Workspace session paused. Input and queued work retained; use /sessions continue.' });
+            }
+            return;
+        }
+        const busy = abortControllerRef.current !== null
+            || (agentStateRef.current.status !== 'idle' && agentStateRef.current.status !== 'error');
+        flushReadingDisplay();
+        if ((busy || routingDraftsRef.current.size > 0) && inputMode === 'steer' && !queuedEntry) {
+            await routeBusyInput(text, draft);
+            return;
+        }
         if (busy) {
-            if (inputMode === 'queue') {
-                const nextSize = enqueueMessage(text);
+            if (inputMode === 'steer') {
+                const nextSize = enqueueMessage(text, 'subturn');
                 if (nextSize !== null) {
-                    // Durable audit alongside the live queue panel.
-                    addMessage({ role: 'system', content: `Queued (${nextSize})` });
+                    showToastRef.current?.('Steering current task · Sending after the current tool finishes');
                 }
                 return;
             }
+            // Retire the prior event owner before aborting it, so late output and
+            // checkpoints cannot overwrite the replacement turn.
+            cancelGeneration();
             addMessage({
                 role: 'system',
                 content: 'Interrupting current response...'
             });
         }
-        let currentAgent = agent;
+        // Agent events do not carry a run owner. An aborted HTTP body can finish
+        // after its run promise settles, so a replacement must not subscribe to
+        // that retired Agent's emitter.
+        const liveAgent = diagnosticAgentRef.current;
+        let currentAgent = liveAgent && !retiredAgentsRef.current.has(liveAgent) ? liveAgent : null;
         if (skills.length > 0) {
             const activated = autoActivateSkills(text, skills);
             const ids = activated.map(skill => skill.id).sort();
@@ -880,15 +1777,7 @@ export const App = () => {
                 activeSkillIds.current = ids;
                 const prompt = buildSkillPrompt(activated);
                 // Let the resolver apply config-key precedence (no env-first getApiKey()).
-                const nextAgent = createAgentFromConfig({
-                    config: configStore.get(),
-                    provider: configStore.getProvider(),
-                    model: configStore.getModel(),
-                    openaiCompatibleBaseUrl: configStore.getOpenAICompatibleBaseUrl(),
-                    emulationId: configStore.getEmulationId(),
-                    skillPrompt: prompt,
-                    allowSelfPlanTransition: false,
-                });
+                const nextAgent = createBoundAgent(agentMode, prompt);
                 if (nextAgent) {
                     setAgent(nextAgent);
                     currentAgent = nextAgent;
@@ -902,7 +1791,7 @@ export const App = () => {
             }
         }
         if (!currentAgent) {
-            currentAgent = createAgent();
+            currentAgent = createBoundAgent(agentMode, buildSkillPrompt(skills.filter(skill => activeSkillIds.current.includes(skill.id))));
             setAgent(currentAgent);
         }
         if (!currentAgent) {
@@ -913,18 +1802,28 @@ export const App = () => {
             return;
         }
         const userMsg = {
-            id: generateId(),
+            id: queuedEntry?.id ?? generateId(),
             role: 'user',
             content: text,
-            timestamp: new Date()
+            timestamp: queuedEntry?.queuedAt ?? new Date(),
+            ...(askUserAnswer ? { metadata: { isAskUserAnswer: true } } : {}),
         };
-        setMessages(prev => [...prev, userMsg]);
         const requestMessages = [...messagesRef.current, userMsg];
-        lastRequestRef.current = { messages: requestMessages, agent: currentAgent };
+        setMessages(prev => [...prev, userMsg]);
+        const promptTurn = new PromptTurn(userMsg.id, () => {
+            const snapshot = promptTurn.snapshot();
+            setMessages(prev => prev.map(message => message.turn?.id === snapshot.id ? { ...message, turn: snapshot } : message));
+        });
+        promptTurnRef.current = promptTurn;
+        lastRequestRef.current = { messages: requestMessages, agent: currentAgent, turn: promptTurn };
         const runId = `${Date.now()}_${runCounterRef.current++}`;
         activeRunIdRef.current = runId;
+        resetAskUserTurnFlag();
         const controller = new AbortController();
+        resetEscapeStop();
+        queuePausedRef.current = false;
         abortControllerRef.current = controller;
+        await workspaceCoordinator.setActivity('running');
         const isActive = () => activeRunIdRef.current === runId;
         const runStartedAt = Date.now();
         streamingMessageId.current = null;
@@ -933,6 +1832,12 @@ export const App = () => {
             if (!isActive())
                 return;
             switch (event.type) {
+                case 'evidence':
+                    setAgentState(previous => applyAgentEventToState(previous, event));
+                    break;
+                case 'command_wait':
+                case 'command_wait_end':
+                case 'tool_progress':
                 case 'thinking_start':
                     setAgentState(s => applyAgentEventToState(s, event));
                     break;
@@ -954,13 +1859,17 @@ export const App = () => {
                     setAgentState(s => applyAgentEventToState(s, event));
                     if (!streamingMessageId.current) {
                         const id = generateId();
+                        // Register the owned stream before React can batch its completion
+                        // into the same paint. Historical settled messages are never typed.
+                        readingStatesRef.current.set(id, { ...initialStreamTypewriterState(), messageId: id });
                         streamingMessageId.current = id;
                         setMessages(prev => [...prev, {
                                 id,
                                 role: 'assistant',
                                 content: '',
                                 timestamp: new Date(),
-                                isStreaming: true
+                                isStreaming: true,
+                                turn: promptTurn.snapshot(),
                             }]);
                     }
                     break;
@@ -983,6 +1892,7 @@ export const App = () => {
                     });
                     break;
                 case 'stream_end':
+                    setAgentState(s => applyAgentEventToState(s, event));
                     if (streamingMessageId.current) {
                         // Get the streaming message to speak it
                         const streamingMsgId = streamingMessageId.current;
@@ -1007,6 +1917,7 @@ export const App = () => {
                     streamingMessageId.current = null;
                     break;
                 case 'tool_end': {
+                    setAgentState(s => applyAgentEventToState(s, event));
                     const key = event.tool;
                     const bucket = toolStartTimes.current.get(key) || [];
                     const started = bucket.shift();
@@ -1024,6 +1935,7 @@ export const App = () => {
                     break;
                 }
                 case 'tool_error': {
+                    setAgentState(s => applyAgentEventToState(s, event));
                     addMessage({
                         role: 'tool',
                         content: formatToolError(event.tool, event.error, configStore.getEmulationId())
@@ -1047,9 +1959,10 @@ export const App = () => {
                     }));
                     break;
                 case 'api_retry':
+                    setAgentState(s => applyAgentEventToState(s, event));
                     addMessage({
                         role: 'system',
-                        content: `⚠️ ${event.reason}. Retrying in ${event.delay / 1000}s... (attempt ${event.attempt}/${event.maxAttempts})`
+                        content: formatApiRetryNotice(event)
                     });
                     break;
                 case 'error':
@@ -1058,7 +1971,17 @@ export const App = () => {
             }
         });
         try {
-            await runWithRetry(requestMessages, currentAgent, false, isActive, controller.signal);
+            await runWithRetry(requestMessages, currentAgent, false, isActive, controller.signal, () => {
+                if (!isActive())
+                    return [];
+                const pending = queueRef.current.filter(entry => entry.delivery === 'subturn');
+                queueRef.current = queueRef.current.filter(entry => entry.delivery !== 'subturn');
+                setQueue(queueRef.current);
+                // These messages become visible through the real history checkpoint
+                // when the Agent admits them after the completed tool result.
+                return pending.map(entry => ({ id: entry.id, role: 'user', content: entry.text,
+                    timestamp: entry.queuedAt, attachments: entry.attachments, metadata: { steering: true } }));
+            }, promptTurn);
         }
         catch (err) {
             if ((err instanceof AgentError && err.code === 'CANCELLED') || controller.signal.aborted)
@@ -1098,6 +2021,7 @@ export const App = () => {
                 activeRunIdRef.current = null;
                 abortControllerRef.current = null;
                 lastRunDurationRef.current = Date.now() - runStartedAt;
+                resetEscapeStop();
                 if (getTraceStyle(configStore.getEmulationId()) === 'codex') {
                     const seconds = Math.max(0, Math.round((lastRunDurationRef.current || 0) / 1000));
                     addMessage({
@@ -1106,6 +2030,9 @@ export const App = () => {
                     });
                 }
                 cleanup();
+                if (!workspaceClosedRef.current && !workspacePausedRef.current)
+                    await workspaceCoordinator.setActivity('idle');
+                presentAgentQuestion(runId);
                 // Queue flushing is handled by the flush-on-idle effect below; shifting
                 // here would strand the queue on cancel/error paths.
             }
@@ -1113,7 +2040,8 @@ export const App = () => {
                 cleanup();
             }
         }
-    }, [agent, agentState.status, addMessage, handleCommand, enqueueMessage, inputMode, isRetryableError, runWithRetry]);
+    }, [agent, agentMode, skills, agentState.status, addMessage, handleCommand, enqueueMessage, inputMode, isRetryableError, runWithRetry, cancelGeneration, resetEscapeStop, routeBusyInput, admitWorkspace, workspaceFactoryOptions, createBoundAgent, workspaceCoordinator, isolateWorkspace, flushReadingDisplay, presentAgentQuestion]);
+    workspaceSubmitRef.current = handleSubmit;
     // Flush-on-idle: one dequeue per idle-edge, uniform across cancel/error.
     // Latch is set BEFORE dequeue because setQueue's notify is synchronous —
     // otherwise this effect would re-enter itself and dequeue twice.
@@ -1125,35 +2053,41 @@ export const App = () => {
         // must still be sent when the run is configured to interrupt on Enter.
         if (agentState.status !== 'idle')
             return;
+        if (abortControllerRef.current !== null)
+            return;
+        if (queuePausedRef.current || workspacePausedRef.current || agentQuestionRef.current || pendingPromptRef.current || formCallbacksRef.current.size > 0 || questionnaireWidget.isActive() || scopeWidget.isActive() || workspaceWidget.isActive())
+            return;
         if (prevStatus === 'idle' && queue.length === 0)
             return;
         if (queue.length === 0)
             return;
         if (flushingRef.current)
             return;
-        // End-of-turn entries only; a `subturn` entry still waiting here is started
-        // by its own fallback path, so taking it here would send it twice.
-        const ready = queueRef.current.find(entry => entry.delivery !== 'subturn');
-        if (!ready)
-            return;
         flushingRef.current = true;
+        setFlushing(true);
         const next = dequeueMessage();
         if (!next) {
             flushingRef.current = false;
+            setFlushing(false);
             return;
         }
-        void handleSubmit(next.text).finally(() => {
+        void handleSubmit(next.text, undefined, next).finally(() => {
             flushingRef.current = false;
+            setFlushing(false);
         });
-    }, [agentState.status, queue.length, dequeueMessage, handleSubmit]);
-    const showToast = useCallback((message) => {
+    }, [agentState.status, queue.length, flushing, dequeueMessage, handleSubmit, scopeWidget, workspaceWidget, questionnaireWidget, questionnaireVersion, workspaceResumeVersion]);
+    const showToast = useCallback((message, durationMs = DEFAULT_TOAST_MS) => {
         setToast(message);
         if (toastTimerRef.current) {
             clearTimeout(toastTimerRef.current);
         }
-        toastTimerRef.current = setTimeout(() => {
+        const timer = setTimeout(() => {
+            if (toastTimerRef.current !== timer)
+                return;
+            toastTimerRef.current = null;
             setToast(null);
-        }, DEFAULT_TOAST_MS);
+        }, durationMs);
+        toastTimerRef.current = timer;
     }, []);
     // Wire showToast into the ref so enqueue (which is declared before showToast)
     // can surface "Queue full" notices without creating a dependency cycle.
@@ -1170,7 +2104,7 @@ export const App = () => {
             if (skippedPlan)
                 next = getNextMode(next);
             setAgentMode(next);
-            setAgent(createAgent(next));
+            setAgent(createBoundAgent(next));
             const label = getModeConfig(next).label;
             // The status line's mode field already reads out the active mode, so this
             // fallback only speaks up when it had to skip Plan.
@@ -1181,7 +2115,7 @@ export const App = () => {
         catch (error) {
             showToast(error instanceof Error ? error.message : String(error));
         }
-    }, [agentMode, showToast]);
+    }, [agentMode, showToast, createBoundAgent]);
     const handleDictationStateChange = useCallback((state) => {
         setIsRecording(state === 'recording');
         setIsTranscribing(state === 'transcribing');
@@ -1225,29 +2159,92 @@ export const App = () => {
         });
         return cleanup;
     }, [useNativeDictation, showToast]);
+    // Reveal is a display projection; canonical messages and provider/session
+    // history always retain the full received body and its actual completion.
+    const { displayMessages, readingPending } = useMemo(() => {
+        if (readingSessionRef.current !== sessionId) {
+            readingStatesRef.current.clear();
+            bypassedReadingIdsRef.current.clear();
+            readingSessionRef.current = sessionId;
+        }
+        const ids = new Set(messages.map(message => message.id));
+        for (const id of readingStatesRef.current.keys())
+            if (!ids.has(id))
+                readingStatesRef.current.delete(id);
+        for (const id of bypassedReadingIdsRef.current)
+            if (!ids.has(id))
+                bypassedReadingIdsRef.current.delete(id);
+        let pending = false;
+        const shown = messages.map(message => {
+            const eligible = message.role === 'assistant' && message.metadata?.reasoning !== true
+                && message.metadata?.toolResult !== true && !message.metadata?.toolOutput
+                && !message.toolCalls?.length && !message.widget;
+            const previous = readingStatesRef.current.get(message.id);
+            if (!eligible || bypassedReadingIdsRef.current.has(message.id)
+                || (!message.isStreaming && !previous))
+                return message;
+            const plan = planStreamTypewriterSample(previous ?? initialStreamTypewriterState(), message, {
+                enabled: messageDisplay.smoothStreaming || messageDisplay.proseReadingRateWordsPerSecond !== null,
+                now: Date.now(), proseReadingRateWordsPerSecond: messageDisplay.proseReadingRateWordsPerSecond,
+            });
+            readingStatesRef.current.set(message.id, plan.nextState);
+            pending ||= plan.pending;
+            return plan.content === message.content && !plan.pending ? message
+                : { ...message, content: plan.content, isStreaming: message.isStreaming || plan.pending };
+        });
+        return { displayMessages: shown, readingPending: pending };
+    }, [messages, sessionId, messageDisplay.smoothStreaming, messageDisplay.proseReadingRateWordsPerSecond, readingTick]);
+    React.useEffect(() => {
+        if (!readingPending)
+            return;
+        const timer = setTimeout(() => refreshReadingDisplay(tick => tick + 1), STREAM_TYPEWRITER_DEFAULTS.tickMs);
+        return () => clearTimeout(timer);
+    }, [readingPending, readingTick, messages, messageDisplay.smoothStreaming, messageDisplay.proseReadingRateWordsPerSecond]);
     // Compute messages for Static (completed) vs live (streaming/interactive)
-    // Static component handles deduplication by key - it only renders new items
-    const { staticMessages, streamingMessage, formMessages } = useMemo(() => {
+    // Static renders only items past its retained index. Explicit clear starts a
+    // new component generation so the shorter transcript is rendered from zero.
+    const { staticMessages, liveTurnMessages, formMessages } = useMemo(() => {
         // Form widget messages are always computed (need interactivity)
         const forms = messages.filter(m => m.widget?.widgetType === 'form');
         if (!scrollback) {
-            return { staticMessages: [], streamingMessage: null, formMessages: forms };
+            return { staticMessages: [], liveTurnMessages: [], formMessages: forms };
         }
         // Completed messages without widgets go to Static (rendered once, kept in scrollback)
-        const completed = messages.filter(m => !m.isStreaming
+        const completed = displayMessages.filter(m => !m.isStreaming
+            && !(messageDisplay.showTurnMetadata && m.turn && m.turn.finishedAt === undefined)
             && !m.widget
             && (messageDisplay.showThinking || m.metadata?.reasoning !== true));
         // Streaming message stays in live section (can update)
-        const streaming = messages.find(m => m.isStreaming
-            && (messageDisplay.showThinking || m.metadata?.reasoning !== true)) || null;
+        const streaming = displayMessages.filter(m => (m.isStreaming || (messageDisplay.showTurnMetadata && m.turn && m.turn.finishedAt === undefined))
+            && (messageDisplay.showThinking || m.metadata?.reasoning !== true));
         return {
             staticMessages: completed,
-            streamingMessage: streaming,
+            liveTurnMessages: streaming,
             formMessages: forms
         };
-    }, [messages, scrollback, messageDisplay.showThinking]);
-    return (_jsxs(FullScreen, { debug: debug, scrollback: scrollback, children: [!scrollback && _jsx(Header, { version: getVersion(), debug: debug, renderer: "ink" }), scrollback ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticMessages, children: (msg) => (_jsx(Box, { flexDirection: "column", children: _jsx(SingleMessage, { message: msg, expandToolOutputs: expandToolOutputs }) }, msg.id)) }), streamingMessage && (_jsx(SingleMessage, { message: streamingMessage, expandToolOutputs: expandToolOutputs }))] })) : (_jsx(MessageList, { messages: messages, height: contentHeight, debug: debug, expandToolOutputs: expandToolOutputs, scrollback: scrollback, showThinking: messageDisplay.showThinking })), _jsx(ActivityLine, { state: agentState, spinnerLabel: spinnerLabel, spinnerFrame: spinnerFrame, inputMode: inputMode, scrollback: scrollback }), _jsx(QueuePanel, { entries: queuePreview, total: queue.length, cols: columns }), isRecording && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", children: "\u25CF Recording" }), recordingDevice && (_jsxs(Text, { color: "gray", children: [" [", recordingDevice, "]"] })), _jsx(Text, { color: "gray", children: " " }), _jsx(Text, { color: "cyan", children: renderVUMeter(audioLevel) }), _jsx(Text, { color: "gray", children: " \u2014 Ctrl+R to stop" })] }), partialTranscript && (_jsx(Box, { children: _jsxs(Text, { color: "gray", italic: true, children: ["\"", partialTranscript, "\""] }) }))] })), isTranscribing && !useNativeDictation && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "yellow", children: "\u280B Transcribing..." }) })), formMessages.map((msg) => (msg.widget && (_jsx(FormWidget, { title: msg.widget.title, fields: msg.widget.fields, formId: msg.widget.formId, submitLabel: msg.widget.submitLabel, onSubmit: handleFormSubmit, onCancel: handleFormCancel, isActive: true }, msg.id)))), _jsx(InputArea, { onSubmit: handleSubmit, onCommand: handleCommand, commands: commands, onStateChange: setInputSnapshot, onToast: showToast, onDictationStateChange: handleDictationStateChange, cols: columns, inputBus: inputBus, disabled: false, debug: debug, cwd: shellCwdRef.current, placeholder: (!configStore.hasApiKey() && !configStore.isAuthenticated())
+    }, [messages, displayMessages, scrollback, messageDisplay.showThinking, messageDisplay.showTurnMetadata]);
+    React.useEffect(() => {
+        if (!messageDisplay.showTurnMetadata || !messages.some(message => message.turn && message.turn.finishedAt === undefined))
+            return;
+        const timer = setInterval(() => setPromptClock(clock => clock + 1), 1000);
+        return () => clearInterval(timer);
+    }, [messages, messageDisplay.showTurnMetadata]);
+    return (_jsxs(FullScreen, { debug: debug, scrollback: scrollback, children: [!scrollback && _jsx(Header, { version: getVersion(), debug: debug, renderer: "ink" }), scrollback ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticMessages, children: (msg) => (_jsx(Box, { flexDirection: "column", children: _jsx(SingleMessage, { message: msg, expandToolOutputs: expandToolOutputs, cols: columns, showTurnMetadata: messageDisplay.showTurnMetadata }) }, msg.id)) }, transcriptGeneration), liveTurnMessages.map(message => _jsx(SingleMessage, { message: message, expandToolOutputs: expandToolOutputs, cols: columns, showTurnMetadata: messageDisplay.showTurnMetadata }, message.id))] })) : (_jsx(MessageList, { messages: displayMessages, height: contentHeight, debug: debug, expandToolOutputs: expandToolOutputs, scrollback: scrollback, showThinking: messageDisplay.showThinking, showTurnMetadata: messageDisplay.showTurnMetadata, cols: columns })), _jsx(ActivityLine, { state: agentState, spinnerLabel: spinnerLabel, spinnerFrame: spinnerFrame, inputMode: inputMode, scrollback: scrollback, cols: columns }), _jsx(QueuePanel, { entries: queuePreview, total: queue.length, cols: columns }), isRecording && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsxs(Box, { children: [_jsx(Text, { color: "red", children: "\u25CF Recording" }), recordingDevice && (_jsxs(Text, { color: "gray", children: [" [", recordingDevice, "]"] })), _jsx(Text, { color: "gray", children: " " }), _jsx(Text, { color: "cyan", children: renderVUMeter(audioLevel) }), _jsx(Text, { color: "gray", children: " \u2014 Ctrl+R to stop" })] }), partialTranscript && (_jsx(Box, { children: _jsxs(Text, { color: "gray", italic: true, children: ["\"", partialTranscript, "\""] }) }))] })), isTranscribing && !useNativeDictation && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "yellow", children: "\u280B Transcribing..." }) })), scopeWidget.isActive() && _jsx(Box, { paddingX: 1, children: _jsx(Text, { children: scopeWidget.buildContent(columns) }) }), workspaceWidget.isActive() && _jsx(Box, { paddingX: 1, flexShrink: 0, children: _jsx(Text, { children: workspaceWidget.buildContent(columns) }) }), questionnaireWidget.isActive() && _jsx(InkNode, { node: questionnaireWidget.buildSurface(columns, rows).view }), formMessages.map((msg) => (msg.widget && (_jsx(FormWidget, { title: msg.widget.title, fields: msg.widget.fields, formId: msg.widget.formId, submitLabel: msg.widget.submitLabel, onSubmit: handleFormSubmit, onCancel: handleFormCancel, isActive: formCallbacksRef.current.has(msg.widget.formId) }, msg.id)))), _jsx(InputArea, { onCancelRun: () => {
+                    const routing = routingControllersRef.current.size > 0;
+                    retireRouting();
+                    return cancelGeneration() || routing;
+                }, isRunning: agentState.status !== 'idle' && agentState.status !== 'error', mode: agentMode, onSubmit: handleSubmit, onQueue: (text) => {
+                    const size = enqueueMessage(text, 'end-of-turn');
+                    if (size === null)
+                        return false;
+                    showToast(`Queued (${size})`);
+                    return true;
+                }, onCommand: handleCommand, commands: commands, onStateChange: setInputSnapshot, onToast: showToast, onDictationStateChange: handleDictationStateChange, cols: columns, inputBus: inputBus, inputBlocked: () => questionnaireWidget.isActive() || questionnaireEventOwnedRef.current, clearDraftVersion: clearDraftVersion, disabled: scopeWidget.isActive() || workspaceWidget.isActive() || questionnaireWidget.isActive() || formCallbacksRef.current.size > 0, debug: debug, cwd: shellCwdRef.current, placeholder: (!configStore.hasApiKey() && !configStore.isAuthenticated())
                     ? 'Use /config key or /auth login to get started'
-                    : getAgentActivityPlaceholder(agentState) ?? 'Type a message or /help for commands...', spinnerLabel: scrollback ? spinnerLabel : null, spinnerFrame: scrollback ? spinnerFrame : null, passwordMode: pendingPromptRef.current?.isPassword ?? false, onCycleMode: onCycleMode }), _jsx(StatusBar, { state: agentState, sessionId: sessionId, version: getVersion(), connectionStatus: (configStore.hasApiKey() || configStore.isAuthenticated()) ? 'connected' : 'disconnected', contextLength: contextLength, contextEstimated: contextEstimated, contextStatus: contextStatus, provider: provider, model: model, emulationId: emulationId, effort: configStore.getCodexEffort(), inputMode: inputMode, toast: toast, debug: debug, mode: agentMode, cols: columns, statusLine: configStore.get().statusLine })] }));
+                    : getAgentActivityPlaceholder(agentState) ?? 'Type a message or /help for commands...', spinnerLabel: scrollback ? spinnerLabel : null, spinnerFrame: scrollback ? spinnerFrame : null, passwordMode: pendingPromptRef.current?.isPassword ?? false, promptOwner: pendingPromptRef.current || undefined, allowEmptySubmit: pendingPromptRef.current?.allowEmptySubmit ?? false, onCycleMode: onCycleMode }), _jsx(StatusBar, { state: agentState, sessionId: sessionId, sessionName: sessionName, version: getVersion(), connectionStatus: (configStore.hasApiKey() || configStore.isAuthenticated()) ? 'connected' : 'disconnected', contextLength: contextLength, contextEstimated: contextEstimated, contextStatus: contextStatus, provider: provider, model: model, emulationId: emulationId, effort: configStore.getCodexEffort(), inputMode: inputMode, toast: toast, escapeHint: scopeWidget.isActive() || workspaceWidget.isActive() || questionnaireWidget.isActive() || formCallbacksRef.current.size > 0 || pendingPromptRef.current
+                    ? 'Esc close'
+                    : abortControllerRef.current
+                        ? isEscapeStopArmed(escapeStopArm, abortControllerRef.current, Date.now()) ? ESCAPE_CONFIRMATION_HINT : 'Esc twice to stop'
+                        : queue.length > 0 ? 'Esc keeps queue · /rewind' : 'Esc keeps draft · /rewind', debug: debug, mode: agentMode, cols: columns, statusLine: configStore.get().statusLine })] }));
 };
 export default App;