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

package/dist/headless.js

@@ -1,4 +1,9 @@
-import { shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
+import { environmentOperationInProgress } from './agent/commands/environment.js';
+import { getEnvironment, openEnvironment, releaseEnvironment, describeEnvironmentForAgent, isEnvironmentWorkspacePath, EnvironmentRecoveryError } from './environment/store.js';
+import { inferAgentPaneTitle, readPaneLabels } from './panes/labels.js';
+import { listCommandJobs, shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
+import { ToolResponseStore } from './agent/tool_response_store.js';
+import { projectGoal } from './goal_contract.js';
 /**
  * Headless Mode for ZTC
  *
@@ -17,14 +22,17 @@ import { shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/comma
  *   echo "build a JIRA connector" | ztc --headless --mode ~/dcaig/ztc/modes/dcaig.yaml
  *   echo '{"prompt": "...", "session_id": "..."}' | ztc --headless --json
  */
+import { randomUUID } from 'node:crypto';
 import { writeFile } from 'fs/promises';
 import { configStore } from './config.js';
+import { formatTaskHandoffContext, projectTaskHandoff } from './session_handoff_contract.js';
 import { RouterConfigurationError } from './router_auth.js';
 import { registerInstance, deregisterInstance } from './instance_registry.js';
 import { ContextOverflowError, isContextOverflowMessage } from './agent/agent.js';
 import { dumpContextOverflow } from './agent/contextDump.js';
 import { registerToolCallbacks } from './app/tool_callbacks.js';
 import { createAgentWithConfig } from './app/agent_runner.js';
+import { mergeToolCheckpointMessages } from './agent/runtime/tool_checkpoints.js';
 import { clearWorkerExecutor } from './worker/index.js';
 import { commands, refreshPluginCommands } from './agent/commands/index.js';
 import { goalManager, goalPinTask, detectGoalCompletion, detectGoalBlocked, goalBlockedReason, goalFinalNote, turnProducedText, turnToolOutcomes, shouldAccountFinalTurn, snapshotGoalForTurn } from './agent/commands/goal.js';
@@ -33,13 +41,16 @@ import { allocatePlanArtifact, findPlanContent, readPlanArtifactSafely, } from '
 import { initModeRegistry, registerBuiltinHandlers, getModeRegistry } from './modes/index.js';
 import { loadEmulationProfiles, getEmulationProfile } from './emulation/catalog.js';
 import { resolve } from 'path';
-import { loadSessionByIdOrName, loadSessionFromFile, generateSessionId, SessionLoadError, bindToolResponseStoreToSession, } from './session.js';
+import { homedir } from 'node:os';
+import { applyAccountOp } from './web/accounts_mirror.js';
+import { loadSessionByIdOrName, loadSessionFromFile, generateSessionId, getSessionPathForCwd, SessionLoadError, bindToolResponseStoreToSession, } from './session.js';
 import { clearStaleTodosOnBoot } from './app/todo_state.js';
 import { runtimeDiag } from './utils/debug_log.js';
 import { rename as renameFile } from 'fs/promises';
 import { buildModelsController, buildSkillsController, buildShellController, buildStubShellController, buildAutoSelectWidgets, routeUserInput, getPlanModeCommandDenial } from './app/command_context.js';
 import { isToolAllowed } from './app/modes.js';
 import { SessionManager } from './app/session_manager.js';
+import { LocalWorkspaceCoordinator } from './workspace_collision.js';
 import { HeadlessPaneManager } from './ui/ratatui/headless_pane_manager.js';
 import { setPaneToolsTuiProcess, clearPaneToolsTuiProcess, setBusTransport, clearBusTransport, getBackgroundRegistry, clearBackgroundRegistry, resetAskUserTurnFlag, setTodoUpdateCallback } from './agent/tools/index.js';
 import { PaneRelayServer, generateRelaySocketPath } from './ui/ratatui/pane_relay.js';
@@ -98,6 +109,11 @@ export function classifyPaneChildLine(line) {
             }
             case 'cancel':
                 return { kind: 'cancel' };
+            case 'ask_user_answer':
+                if (typeof cmd.question_id !== 'string' || !cmd.question_id || typeof cmd.answer !== 'string' || !cmd.answer.trim()) {
+                    return { kind: 'malformed_cmd', raw: trimmed };
+                }
+                return { kind: 'ask_user_answer', questionId: cmd.question_id, answer: cmd.answer };
             default:
                 return { kind: 'unknown_cmd', cmd: typeof cmd.__ztc_cmd === 'string' ? cmd.__ztc_cmd : String(cmd.__ztc_cmd) };
         }
@@ -291,10 +307,13 @@ export class HeadlessApp {
     messages = [];
     sessionId;
     sessionName;
+    sessionLabels = {};
     agentBuiltForMode = null;
     /** Plan artifact captured by the current agent's prompt/write guard. */
     agentBuiltForPlanFile = null;
     /** Binding barrier for agents created by synchronous mode-change callbacks. */
+    sessionToolResponseStore = new ToolResponseStore();
+    sessionToolResponseBinding = null;
     pendingAgentBind = null;
     /** Sticky failure for the current agent generation; a settled rejected bind
      * must not be forgotten before the next turn awaits it. */
@@ -327,13 +346,22 @@ export class HeadlessApp {
     lastResponse = null;
     taskCompleted = false;
     sessionManager;
+    workspaceCoordinator = null;
+    taskHandoff = null;
+    restoredHandoffCorrections = [];
     paneManager = null;
     askUserAutoAnswered = false;
+    pendingQuestionId = null;
     paneRelay = null;
     // Auto-started loopback mirror so this headless instance is reachable from
     // other ZTC navigators. Silent — no banner, no browser auto-open.
     autoMirror = null;
     shellCwd;
+    startupCatalogController = new AbortController();
+    environmentRecord = null;
+    environmentReturnCwd = process.cwd();
+    environmentSessionCwd = null;
+    environmentReleased = false;
     shellMode;
     backgroundEventUnsub = null;
     batchEventUnsub = null;
@@ -346,6 +374,9 @@ export class HeadlessApp {
      * AbortController()`, cleared in that run's finally.
      */
     activeRunController = null;
+    turnAdmissionCount = 0;
+    runtimeMutationDone = null;
+    accountReloadPending = false;
     /**
      * Set by cancelActiveRun so the run's catch can tell a user cancel apart from
      * the timeout path (which aborts the same controller) and from real errors —
@@ -364,6 +395,7 @@ export class HeadlessApp {
     activityState = { status: 'idle' };
     lastEmittedStatus = null;
     lastEmittedVerb = null;
+    lastEmittedWaiting = null;
     hookLifecycle;
     constructor(options) {
         this.options = {
@@ -383,12 +415,13 @@ export class HeadlessApp {
         this.shellMode = resolve_headless_shell_mode();
         this.sessionManager = new SessionManager({
             sessionId: this.sessionId,
+            getSessionCwd: () => this.environmentSessionCwd ?? process.cwd(),
             sessionFile: options.sessionFile,
             getMessages: () => this.messages,
             setMessages: (msgs) => { this.messages = msgs; },
             addMessage: (msg) => {
                 this.messages.push({
-                    id: `msg_${Date.now()}`,
+                    id: `msg_${randomUUID()}`,
                     role: msg.role,
                     content: msg.content,
                     timestamp: new Date(),
@@ -403,11 +436,29 @@ export class HeadlessApp {
             // Without mode + artifact, a resumed headless plan silently becomes a
             // normal full-tool agent even though its transcript says it is planning.
             getRuntimeState: () => ({
+                environment: this.environmentRecord ? { id: this.environmentRecord.id, name: this.environmentRecord.name } : null,
+                evidence: this.agent?.getEvidenceSnapshot(),
+                usage: this.agent?.getUsageSessionId() === this.sessionId ? this.agent.getUsageSnapshot() : undefined,
+                diagnostics: this.agent?.getDiagnosticSessionId() === this.sessionId
+                    ? this.agent.getDiagnosticSnapshot() : undefined,
                 mode: this.currentMode,
                 planFile: this.currentMode === 'plan' ? this.artifactPath : null,
                 artifactPath: this.artifactPath,
                 goal: goalManager.serialize(),
+                taskHandoffInput: { corrections: this.restoredHandoffCorrections.map(correction => {
+                        const source = this.messages.find(message => message.id === correction.sourceMessageId);
+                        const raw = source?.metadata?.taskHandoffCorrection;
+                        const text = source?.role === 'user' ? source.content
+                            : raw && typeof raw === 'object' && 'text' in raw && typeof raw.text === 'string' ? raw.text : correction.text;
+                        return { ...correction, text };
+                    }), owner: { pid: process.pid, paneId: null } },
             }),
+            flushToolResponses: async () => { await this.agent?.toolResponseStore.flush(); },
+            onCheckpoint: session => {
+                this.taskHandoff = session.task_handoff ? projectTaskHandoff(session.task_handoff) : null;
+                this.agent?.setTaskHandoff(this.taskHandoff);
+                this.publishTaskHandoff();
+            },
             debugLog: (msg) => {
                 if (this.options.verbose) {
                     this.output({ type: 'status', timestamp: new Date().toISOString(), data: { status: 'debug', message: msg } });
@@ -449,14 +500,16 @@ export class HeadlessApp {
         if (this.options.paneChild) {
             // A human is watching this pane in the web mirror. Surface the question
             // instead of auto-answering: emit an 'ask_user' event that the cli_ratatui
-            // relay republishes as publishAskUser(paneId) so the browser renders the
-            // widget. The turn then ends (no re-run flag), and the human's answer comes
-            // back as a normal stdin prompt (onAskUserAnswer -> deliverBusMessage ->
-            // pane-input callback), continuing the conversation.
+            // relay forwards with its original request ID. The turn then ends (no
+            // re-run flag), and the human's answer returns through the identified
+            // control channel, checked against this pane's pending question.
+            this.pendingQuestionId = randomUUID();
             this.output({
                 type: 'ask_user',
                 timestamp: new Date().toISOString(),
                 data: {
+                    question_id: this.pendingQuestionId,
+                    origin_session_id: this.sessionId,
                     questions: questions.map(q => ({
                         question: q.question,
                         options: q.options,
@@ -478,7 +531,7 @@ export class HeadlessApp {
             ? answers[0]
             : JSON.stringify(questions.map((q, i) => ({ question: q.question, answer: answers[i] })));
         this.messages.push({
-            id: `msg_${Date.now()}`,
+            id: `msg_${randomUUID()}`,
             role: 'user',
             content: answerText,
             timestamp: new Date(),
@@ -486,19 +539,29 @@ export class HeadlessApp {
         this.askUserAutoAnswered = true;
         return null;
     }
+    dismissPendingQuestion() {
+        if (!this.pendingQuestionId)
+            return;
+        this.output({ type: 'question_dismiss', timestamp: new Date().toISOString(),
+            data: { question_id: this.pendingQuestionId, origin_session_id: this.sessionId } });
+        this.pendingQuestionId = null;
+    }
     emitHeadlessStatus() {
         const projected = buildActivityDisplayState(this.activityState, 'Thinking');
         const verb = projected.verb ?? null;
-        if (projected.wireStatus === this.lastEmittedStatus && verb === this.lastEmittedVerb)
+        const waitingKey = projected.waiting ? JSON.stringify(projected.waiting) : null;
+        if (projected.wireStatus === this.lastEmittedStatus && verb === this.lastEmittedVerb && waitingKey === this.lastEmittedWaiting)
             return;
         this.lastEmittedStatus = projected.wireStatus;
         this.lastEmittedVerb = verb;
+        this.lastEmittedWaiting = waitingKey;
         this.output({
             type: 'status',
             timestamp: new Date().toISOString(),
             data: {
                 status: projected.wireStatus,
                 ...(verb ? { verb } : {}),
+                ...(projected.waiting ? { waiting: projected.waiting } : {}),
             },
         });
     }
@@ -531,11 +594,31 @@ export class HeadlessApp {
     subscribeAgentEvents() {
         if (!this.agent)
             throw new Error('Agent not initialized');
-        this.activityState = { status: 'thinking', startedAt: new Date() };
+        this.activityState = { status: 'thinking', startedAt: new Date(), taskHandoff: this.activityState.taskHandoff,
+            workspaceCollision: this.activityState.workspaceCollision };
+        void this.workspaceCoordinator?.setActivity('running').catch(() => {
+            runtimeDiag('warn', '[ztc] Local workspace activity evidence could not be refreshed.');
+        });
         this.emitHeadlessStatus();
+        this.output({ type: 'evidence', timestamp: new Date().toISOString(),
+            data: { session_id: this.sessionId, snapshot: this.agent.getEvidenceSnapshot() } });
         const unsubscribe = this.agent.on((event) => {
             this.activityState = applyAgentEventToState(this.activityState, event);
             switch (event.type) {
+                case 'request_usage':
+                    this.output({ type: 'request_usage', timestamp: new Date().toISOString(), data: { session_id: this.sessionId, receipt: event.receipt } });
+                    this.autoMirror?.publish({ type: 'request_usage', data: { sessionId: this.sessionId, receipt: event.receipt } });
+                    break;
+                case 'evidence':
+                    this.output({ type: 'evidence', timestamp: new Date().toISOString(),
+                        data: { session_id: event.sessionId, snapshot: event.snapshot } });
+                    break;
+                case 'command_wait':
+                case 'command_wait_end':
+                    goalManager.observeHostWait(event);
+                    this.publishCurrentGoal();
+                    this.emitHeadlessStatus();
+                    break;
                 case 'thinking_start':
                     this.emitHeadlessStatus();
                     break;
@@ -692,7 +775,11 @@ export class HeadlessApp {
         });
         return () => {
             unsubscribe();
-            this.activityState = { status: 'idle' };
+            this.activityState = { status: 'idle', taskHandoff: this.activityState.taskHandoff,
+                workspaceCollision: this.activityState.workspaceCollision };
+            void this.workspaceCoordinator?.setActivity('idle').catch(() => {
+                runtimeDiag('warn', '[ztc] Local workspace activity evidence could not be refreshed.');
+            });
             this.emitHeadlessStatus();
         };
     }
@@ -711,6 +798,13 @@ export class HeadlessApp {
     /**
      * Output a message in the appropriate format
      */
+    publishTaskHandoff() {
+        this.publishCurrentGoal();
+        this.activityState = applyAgentEventToState(this.activityState, { type: 'task_handoff', sessionId: this.sessionId, projection: this.taskHandoff });
+        this.output({ type: 'task_handoff', timestamp: new Date().toISOString(),
+            data: { sessionId: this.sessionId, projection: this.taskHandoff } });
+        this.autoMirror?.publishTaskHandoff(this.taskHandoff, this.sessionId);
+    }
     output(data) {
         if (this.options.json) {
             console.log(JSON.stringify(data));
@@ -748,11 +842,19 @@ export class HeadlessApp {
                     if (!this.options.quiet || this.options.verbose)
                         console.log(`${ts}[commands] ${JSON.stringify(data.data.jobs)}`);
                     break;
+                case 'evidence':
+                    if (!this.options.quiet || this.options.verbose)
+                        console.log(`${ts}[evidence] Retained source-linked observations; inspect with /evidence.`);
+                    break;
+                case 'task_handoff':
+                    if (this.taskHandoff && (!this.options.quiet || this.options.verbose))
+                        console.log(formatTaskHandoffContext(this.taskHandoff.snapshot));
+                    break;
                 case 'status':
                     // In quiet mode, skip status unless verbose
                     if (this.options.quiet && !this.options.verbose)
                         break;
-                    console.log(`${ts}[status] ${data.data.status}`);
+                    console.log(`${ts}[status] ${data.data.waiting ? 'Waiting for command' : data.data.status}`);
                     break;
                 case 'artifact':
                     console.log(`${ts}[artifact] ${data.data.path}`);
@@ -1008,8 +1110,9 @@ export class HeadlessApp {
         // whose real credential (for example a Codex subscription auth.json) is on
         // disk. `load()` is idempotent, so the CLI path is unaffected.
         await configStore.load();
-        // Require either direct provider key or platform auth token.
-        if (!configStore.hasApiKey() && !configStore.isAuthenticated()) {
+        // Hosted native Messages supplies its own scoped transport bearer. The
+        // backend factory validates it; provider-key discovery must not gate it.
+        if (!configStore.get().nativeAnthropicMessagesRouter && !configStore.hasApiKey() && !configStore.isAuthenticated()) {
             this.output({
                 type: 'error',
                 timestamp: new Date().toISOString(),
@@ -1182,6 +1285,27 @@ export class HeadlessApp {
                 });
             }
         }
+        const savedEnvironment = loadedSession?.metadata.environment;
+        if (savedEnvironment && this.options.detachEnvironment) {
+            this.output({ type: 'status', timestamp: new Date().toISOString(), data: { status: 'environment_detached', message: `Environment ${savedEnvironment.name} detached by launch option; conversation resumed in ${this.shellCwd}.` } });
+        }
+        if (savedEnvironment && !this.options.detachEnvironment) {
+            try {
+                this.environmentSessionCwd = loadedSession.metadata.cwd;
+                this.environmentReturnCwd = this.environmentSessionCwd;
+                const before = await getEnvironment(savedEnvironment.name);
+                if (before.id !== savedEnvironment.id)
+                    throw new Error('The saved environment was replaced; inspect it before recovery.');
+                const record = await openEnvironment(savedEnvironment.name, this.sessionId);
+                this.environmentReleased = false;
+                this.environmentRecord = record;
+                this.shellCwd = record.workspacePath;
+                process.chdir(record.workspacePath);
+            }
+            catch (error) {
+                throw new EnvironmentRecoveryError(`Environment ${savedEnvironment.name} could not resume: ${error instanceof Error ? error.message : String(error)}. To resume the conversation in the current project, add --detach-environment.`);
+            }
+        }
         if (explicitMode) {
             if (explicitMode.name === 'plan') {
                 const resumePath = loadedSession?.metadata.mode === 'plan'
@@ -1217,6 +1341,7 @@ export class HeadlessApp {
             executeCommand: (cmd, args, origin) => this.executeCommand(cmd, args, origin),
             getMode: () => this.currentMode,
             setMode: (mode) => {
+                this.sessionManager.recordHostDiagnostic('mode', { mode, previousMode: this.currentMode, source: 'host_mode_change' });
                 this.currentMode = mode;
                 this.hookLifecycle.onModeChange();
             },
@@ -1253,14 +1378,15 @@ export class HeadlessApp {
         // Set up pane tools for mux mode
         if (this.options.muxMode) {
             this.paneManager = new HeadlessPaneManager();
-            this.paneManager.setHostTitle('Overseer');
+            this.paneManager.setHostTitle(inferAgentPaneTitle({ cwd: this.options.cwd ?? process.cwd(), sessionId: this.sessionId, paneId: 0 }));
+            this.paneManager.send({ type: 'set_pane_labels', pane_id: 0, labels: this.sessionLabels, if_newer: true });
             await this.paneManager.start({ mux: true });
             setPaneToolsTuiProcess(this.paneManager);
             // Start pane relay server so child panes (--pane) can connect and use pane tools
             const relayPath = generateRelaySocketPath();
             process.env.ZTC_PANE_RELAY = relayPath;
             this.paneRelay = new PaneRelayServer(this.paneManager, relayPath);
-            this.paneRelay.start();
+            await this.paneRelay.start();
             await runtimePluginRegistry.runMuxStartHooks({
                 paneManager: this.paneManager,
                 relayPath,
@@ -1290,6 +1416,13 @@ export class HeadlessApp {
         if (!this.options.deferJsonStdinStartup) {
             this.outputHeadlessShellMode();
         }
+        // Discover current Router controls before the first backend snapshots them.
+        try {
+            if (configStore.resolveLLMBackendConfig().useProxy) {
+                void buildModelsController(configStore).catalog(this.startupCatalogController.signal, { refresh: 'startup' }).catch(() => { });
+            }
+        }
+        catch { /* Offline startup keeps the account-scoped cached catalog. */ }
         // Create agent
         this.agent = this.createAgent();
         if (!this.agent) {
@@ -1319,6 +1452,7 @@ export class HeadlessApp {
                     // Web `use` (switch account) hot-swaps this headless instance's live
                     // agent, matching the CLI /accounts use path.
                     this.autoMirror.setAccountReloadHook(() => this.reloadAgentInPlace());
+                    this.autoMirror.setAccountOperationHook(body => this.applyAccountOperation(body));
                     mirrorPort = this.autoMirror.getPort();
                 }
                 catch (err) {
@@ -1344,49 +1478,61 @@ export class HeadlessApp {
                 hidden: false,
                 cwd: process.cwd(),
             });
-            let cleanedUp = false;
-            const cleanup = () => {
-                if (cleanedUp)
-                    return;
-                cleanedUp = true;
+        }
+        // Visibility only controls navigator registration, never process cleanup.
+        let cleanedUp = false;
+        const cleanup = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            if (!this.options.navigatorHidden) {
                 try {
                     deregisterInstance(process.pid);
                 }
-                catch { /* ignore */ }
-                try {
-                    this.autoMirror?.stop();
-                }
                 catch { /* best effort */ }
-            };
-            // Fatal-signal exit must also reap detached shell-tool children. They are
-            // spawned in their own process group, so an ordinary ztc exit orphans any
-            // `npm run dev` / test runner / install still running — the cell Stop /
-            // Archive / Quit and supervisor shutdown only SIGTERM this top-level process.
-            // SIGTERM the groups, give them a brief moment, then SIGKILL stragglers and
-            // exit. The 200ms is well under the supervisor's 2s SIGKILL-escalation on us,
-            // so we still exit promptly.
-            const fatalExit = (code) => {
-                cleanup();
-                const killed = terminateActiveShellChildren('SIGTERM');
+            }
+            try {
+                this.autoMirror?.stop();
+            }
+            catch { /* best effort */ }
+            this.workspaceCoordinator?.closeSync();
+        };
+        // Fatal-signal exit must also reap detached shell-tool children. They are
+        // spawned in their own process group, so an ordinary ztc exit orphans any
+        // `npm run dev` / test runner / install still running — the cell Stop /
+        // Archive / Quit and supervisor shutdown only SIGTERM this top-level process.
+        // SIGTERM the groups, give them a brief moment, then SIGKILL stragglers and
+        // exit. The 200ms is well under the supervisor's 2s SIGKILL-escalation on us,
+        // so we still exit promptly.
+        let fatalExitRequested = false;
+        const fatalExit = (code) => {
+            if (fatalExitRequested)
+                return;
+            fatalExitRequested = true;
+            cleanup();
+            const killed = terminateActiveShellChildren('SIGTERM');
+            const forceExit = setTimeout(() => {
+                terminateActiveShellChildren('SIGKILL');
+                process.exit(code);
+            }, 200);
+            // Wait for an already admitted presence publication to retire before
+            // exit. The same bounded fallback covers a stuck filesystem request.
+            void (this.workspaceCoordinator?.close() ?? Promise.resolve()).catch(() => { }).then(() => {
                 if (killed.length === 0) {
+                    clearTimeout(forceExit);
                     process.exit(code);
-                    return;
                 }
-                setTimeout(() => {
-                    terminateActiveShellChildren('SIGKILL');
-                    process.exit(code);
-                }, 200).unref();
-            };
-            process.on('exit', cleanup);
-            process.on('SIGINT', () => fatalExit(130));
-            process.on('SIGTERM', () => fatalExit(143));
-            process.on('SIGHUP', () => fatalExit(129));
-            process.on('uncaughtException', (err) => {
-                cleanup();
-                console.error(err);
-                process.exit(1);
             });
-        }
+        };
+        process.on('exit', cleanup);
+        process.on('SIGINT', () => fatalExit(130));
+        process.on('SIGTERM', () => fatalExit(143));
+        process.on('SIGHUP', () => fatalExit(129));
+        process.on('uncaughtException', (err) => {
+            cleanup();
+            console.error(err);
+            process.exit(1);
+        });
         // A pane child receives the web mirror's stop button as SIGUSR2 (see
         // HeadlessPaneManager.cancelPane): its stdin loop AWAITS the running turn, so
         // a signal is the only mid-turn cancel channel. SIGUSR2, not SIGUSR1 — Node
@@ -1412,21 +1558,44 @@ export class HeadlessApp {
                 this.outputBackgroundEvent(event);
             });
         }
+        // Navigator visibility does not change local workspace ownership evidence.
+        // Hidden workers and pane children must remain discoverable by sibling UIs.
+        this.workspaceCoordinator = new LocalWorkspaceCoordinator({
+            sessionId: this.sessionId,
+            getCwd: () => this.shellCwd,
+            getWork: () => ({ sessionId: this.sessionId, messages: this.messages,
+                goal: goalManager.get(), jobs: listCommandJobs(this.sessionId), taskHandoff: this.taskHandoff }),
+            kind: process.env.ZTC_COLONY_CHILD ? 'colony_child' : 'headless',
+            onSnapshot: (snapshot) => {
+                this.activityState = { ...this.activityState, workspaceCollision: snapshot };
+            },
+        });
+        await this.workspaceCoordinator.start();
         return true;
     }
     /**
      * Create the agent
      */
     commandJobsUnsubscribe;
-    createAgent() {
+    createAgent(options = {}) {
+        const diagnostics = this.sessionManager.getDiagnostics();
+        this.sessionManager.recordHostDiagnostic('runtime', {
+            renderer: 'headless', rendererVersion: null, nativeCapabilities: null, source: 'host_launch',
+        });
+        this.sessionManager.recordHostDiagnostic('mode', { mode: this.currentMode, source: 'agent_construction' });
         this.commandJobsUnsubscribe?.();
         this.commandJobsUnsubscribe = subscribeCommandJobs(this.sessionId, jobs => {
+            for (const job of jobs)
+                this.sessionManager.recordCommandJob(job);
             this.output({ type: 'command_jobs', timestamp: new Date().toISOString(), data: { jobs } });
             this.autoMirror?.publish({ type: 'command_jobs', data: { jobs } });
+            void this.workspaceCoordinator?.refresh().catch(error => runtimeDiag('warn', `[ztc] Local workspace command evidence could not be refreshed: ${String(error)}`));
         });
         const isEvolveMode = this.currentMode === 'evolved-swarm';
         const hookDispatcher = this.hookLifecycle.refresh();
         const agent = createAgentWithConfig({
+            allowUnavailableRouterAuth: options.allowUnavailableRouterAuth,
+            environmentContext: this.environmentRecord ? describeEnvironmentForAgent(this.environmentRecord) : undefined,
             autoContinue: true, // Always auto-continue in headless mode
             maxConsecutiveAutoContinues: configStore.getMaxConsecutiveAutoContinues(),
             maxIterations: isEvolveMode ? 200 : (this.options.maxIterations ?? Infinity),
@@ -1443,8 +1612,25 @@ export class HeadlessApp {
             cwdProvider: () => this.shellCwd || process.cwd(),
             hookDispatcher,
             hookApprovalRequester: (request) => this.requestHookApproval(request),
+            toolResponseStore: this.sessionToolResponseStore,
+            onLocalFileChange: async (paths, cwd) => {
+                await this.workspaceCoordinator?.recordObservedPaths(paths, cwd);
+            },
+            toolCheckpoint: async (checkpoint) => {
+                if (checkpoint.sessionId !== this.sessionId) {
+                    throw new Error('Tool checkpoint session identity does not match the active headless session.');
+                }
+                const merged = mergeToolCheckpointMessages(this.messages, checkpoint.messages);
+                // Agent.run shares this array. Preserve that identity and any accepted
+                // live correction sources while applying the canonical tool outcome.
+                this.messages.splice(0, this.messages.length, ...merged);
+                await this.sessionManager.save({ required: true });
+            },
         });
         if (agent) {
+            agent.restoreDiagnosticSnapshot(diagnostics);
+            agent.restoreUsageSnapshot(this.sessionManager.getUsageSnapshot());
+            agent.setTaskHandoff(this.taskHandoff);
             this.agentBindFailure = null;
             const bind = this.bindAgentStore(agent);
             this.pendingAgentBind = bind;
@@ -1467,12 +1653,20 @@ export class HeadlessApp {
         return agent;
     }
     async bindAgentStore(agent) {
-        await bindToolResponseStoreToSession(agent.toolResponseStore, agent.discoveredTools, process.cwd(), this.sessionId, {
+        const storeConfig = {
+            offloadEnabled: configStore.getOffloadEnabled(),
+            inlineSizeThresholdTokens: configStore.getInlineSizeThresholdTokens(),
+            inlineAgeTurns: configStore.getInlineAgeTurns(),
+            toolCompression: configStore.getToolCompression(),
+        };
+        agent.toolResponseStore.setConfig(storeConfig);
+        this.sessionToolResponseBinding ??= bindToolResponseStoreToSession(agent.toolResponseStore, agent.discoveredTools, this.environmentSessionCwd ?? process.cwd(), this.sessionId, {
             offloadEnabled: configStore.getOffloadEnabled(),
             inlineSizeThresholdTokens: configStore.getInlineSizeThresholdTokens(),
             inlineAgeTurns: configStore.getInlineAgeTurns(),
             toolCompression: configStore.getToolCompression(),
         }, this.options.sessionFile);
+        await this.sessionToolResponseBinding;
         agent.refreshSystemPrompt();
     }
     async awaitAgentBind() {
@@ -1497,6 +1691,11 @@ export class HeadlessApp {
      */
     replaceAgent(next) {
         const previous = this.agent;
+        const diagnostics = this.sessionManager.getDiagnostics();
+        if (next?.getDiagnosticSessionId() === this.sessionId)
+            next.restoreDiagnosticSnapshot(diagnostics);
+        if (next?.getUsageSessionId() === this.sessionId)
+            next.restoreUsageSnapshot(this.sessionManager.getUsageSnapshot());
         this.agent = next;
         if (previous && previous !== next)
             previous.dispose();
@@ -1542,6 +1741,145 @@ export class HeadlessApp {
         this.replaceAgent(nextAgent);
         this.hookLifecycle.ensureWatcher();
     }
+    /** Activate a config profile without replacing the conversation or its storage. */
+    async switchConfigProfileInPlace(name, duplicateSource) {
+        if (process.env.ZTC_HOSTED === '1' || process.env.ZTC_HOST_RUNTIME?.trim()) {
+            throw new Error('Hosted thread settings cannot be replaced by a local config profile.');
+        }
+        if (this.activeRunController) {
+            throw new Error('Wait for the current turn to finish before switching profiles.');
+        }
+        await this.awaitAgentBind();
+        const previousMcp = JSON.stringify(configStore.get().mcpServers ?? {});
+        const previousColonyMcp = process.env.ZTC_COLONY_MCP;
+        const previousColonyOwned = process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+        let runtimeTouched = false;
+        let mcpChanged = false;
+        const reloadMcp = async () => {
+            const { closeMcpServers, colonyOptIn } = await import('./mcp/registry.js');
+            await closeMcpServers();
+            const servers = configStore.get().mcpServers;
+            if ((servers && Object.keys(servers).length > 0) || colonyOptIn()) {
+                const { initMcpServers } = await import('./mcp/client.js');
+                await initMcpServers(servers);
+            }
+        };
+        const reloadSkills = async () => {
+            const { invalidateSkillsCache, preloadSkillsManifest } = await import('./skills/registry.js');
+            invalidateSkillsCache();
+            await preloadSkillsManifest();
+        };
+        const rebuild = async () => {
+            const next = this.createAgent({ allowUnavailableRouterAuth: true });
+            try {
+                if (next)
+                    await this.awaitAgentBind();
+            }
+            catch (error) {
+                next?.dispose();
+                throw error;
+            }
+            this.replaceAgent(next);
+            this.hookLifecycle.ensureWatcher();
+        };
+        try {
+            const activate = async () => {
+                runtimeTouched = true;
+                if (process.env.ZTC_COLONY_MCP_CONFIG_OWNED === '1') {
+                    delete process.env.ZTC_COLONY_MCP;
+                    delete process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+                }
+                if (configStore.get().mcp?.colonyAutoAttach && !process.env.ZTC_COLONY_MCP) {
+                    process.env.ZTC_COLONY_MCP = '1';
+                    process.env.ZTC_COLONY_MCP_CONFIG_OWNED = '1';
+                }
+                mcpChanged = previousMcp !== JSON.stringify(configStore.get().mcpServers ?? {})
+                    || previousColonyMcp !== process.env.ZTC_COLONY_MCP;
+                if (mcpChanged)
+                    await reloadMcp();
+                await reloadSkills();
+                await rebuild();
+                await this.sessionManager.save({ persistEmpty: true, required: true });
+            };
+            if (duplicateSource === undefined)
+                await configStore.switchProfile(name, activate);
+            else
+                await configStore.duplicateProfile(name, duplicateSource, activate);
+        }
+        catch (error) {
+            if (previousColonyMcp === undefined)
+                delete process.env.ZTC_COLONY_MCP;
+            else
+                process.env.ZTC_COLONY_MCP = previousColonyMcp;
+            if (previousColonyOwned === undefined)
+                delete process.env.ZTC_COLONY_MCP_CONFIG_OWNED;
+            else
+                process.env.ZTC_COLONY_MCP_CONFIG_OWNED = previousColonyOwned;
+            if (runtimeTouched) {
+                try {
+                    if (mcpChanged)
+                        await reloadMcp();
+                    await reloadSkills();
+                    await rebuild();
+                }
+                catch (restoreError) {
+                    throw new Error('Profile switch failed: ' + error.message
+                        + '. Restoring the previous runtime also failed: ' + restoreError.message);
+                }
+            }
+            throw error;
+        }
+        this.autoMirror?.setSuperuser(configStore.isSuperuser());
+        if (!this.agent) {
+            let notice = 'This profile has no usable provider yet. Configure one with /config or /auth.';
+            try {
+                configStore.resolveLLMBackendConfig({ cwd: this.shellCwd });
+            }
+            catch (error) {
+                if (error instanceof RouterConfigurationError && error.needsSignIn) {
+                    notice = 'This profile needs a Router sign-in. Use /auth login to sign in for this profile; your session and conversation are retained.';
+                }
+            }
+            this.emitPaneChildNotice(notice);
+        }
+    }
+    async reloadAccountAgent() {
+        if (this.turnAdmissionCount > 0 || this.activeRunController || this.runtimeMutationDone) {
+            this.accountReloadPending = true;
+            return;
+        }
+        this.reloadAgentInPlace();
+        await this.awaitAgentBind();
+    }
+    async applyAccountOperation(body) {
+        if (this.turnAdmissionCount > 0 || this.activeRunController || this.runtimeMutationDone)
+            return { ok: false, blocked: true, error: 'An agent turn or tool is active; wait before switching accounts.' };
+        let release;
+        this.runtimeMutationDone = new Promise(resolve => { release = resolve; });
+        let operationOpen = true;
+        try {
+            return await applyAccountOp(body, configStore, async () => {
+                if (!operationOpen) {
+                    await this.reloadAccountAgent();
+                    return;
+                }
+                this.reloadAgentInPlace();
+                await this.awaitAgentBind();
+            });
+        }
+        finally {
+            operationOpen = false;
+            this.runtimeMutationDone = null;
+            release();
+        }
+    }
+    async finishTurnAdmission() {
+        this.turnAdmissionCount--;
+        if (this.turnAdmissionCount === 0 && this.accountReloadPending) {
+            this.accountReloadPending = false;
+            await this.reloadAccountAgent();
+        }
+    }
     /** Rebuild a backend invalidated by logout before either headless turn path. */
     async ensureAgentForTurn() {
         if (this.agent)
@@ -1596,10 +1934,11 @@ export class HeadlessApp {
             addMessage: (msg) => {
                 capturedMessages.push(msg.content);
                 this.messages.push({
-                    id: `msg_${Date.now()}`,
+                    id: `msg_${randomUUID()}`,
                     role: msg.role,
                     content: msg.content,
                     timestamp: new Date(),
+                    ...(msg.metadata ? { metadata: msg.metadata } : {}),
                 });
                 this.output({
                     type: 'message',
@@ -1608,11 +1947,24 @@ export class HeadlessApp {
                 });
             },
             clearMessages: () => { this.messages = []; },
+            setMessages: (messages) => { this.messages = messages; },
             // /clear-only reset (never /compact): drop the R7 pinned task so a fresh
             // conversation re-pins its own first message instead of re-running the
             // pre-clear prompt. clearMessages above is shared with /compact and must
             // keep the pin, so the reset lives here.
-            clearTransientState: () => { this.agent?.clearPinnedTask(); },
+            clearTransientState: () => {
+                this.taskHandoff = null;
+                this.restoredHandoffCorrections = [];
+                this.agent?.setTaskHandoff(null);
+                this.publishTaskHandoff();
+                this.agent?.clearPinnedTask();
+                if (this.agent) {
+                    this.agent.toolResponseStore.evidence.clear();
+                    const snapshot = this.agent.getEvidenceSnapshot();
+                    this.activityState = applyAgentEventToState(this.activityState, { type: 'evidence', sessionId: this.sessionId, snapshot });
+                    this.output({ type: 'evidence', timestamp: new Date().toISOString(), data: { session_id: this.sessionId, snapshot } });
+                }
+            },
             getMessages: () => this.messages,
             setAgentState: () => { },
             // Authoritative context for /context + /compact (matches the bar): the
@@ -1624,6 +1976,13 @@ export class HeadlessApp {
             // and /context use the reduced size.
             setContextUsage: (used) => { this.lastContextTokens = used; },
             reloadAgent: (options) => this.reloadAgentInPlace(options?.defer),
+            switchConfigProfile: (name) => this.switchConfigProfileInPlace(name),
+            duplicateProfile: async (name, source) => {
+                await this.switchConfigProfileInPlace(name, source);
+                return name;
+            },
+            applyAccountOperation: body => this.applyAccountOperation(body),
+            getUsageSnapshot: () => this.sessionManager.getUsageSnapshot(),
             setRuntimeModelOverride: (provider, model) => {
                 configStore.setCliOverride('provider', provider);
                 configStore.setCliOverride('model', model);
@@ -1631,16 +1990,57 @@ export class HeadlessApp {
             },
             setDebug: () => { },
             getSessionId: () => this.sessionId,
+            getSessionCwd: () => this.environmentSessionCwd ?? this.shellCwd,
+            environmentAvailable: () => this.shellMode === 'real',
+            isAgentRunning: () => this.activeRunController !== null,
+            getEnvironment: () => this.environmentRecord,
+            environmentChanged: async (name, returnCwd) => {
+                if (returnCwd) {
+                    this.environmentReturnCwd = returnCwd;
+                    this.environmentSessionCwd ??= returnCwd;
+                }
+                if (name) {
+                    this.environmentRecord = await getEnvironment(name);
+                    this.environmentReleased = false;
+                }
+                else {
+                    const previous = this.environmentRecord;
+                    this.environmentRecord = null;
+                    this.shellCwd = previous && isEnvironmentWorkspacePath(previous.workspacePath, this.environmentReturnCwd) ? homedir() : this.environmentReturnCwd;
+                }
+                process.chdir(this.shellCwd);
+                await this.sessionManager.save({ persistEmpty: true, required: true });
+            },
             getExecutionContext: () => this.agent?.getExecutionContext(),
+            getOwnPaneId: () => this.paneManager ? 0 : null,
+            getPaneLabels: this.paneManager ? async (paneId = 0) => readPaneLabels(this.paneManager, paneId) : undefined,
+            setPaneLabels: async (labels, paneId) => {
+                if (paneId !== undefined && !this.paneManager)
+                    throw new Error('Pane mux is unavailable.');
+                if (paneId === undefined) {
+                    this.sessionName = labels.manual_title;
+                    this.sessionLabels = { ...labels };
+                }
+                this.paneManager?.send({ type: 'set_pane_labels', pane_id: paneId ?? 0, labels });
+            },
+            checkpointSession: async () => {
+                await this.sessionManager.save({ required: true, persistEmpty: true });
+                return this.options.sessionFile ?? getSessionPathForCwd(process.cwd(), this.sessionId);
+            },
+            getDiagnostics: () => this.sessionManager.getDiagnostics(),
+            getEvidenceSnapshot: () => this.agent?.getEvidenceSnapshot(),
             getSessionName: () => this.sessionName,
             setSessionName: (name) => {
                 this.sessionName = name && name.length > 0 ? name : undefined;
+                this.sessionLabels.manual_title = this.sessionName;
+                this.paneManager?.send({ type: 'set_pane_labels', pane_id: 0, labels: this.sessionLabels });
             },
             retry: () => { },
             exit: () => { process.exit(0); },
             config: configStore,
             emulation: { list: loadEmulationProfiles, get: getEmulationProfile },
             setMode: (mode) => {
+                this.sessionManager.recordHostDiagnostic('mode', { mode, previousMode: this.currentMode, source: 'host_mode_change' });
                 this.currentMode = mode;
                 this.hookLifecycle.onModeChange();
             },
@@ -1677,7 +2077,7 @@ export class HeadlessApp {
             ...autoWidgets,
             embedded: this.embeddedController || undefined,
             bench: this.benchController || undefined,
-            getInputMode: () => 'queue',
+            getInputMode: () => 'steer',
             setInputMode: () => { },
             triggerAgentTurn: () => {
                 agentTurnPromise = this.runAgentOnCurrentMessages();
@@ -1699,6 +2099,8 @@ export class HeadlessApp {
             return denial;
         }
         // Global command lookup first — global commands may have richer behavior than mode handlers
+        if (cmd.toLowerCase() === 'model' && (this.turnAdmissionCount > 0 || this.activeRunController || this.runtimeMutationDone))
+            return 'Cannot switch model while an active agent turn or account change is running.';
         const command = commands.find(c => c.name === cmd.toLowerCase());
         if (command) {
             try {
@@ -1739,6 +2141,21 @@ export class HeadlessApp {
      * Run a single prompt through the agent
      */
     async runPrompt(prompt, opts = {}) {
+        if (routeUserInput(prompt).type === 'command') {
+            await this.runPromptAdmitted(prompt, opts);
+            return;
+        }
+        if (this.runtimeMutationDone)
+            await this.runtimeMutationDone;
+        this.turnAdmissionCount++;
+        try {
+            await this.runPromptAdmitted(prompt, opts);
+        }
+        finally {
+            await this.finishTurnAdmission();
+        }
+    }
+    async runPromptAdmitted(prompt, opts = {}) {
         // Route input: slash command or regular message
         const route = routeUserInput(prompt);
         if (route.type === 'command') {
@@ -1753,6 +2170,11 @@ export class HeadlessApp {
             }
             return;
         }
+        if (this.environmentRecord?.status === 'paused' || environmentOperationInProgress(this.sessionId)) {
+            this.hadHeadlessError = true;
+            this.output({ type: 'error', timestamp: new Date().toISOString(), data: { message: this.environmentRecord?.status === 'paused' ? 'Environment paused. Use /environment resume before starting an agent turn.' : 'Wait for the environment operation to finish before starting an agent turn.' } });
+            return;
+        }
         if (!await this.ensureAgentForTurn())
             return;
         if (route.type === 'shell') {
@@ -1770,12 +2192,19 @@ export class HeadlessApp {
         }
         // Add user message
         const userMsg = {
-            id: `msg_${Date.now()}`,
+            id: `msg_${randomUUID()}`,
             role: 'user',
             content: prompt,
             timestamp: new Date(),
         };
         this.messages.push(userMsg);
+        if (!opts.automaticGoalTurn) {
+            const sustained = goalManager.adoptUserIntent(userMsg, { configuredMaxTurns: configStore.get().goalMaxTurns });
+            if (sustained) {
+                this.agent?.setPinnedTask(goalPinTask(sustained));
+                this.emitGoalNote(`Sustained goal recorded: ${sustained.objective}`);
+            }
+        }
         this.output({
             type: 'message',
             timestamp: new Date().toISOString(),
@@ -1785,6 +2214,7 @@ export class HeadlessApp {
         try {
             this.ensureAgentMatchesMode();
             await this.awaitAgentBind();
+            await this.sessionManager.save({ required: true });
             cleanup = this.subscribeAgentEvents();
         }
         catch (error) {
@@ -1844,11 +2274,12 @@ export class HeadlessApp {
                 // `automatic`); a user turn taken while a goal is active resets it instead.
                 this.lastTurnAutomaticGoal = opts.automaticGoalTurn === true;
                 // Add assistant response
-                if (response.content) {
+                if (response.content || response.reasoning?.trim()) {
                     const assistantMsg = {
-                        id: `msg_${Date.now()}`,
+                        id: `msg_${randomUUID()}`,
                         role: 'assistant',
                         content: response.content,
+                        ...(response.nativeContent ? { nativeContent: response.nativeContent, nativeModel: response.nativeModel, nativeContextId: response.nativeContextId } : {}),
                         timestamp: new Date(),
                         // Reasoning models expect their trace replayed with the assistant
                         // message on later turns; dropping it strips the history.
@@ -1993,7 +2424,7 @@ export class HeadlessApp {
             return;
         }
         const userMsg = {
-            id: `msg_${Date.now()}`,
+            id: `msg_${randomUUID()}`,
             role: 'user',
             content: prompt,
             timestamp: new Date(),
@@ -2029,7 +2460,7 @@ export class HeadlessApp {
             }
             const content = toolResult.content;
             const assistantMsg = {
-                id: `msg_${Date.now()}`,
+                id: `msg_${randomUUID()}`,
                 role: 'assistant',
                 content,
                 timestamp: new Date(),
@@ -2082,6 +2513,22 @@ export class HeadlessApp {
      * Used when commitPlan already added messages and we just need the agent to act on them.
      */
     async runAgentOnCurrentMessages() {
+        if (this.environmentRecord?.status === 'paused' || environmentOperationInProgress(this.sessionId)) {
+            this.hadHeadlessError = true;
+            this.output({ type: 'error', timestamp: new Date().toISOString(), data: { message: this.environmentRecord?.status === 'paused' ? 'Environment paused. Use /environment resume before starting an agent turn.' : 'Wait for the environment operation to finish before starting an agent turn.' } });
+            return;
+        }
+        if (this.runtimeMutationDone)
+            await this.runtimeMutationDone;
+        this.turnAdmissionCount++;
+        try {
+            await this.runAgentOnCurrentMessagesAdmitted();
+        }
+        finally {
+            await this.finishTurnAdmission();
+        }
+    }
+    async runAgentOnCurrentMessagesAdmitted() {
         if (!await this.ensureAgentForTurn())
             return;
         let cleanup;
@@ -2145,9 +2592,10 @@ export class HeadlessApp {
                 }
                 if (response.content) {
                     const assistantMsg = {
-                        id: `msg_${Date.now()}`,
+                        id: `msg_${randomUUID()}`,
                         role: 'assistant',
                         content: response.content,
+                        ...(response.nativeContent ? { nativeContent: response.nativeContent, nativeModel: response.nativeModel, nativeContextId: response.nativeContextId } : {}),
                         timestamp: new Date(),
                         // Reasoning models expect their trace replayed with the assistant
                         // message on later turns; dropping it strips the history.
@@ -2228,6 +2676,7 @@ export class HeadlessApp {
      * Save the current session
      */
     async saveCurrentSession() {
+        this.publishCurrentGoal();
         try {
             await this.sessionManager.save({ required: !!this.options.sessionFile });
         }
@@ -2347,6 +2796,11 @@ export class HeadlessApp {
      * Shut down background agents and batch orchestrator gracefully before exiting.
      */
     async shutdownBackgroundAgents() {
+        this.startupCatalogController.abort(new Error('Runtime stopped'));
+        if (this.environmentRecord && !this.environmentReleased) {
+            await releaseEnvironment(this.environmentRecord.name, this.sessionId);
+            this.environmentReleased = true;
+        }
         await shutdownCommandJobs(this.sessionId);
         this.commandJobsUnsubscribe?.();
         this.commandJobsUnsubscribe = undefined;
@@ -2402,11 +2856,15 @@ export class HeadlessApp {
         }
         this.embeddedController = null;
         this.benchController = null;
+        // Capture the producing agent before retiring its backend and identity.
+        this.sessionManager.getDiagnostics();
         // Reap the live agent's backend (a codex child now outlives each turn).
         this.agent?.dispose();
         // The worker executor holds a SEPARATE backend instance — reap it too.
         clearWorkerExecutor();
         this.agent = null;
+        await this.workspaceCoordinator?.close();
+        this.workspaceCoordinator = null;
     }
     outputHeadlessShellMode() {
         this.output({
@@ -2541,6 +2999,7 @@ export class HeadlessApp {
                             switch (classified.kind) {
                                 case 'prompt':
                                     assertPromptWithinLimit(classified.text);
+                                    this.dismissPendingQuestion();
                                     await this.runInteractivePrompt(classified.text);
                                     this.outputPromptComplete();
                                     break;
@@ -2575,8 +3034,24 @@ export class HeadlessApp {
                                     this.outputPromptComplete();
                                     break;
                                 case 'cancel':
+                                    this.dismissPendingQuestion();
                                     this.cancelActiveRun();
                                     break;
+                                case 'ask_user_answer':
+                                    if (this.pendingQuestionId !== classified.questionId) {
+                                        this.emitPaneChildNotice('Stale question answer ignored. No prompt was submitted.');
+                                        break;
+                                    }
+                                    assertPromptWithinLimit(classified.answer);
+                                    this.dismissPendingQuestion();
+                                    if (classified.answer === '__SKIP__') {
+                                        this.messages.push({ id: randomUUID(), role: 'user', content: '__SKIP__', timestamp: new Date() });
+                                    }
+                                    else {
+                                        await this.runInteractivePrompt(classified.answer);
+                                        this.outputPromptComplete();
+                                    }
+                                    break;
                                 case 'unknown_cmd':
                                     this.emitPaneChildNotice(`Unknown pane command "${classified.cmd}" — ignored.`);
                                     break;
@@ -2663,7 +3138,7 @@ export class HeadlessApp {
     async runSingle(prompt) {
         this.turnStartGoal = snapshotGoalForTurn();
         await this.runPrompt(prompt);
-        this.accountGoalFinalTurnAfterPrompt();
+        await this.accountGoalFinalTurnAfterPrompt();
         // If the prompt set/resumed an autonomous /goal, drive it to a terminal
         // state before exiting (no-op when there is no armed goal).
         await this.runGoalLoopIfArmed();
@@ -2736,10 +3211,22 @@ export class HeadlessApp {
      * auto-starts; the user runs /goal resume. Shared by both load branches.
      */
     applyResumedSession(session, restoreRuntimeMode = true) {
+        if (!session.hosted_settings)
+            configStore.restoreSessionSelection(session.metadata);
+        this.sessionToolResponseStore = new ToolResponseStore();
+        this.sessionToolResponseBinding = null;
         this.sessionId = session.metadata.id;
         this.sessionManager.setSessionId(this.sessionId);
+        this.sessionManager.restoreDiagnostics(session.diagnostics);
+        this.sessionManager.restoreUsageSnapshot(session.usage);
         this.sessionName = session.metadata.name;
+        this.sessionLabels = { ...session.metadata.labels, manual_title: this.sessionName };
         this.messages = session.messages;
+        this.taskHandoff = session.task_handoff ? projectTaskHandoff(session.task_handoff) : null;
+        this.restoredHandoffCorrections = session.task_handoff?.corrections.map(correction => ({
+            ...correction, deliveryState: correction.deliveryState === 'pending' ? 'unknown' : correction.deliveryState,
+        })) ?? [];
+        this.publishTaskHandoff();
         goalManager.hydrate(session.metadata.goal);
         if (!restoreRuntimeMode)
             return true;
@@ -2777,7 +3264,18 @@ export class HeadlessApp {
      * makes a second call in the same terminal episode a no-op, so this cannot
      * double-count with the goal loop's own accounting.
      */
-    accountGoalFinalTurnAfterPrompt() {
+    async accountGoalFinalTurnAfterPrompt() {
+        const initial = goalManager.accountSustainedFirstTurn({ turnTokens: this.lastTurnTokens,
+            ...(detectGoalBlocked(this.lastTurnText) ? { blockedReason: goalBlockedReason(this.lastTurnText) } : {}),
+            toolCallCount: this.lastTurnToolCalls, hadTextualOutput: this.lastTurnHadTextualOutput,
+            automaticGoalTurn: false, turnSummary: this.lastTurnText, ...this.lastTurnToolOutcome,
+            evidence: this.agent?.getEvidenceSnapshot() });
+        if (initial) {
+            if (initial.kind !== 'idle')
+                this.emitGoalNote(initial.note);
+            await this.saveCurrentSession();
+            return;
+        }
         if (!shouldAccountFinalTurn(this.turnStartGoal, goalManager.get()))
             return;
         const accounted = goalManager.accountFinalTurn({
@@ -2785,8 +3283,10 @@ export class HeadlessApp {
         });
         // Only report when this call did the accounting, so the tallies include the
         // final turn (the `/goal complete` command message fires before it is known).
-        if (accounted)
+        if (accounted) {
             this.emitGoalNote(goalFinalNote(accounted));
+            await this.saveCurrentSession();
+        }
     }
     /**
      * Run an interactive prompt, then drive any /goal it armed to a terminal state
@@ -2798,7 +3298,7 @@ export class HeadlessApp {
     async runInteractivePrompt(prompt) {
         this.turnStartGoal = snapshotGoalForTurn();
         await this.runPrompt(prompt);
-        this.accountGoalFinalTurnAfterPrompt();
+        await this.accountGoalFinalTurnAfterPrompt();
         await this.runGoalLoopIfArmed();
     }
     /**
@@ -2847,7 +3347,7 @@ export class HeadlessApp {
             // them in would attribute stale numbers to this turn.
             if (this.goalTurnCancelled) {
                 this.goalTurnCancelled = false;
-                goalManager.pause();
+                goalManager.pause('user_cancelled');
                 this.emitGoalNote(`⏸ Goal paused (cancelled): "${goal.objective}". /goal resume to continue.`);
                 break;
             }
@@ -2868,7 +3368,7 @@ export class HeadlessApp {
                 break;
             }
             // Provider-agnostic completion: the turn ended with the GOAL_COMPLETE sentinel.
-            if (detectGoalCompletion(this.lastTurnText)) {
+            if (!afterTurn.plateau && !afterTurn.sustained && detectGoalCompletion(this.lastTurnText)) {
                 const done = goalManager.complete({ turnTokens: this.lastTurnTokens });
                 if (done)
                     this.emitGoalNote(goalFinalNote(done));
@@ -2877,19 +3377,21 @@ export class HeadlessApp {
             // Provider-agnostic blocker: the turn ended with the GOAL_BLOCKED sentinel.
             // Terminal like completion — without it the loop keeps buying turns from an
             // agent that has already said it cannot get there.
-            if (detectGoalBlocked(this.lastTurnText)) {
+            if (!afterTurn.plateau && !afterTurn.sustained && detectGoalBlocked(this.lastTurnText)) {
                 const blocked = goalManager.block(goalBlockedReason(this.lastTurnText), { turnTokens: this.lastTurnTokens });
                 if (blocked)
                     this.emitGoalNote(goalFinalNote(blocked));
                 break;
             }
             const decision = goalManager.onTurnComplete({
+                ...(detectGoalBlocked(this.lastTurnText) ? { blockedReason: goalBlockedReason(this.lastTurnText) } : {}),
                 turnTokens: this.lastTurnTokens,
                 toolCallCount: this.lastTurnToolCalls,
                 hadTextualOutput: this.lastTurnHadTextualOutput,
                 automaticGoalTurn: this.lastTurnAutomaticGoal,
                 turnSummary: this.lastTurnText,
                 ...this.lastTurnToolOutcome,
+                evidence: this.agent?.getEvidenceSnapshot(),
             });
             if (decision.kind === 'continue') {
                 this.emitGoalNote(decision.note);
@@ -2907,7 +3409,13 @@ export class HeadlessApp {
         // goal as finished — not stale-'active', which would re-drive a done goal.
         await this.saveCurrentSession();
     }
+    publishCurrentGoal() {
+        const data = { sessionId: this.sessionId, goal: projectGoal(goalManager.get()) };
+        this.output({ type: 'goal', timestamp: new Date().toISOString(), data });
+        this.autoMirror?.publish({ type: 'goal', data });
+    }
     emitGoalNote(content) {
+        this.publishCurrentGoal();
         this.output({
             type: 'message',
             timestamp: new Date().toISOString(),
@@ -3050,7 +3558,7 @@ export async function runHeadless(options, initialPrompt) {
         initialized = await app.init();
     }
     catch (error) {
-        const message = error instanceof RouterConfigurationError ? error.message : 'Headless initialization failed.';
+        const message = error instanceof RouterConfigurationError || error instanceof EnvironmentRecoveryError ? error.message : 'Headless initialization failed.';
         if (options.json) {
             process.stdout.write(`${JSON.stringify({
                 type: 'error',