newmark-agent 0.5.14 → 0.5.15

package/dist/core/conversationKernel.js

@@ -38,15 +38,132 @@ class ConversationKernel {
         return () => this.listeners.delete(listener);
     }
     isRunning(target) {
-        return !!this.findRuntime(target)?.activePromise;
+        const runtime = this.findRuntime(target);
+        return !!runtime?.activePromise || runtime?.externalOwner?.active === true;
+    }
+    conversationOwner(target) {
+        return this.findRuntime(target)?.runner || null;
+    }
+    /** Branch mutations retain the Agent but reload that branch's durable queue. */
+    refreshIdleConversation(target) {
+        const previous = this.findRuntime(target);
+        if (!previous)
+            return;
+        if (this.isRunning(target) || previous.preparingArchive)
+            throw new Error('Cannot refresh a running conversation');
+        previous.preparingArchive = true;
+        this.finishArchive(target, true, true);
+        const restored = this.runtime(previous.target, previous.options, previous.runner);
+        restored.queuePaused = previous.queuePaused;
+        restored.externalOwner = previous.externalOwner;
+        restored.runId = previous.runId;
+        this.emitQueueUpdate(restored);
+    }
+    /** Detach idle owners before config replacement or workspace removal. */
+    disposeIdle(workspaceKey) {
+        const runtimes = Array.from(this.runtimes.values()).filter(runtime => !workspaceKey || runtime.target.workspaceKey === workspaceKey);
+        if (runtimes.some(runtime => runtime.activePromise || runtime.externalOwner || runtime.pendingNextTurn.length || runtime.runner.subagents.hasPendingWork())) {
+            throw new Error('Cannot release a conversation with running or queued work');
+        }
+        for (const runtime of runtimes) {
+            runtime.runner.flushWorkspaceConversationState();
+            runtime.preparingArchive = true;
+            this.finishArchive(runtime.target, true);
+        }
+        return runtimes.map(runtime => runtime.runtimeKey);
+    }
+    /** A Flow and its queue share one Agent; no second history writer is created. */
+    beginExternalRun(targetInput, options, createOwner, previousQueuePaused) {
+        const target = this.normalizeTarget(targetInput);
+        const existing = this.findRuntime(target);
+        if (existing?.activePromise || existing?.externalOwner?.active)
+            throw new Error('Target conversation is already running');
+        const runtime = existing || this.runtime(target, options, createOwner());
+        runtime.options = { ...options };
+        runtime.externalOwner = { active: true, wasPaused: runtime.externalOwner?.wasPaused ?? previousQueuePaused ?? runtime.queuePaused };
+        runtime.queuePaused = true;
+        runtime.runId ||= (0, crypto_1.randomUUID)();
+        runtime.stopRequestedRunId = '';
+        this.emitQueueUpdate(runtime);
+        return runtime.runner;
+    }
+    settleExternalRun(target, completed) {
+        const runtime = this.findRuntime(target);
+        if (!runtime?.externalOwner)
+            return;
+        const wasPaused = runtime.externalOwner.wasPaused;
+        if (completed)
+            runtime.externalOwner = undefined;
+        else
+            runtime.externalOwner.active = false;
+        runtime.queuePaused = completed && !runtime.preparingArchive ? wasPaused : true;
+        runtime.runner.saveWorkspaceConversationState(true);
+        this.emitQueueUpdate(runtime);
+        if (!runtime.queuePaused && runtime.pendingNextTurn.length)
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
+    }
+    releaseExternalRun(target, paused) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return;
+        if (runtime.externalOwner?.active)
+            throw new Error('Wait for the Flow to stop before releasing its queue');
+        runtime.externalOwner = undefined;
+        this.setQueuePaused(target, paused);
+    }
+    async prepareForArchive(target) {
+        const runtime = this.findRuntime(target);
+        if (!runtime)
+            return null;
+        if (runtime.runner.subagents.hasPendingWork())
+            throw new Error('Cannot archive a conversation with running or queued subagents');
+        runtime.preparingArchive = true;
+        runtime.queuePaused = true;
+        if (runtime.goalContinuationTimer)
+            clearTimeout(runtime.goalContinuationTimer);
+        runtime.goalContinuationTimer = undefined;
+        runtime.runner.abortActiveKernelRun('user_stop');
+        if (runtime.activePromise) {
+            runtime.stopRequestedRunId = runtime.runId;
+            try {
+                await runtime.activePromise;
+            }
+            catch { /* archive owns the terminal outcome */ }
+        }
+        runtime.runner.flushWorkspaceConversationState();
+        return runtime.runner;
+    }
+    finishArchive(target, completed, preserveOwner = false) {
+        const runtime = this.findRuntime(target);
+        if (!runtime?.preparingArchive)
+            return;
+        if (!completed) {
+            runtime.preparingArchive = false;
+            runtime.queuePaused = true;
+            return;
+        }
+        // Branch refresh reuses this facade immediately; terminal release must
+        // detach its shared-manager callbacks as well as the kernel subscriptions.
+        if (!preserveOwner)
+            runtime.runner.releaseConversationRuntimeBindings();
+        runtime.unsubscribe?.();
+        runtime.unsubscribePeer?.();
+        runtime.unsubscribeRootInboxWake?.();
+        runtime.unsubscribeUserMessageStart?.();
+        if (runtime.goalContinuationTimer)
+            clearTimeout(runtime.goalContinuationTimer);
+        this.runtimes.delete(runtime.runtimeKey);
     }
     isAnyRunning() {
         for (const runtime of this.runtimes.values()) {
-            if (runtime.activePromise)
+            if (runtime.activePromise || runtime.externalOwner?.active)
                 return true;
         }
         return false;
     }
+    hasRetainedWork() {
+        return Array.from(this.runtimes.values()).some(runtime => runtime.activePromise || runtime.externalOwner || runtime.pendingNextTurn.length || runtime.runner.subagents.hasPendingWork());
+    }
     flushPersistence() {
         this.host.flushWorkspaceConversationState();
         for (const runtime of this.runtimes.values())
@@ -81,10 +198,12 @@ class ConversationKernel {
         const visibleMode = message.visibleMode;
         return {
             text,
+            ...(message.userMessageId || message.clientMessageId ? { userMessageId: message.userMessageId || message.clientMessageId } : {}),
             ...(images?.length ? { images } : {}),
             ...(attachments?.length ? { attachments } : {}),
             ...(visible ? { visibleUserInput: visible } : {}),
             ...(visibleMode ? { visibleMode } : {}),
+            ...(message.goalObjective ? { goalObjective: message.goalObjective } : {}),
             // A normal user follow-up must never inherit the identity metadata that
             // was only needed while it lived in the runtime queue.  In particular,
             // do not let a stale/forwarded hiddenUserInput flag classify it as an
@@ -112,13 +231,15 @@ class ConversationKernel {
                     goalObjective: item.message.goalObjective,
                     runId: item.message.runId,
                     createdAt: String(item.message.createdAt || ''),
+                    images: item.message.images?.map(image => ({ ...image })),
                 }];
         });
     }
     enqueueNext(target, input) {
         const runtime = this.findRuntime(target);
-        if (!runtime?.activePromise || !runtime.runId)
-            throw new Error('Target conversation is not running');
+        if (!runtime)
+            throw new Error('Target conversation runtime is unavailable');
+        runtime.runId ||= (0, crypto_1.randomUUID)();
         const id = String(input.id || '').trim().slice(0, 200);
         const text = String(input.text || '').trim();
         if (!id || !text)
@@ -147,12 +268,18 @@ class ConversationKernel {
                 clientMessageId: id,
                 runId: runtime.runId,
                 createdAt,
+                images: input.images,
+                visibleUserInput: text,
+                visibleMode: String(input.requestedMode || 'build'),
+                goalObjective: input.goalObjective,
             }]);
         this.trackQueuedMessage(runtime, prompt, 'followUp');
         this.emitQueueUpdate(runtime);
+        if (!runtime.activePromise && !runtime.externalOwner && !runtime.queuePaused)
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
         return this.queueItems(runtime.target).find(item => item.id === id);
     }
-    updateQueueItem(target, idInput, textInput) {
+    updateQueueItem(target, idInput, textInput, input = {}) {
         const runtime = this.findRuntime(target);
         if (!runtime)
             throw new Error('Target conversation runtime is unavailable');
@@ -163,17 +290,26 @@ class ConversationKernel {
         const pending = runtime.pendingNextTurn.find(item => typeof item.message !== 'string' && item.message.clientMessageId === id);
         if (!pending || typeof pending.message === 'string')
             throw new Error('Queue item is no longer editable');
-        const oldPrompt = pending.message.text;
+        const previous = runtime.runner.conversationContinuations().find(item => item.clientMessageId === id);
         pending.message.text = `[Next queued while current turn is running]\n${text}`;
         pending.message.visibleUserInput = text;
-        runtime.runner.consumeConversationContinuation({ content: oldPrompt, queueMode: pending.queueMode, clientMessageId: id });
+        if (input.requestedMode !== undefined)
+            pending.message.visibleMode = input.requestedMode;
+        if (input.goalObjective !== undefined)
+            pending.message.goalObjective = input.goalObjective;
+        if (input.images !== undefined)
+            pending.message.images = input.images.map(image => ({ ...image }));
         runtime.runner.retainConversationContinuations([{
+                ...previous,
                 content: pending.message.text,
                 queueMode: pending.queueMode,
                 clientMessageId: id,
                 runId: pending.message.runId,
+                images: pending.message.images,
+                visibleUserInput: text,
+                visibleMode: pending.message.visibleMode,
+                goalObjective: pending.message.goalObjective,
             }]);
-        this.replaceTrackedQueuedMessage(runtime, oldPrompt, pending.message.text, pending.queueMode);
         this.emitQueueUpdate(runtime);
         return this.queueItems(runtime.target).find(item => item.id === id);
     }
@@ -188,7 +324,6 @@ class ConversationKernel {
         const [removed] = runtime.pendingNextTurn.splice(index, 1);
         if (typeof removed.message !== 'string') {
             runtime.runner.consumeConversationContinuation({ content: removed.message.text, queueMode: removed.queueMode, clientMessageId: id });
-            this.consumeQueuedMessage(runtime, removed.message.text);
         }
         this.emitQueueUpdate(runtime);
         return true;
@@ -237,6 +372,8 @@ class ConversationKernel {
         const runtime = this.findRuntime(target);
         if (!runtime)
             throw new Error('Target conversation runtime is unavailable');
+        if (!paused && runtime.externalOwner)
+            throw new Error('Release the Flow owner before resuming its queue');
         runtime.queuePaused = paused;
         this.emitQueueUpdate(runtime);
         if (!paused && !runtime.activePromise && runtime.pendingNextTurn.length) {
@@ -245,9 +382,12 @@ class ConversationKernel {
         return runtime.queuePaused;
     }
     queueAction(target, action, input = {}) {
-        const runtime = this.findRuntime(target);
-        if (!runtime)
-            throw new Error('Target conversation runtime is unavailable');
+        const normalized = this.normalizeTarget(target);
+        const runtime = this.findRuntime(normalized) || this.runtime(normalized, {
+            mode: this.host.mode, model: this.host.model, intelligence: this.host.intelligence,
+            inputMode: this.host.inputMode, engine: this.host.engine,
+        });
+        runtime.runId ||= (0, crypto_1.randomUUID)();
         let receipt;
         if (action === 'enqueue') {
             this.enqueueNext(runtime.target, {
@@ -260,7 +400,7 @@ class ConversationKernel {
             });
         }
         else if (action === 'update') {
-            this.updateQueueItem(runtime.target, String(input.id || ''), String(input.text || ''));
+            this.updateQueueItem(runtime.target, String(input.id || ''), String(input.text || ''), input);
         }
         else if (action === 'delete') {
             if (!this.deleteQueueItem(runtime.target, String(input.id || '')))
@@ -272,7 +412,12 @@ class ConversationKernel {
         else if (action === 'toggle_pause') {
             this.setQueuePaused(runtime.target, !runtime.queuePaused);
         }
+        else if (action === 'set_pause') {
+            this.setQueuePaused(runtime.target, input.paused === true);
+        }
         else if (action === 'guide') {
+            if (input.text !== undefined)
+                this.updateQueueItem(runtime.target, String(input.id || ''), input.text, input);
             const item = this.queueItems(runtime.target).find(entry => entry.id === String(input.id || ''));
             if (!item)
                 throw new Error('Queue item was not found');
@@ -284,6 +429,7 @@ class ConversationKernel {
                 deliveryMode: 'steer',
                 text: item.goalObjective ? `Goal for the current Build:\n${item.goalObjective}` : item.text,
                 goalObjective: item.goalObjective,
+                images: runtime.pendingNextTurn.find(entry => typeof entry.message !== 'string' && entry.message.clientMessageId === item.id)?.message?.images,
                 createdAt: item.createdAt || new Date().toISOString(),
             });
             if (receipt.status === 'rejected')
@@ -323,11 +469,18 @@ class ConversationKernel {
             options: question.options.map(option => ({ ...option })),
         })) : undefined;
     }
-    snapshot(target) {
+    snapshot(target, options = {}) {
         const normalized = this.normalizeTarget(target);
-        const runtime = this.findRuntime(normalized);
+        let runtime = this.findRuntime(normalized);
         const runner = runtime?.runner || this.createRunner(normalized);
-        const conversationSnapshot = runner.getConversationSnapshot(normalized.conversationId);
+        if (!runtime && runner.conversationContinuations().length) {
+            runtime = this.runtime(normalized, { mode: runner.mode, model: runner.model, intelligence: runner.intelligence, inputMode: runner.inputMode, engine: runner.engine }, runner);
+            // Recovered user input remains visible and manageable until its owner
+            // explicitly restores the persisted queue policy or resumes the queue.
+            runtime.queuePaused = true;
+            runtime.runId ||= (0, crypto_1.randomUUID)();
+        }
+        const conversationSnapshot = runner.getConversationSnapshot(normalized.conversationId, options);
         return {
             ...conversationSnapshot,
             workRuns: this.bindWorkRunsToRuntimeTarget(conversationSnapshot.workRuns, normalized),
@@ -398,7 +551,7 @@ class ConversationKernel {
         const canReactivateFinalizingRun = !runtime.activePromise
             && runtime.guideAcceptanceClosedRunId === runtime.runId
             && (!requestedRunId || requestedRunId === runtime.runId);
-        if (!runtime.activePromise && !canReactivateFinalizingRun) {
+        if (!runtime.activePromise && !runtime.externalOwner?.active && !canReactivateFinalizingRun) {
             return { ...base, reason: 'Target conversation is not running' };
         }
         let safeImages = [];
@@ -511,6 +664,12 @@ class ConversationKernel {
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
             return accepted;
         }
+        if (runtime.externalOwner) {
+            const rejected = { ...accepted, status: 'rejected', reason: 'The current Flow Build is not accepting Guide input.', updatedAt: new Date().toISOString() };
+            runtime.guideEnvelopes.delete(clientMessageId);
+            runtime.guideReceipts.set(clientMessageId, rejected);
+            return runtime.runner.recordGuideReceipt(rejected);
+        }
         const deferred = { ...accepted, status: 'deferred', updatedAt: new Date().toISOString() };
         runtime.guideReceipts.set(clientMessageId, deferred);
         runtime.runner.recordGuideReceipt(deferred);
@@ -561,7 +720,7 @@ class ConversationKernel {
     async compressContext(target, options = {}) {
         const normalized = this.normalizeTarget(target);
         const runtime = this.findRuntime(normalized);
-        if (runtime?.activePromise) {
+        if (runtime?.activePromise || runtime?.externalOwner?.active) {
             return { ok: false, error: 'Context compression is unavailable while this conversation is running.' };
         }
         const runner = runtime?.runner || this.createRunner(normalized);
@@ -613,8 +772,7 @@ class ConversationKernel {
         const normalized = this.normalizeTarget(target);
         const runtime = this.findRuntime(normalized);
         const runner = runtime?.runner || this.createRunner(normalized);
-        runner.setMode(mode);
-        runner.saveWorkspaceConversationState(true);
+        runner.selectConversationMode(mode);
         if (runtime)
             runtime.options.mode = mode;
         return runner.mode;
@@ -658,6 +816,18 @@ class ConversationKernel {
         this.mirrorHostIfTargetActive(runtime);
         return paused;
     }
+    updateGoal(target, objective) {
+        const normalized = this.normalizeTarget(target);
+        const runtime = this.findRuntime(normalized);
+        if (runtime?.activePromise || runtime?.externalOwner?.active)
+            throw new Error('Use Guide to change the Goal of a running conversation');
+        const runner = runtime?.runner || this.createRunner(normalized);
+        runner.updateGoal(objective);
+        runner.selectConversationMode('goal');
+        if (runtime)
+            runtime.options.mode = 'goal';
+        return runner.getConversationSnapshot(normalized.conversationId).goal;
+    }
     clearGoal(target) {
         const normalized = this.normalizeTarget(target);
         const runtime = this.findRuntime(normalized);
@@ -688,7 +858,7 @@ class ConversationKernel {
             runtimeKey: runtime.runtimeKey,
             runId: runtime.runId,
             generation: runtime.generation,
-            running: !!runtime.activePromise,
+            running: !!runtime.activePromise || runtime.externalOwner?.active === true,
             stopRequested: !!runtime.runId && runtime.stopRequestedRunId === runtime.runId,
             workRuns: this.bindWorkRunsToRuntimeTarget(runtime.runner.getConversationSnapshot(runtime.id).workRuns, runtime.target),
         };
@@ -697,16 +867,20 @@ class ConversationKernel {
         const normalized = this.normalizeTarget(target);
         const runtime = this.findRuntime(target);
         const runtimeKey = runtime?.runtimeKey || normalized.runtimeKey;
-        if (runtime && !runtime.activePromise && runtime.runId && runtime.stopRequestedRunId === runtime.runId) {
+        // A stale stop cannot pause another generation's peer scheduler or emit
+        // control messages before its target identity has been checked.
+        if (runtime && expectedRunId && expectedRunId !== runtime.runId) {
+            return { action: 'stale', runtimeKey, runId: runtime.runId, generation: runtime.generation, checkpointed: false };
+        }
+        const peerWork = !!runtime?.runner.subagents.hasPendingWork();
+        if (runtime && !runtime.activePromise && !runtime.runner.hasRunningSubagents() && runtime.runId && runtime.stopRequestedRunId === runtime.runId) {
             this.settleCooperativeStop(runtime, runtime.runId);
         }
-        if (!runtime?.activePromise || !runtime.runId) {
+        if (!runtime || (!runtime.activePromise && !peerWork) || !runtime.runId) {
             return { action: 'not_running', runtimeKey, runId: runtime?.runId || undefined, generation: runtime?.generation || undefined, checkpointed: false };
         }
-        if (expectedRunId && expectedRunId !== runtime.runId) {
-            return { action: 'stale', runtimeKey, runId: runtime.runId, generation: runtime.generation, checkpointed: false };
-        }
         if (runtime.stopRequestedRunId === runtime.runId && runtime.forceStopArmedRunId === runtime.runId) {
+            runtime.runner.abortActiveKernelRun('force_stop');
             runtime.runner.emitWorkEvent({
                 type: 'status',
                 content: 'Force stopping this conversation run.',
@@ -728,7 +902,7 @@ class ConversationKernel {
         runtime.runner.abortActiveKernelRun('user_stop');
         runtime.runner.emitWorkEvent({
             type: 'status',
-            content: 'Stop requested. Saving progress and interrupting this conversation.',
+            content: 'Stop requested for this conversation and all of its subagents. Saving progress and interrupting execution.',
             status: 'stopping',
             runId: runtime.runId,
         });
@@ -751,6 +925,12 @@ class ConversationKernel {
             runtime.unsubscribePeer();
         if (runtime?.unsubscribeRootInboxWake)
             runtime.unsubscribeRootInboxWake();
+        runtime?.unsubscribeUserMessageStart?.();
+        if (runtime) {
+            runtime.preparingArchive = true;
+            if (runtime.goalContinuationTimer)
+                clearTimeout(runtime.goalContinuationTimer);
+        }
         if (runtime)
             this.runtimes.delete(runtime.runtimeKey);
         const runner = runtime?.runner || this.createRunner(normalized);
@@ -759,6 +939,8 @@ class ConversationKernel {
     async prompt(message, target, options, queueMode = 'followUp') {
         const normalized = this.normalizeTarget(target);
         const active = this.findRuntime(normalized);
+        if (active?.preparingArchive)
+            throw new Error('This conversation is being archived');
         if (active?.activePromise) {
             // A Build block is already running: queue this message. Queued messages
             // carry no send-time model/mode; the running block keeps its settings and
@@ -819,7 +1001,7 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
-                    else if (!failed && !runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
+                    else if (!failed && !runtime.preparingArchive && !runtime.queuePaused && runtime.pendingNextTurn.length > 0) {
                         // A renderer/IPC Guide can arrive after the final-drain barrier's
                         // last check but before this promise settles. Do not leave the
                         // deferred continuation queued on an idle runtime.
@@ -827,7 +1009,7 @@ class ConversationKernel {
                     }
                 }
             }
-            if (!failed && !stopped && runtime.runId === runId)
+            if (!failed && !stopped && !runtime.preparingArchive && runtime.runId === runId)
                 this.scheduleGoalContinuation(runtime, runId);
             if (stopped) {
                 const settled = this.result(runtime, []);
@@ -928,7 +1110,14 @@ class ConversationKernel {
                 }
                 else {
                     const drained = this.drainQueuedFollowUpMessage(next.message);
-                    lastTokens = await this.runSingle(runtime, drained, next.queueMode);
+                    lastTokens = await this.runPendingQueueItem(runtime, next, async () => {
+                        if (typeof drained !== 'string' && drained.visibleMode && ['build', 'chat', 'plan', 'goal'].includes(drained.visibleMode)) {
+                            runtime.runner.setMode(drained.visibleMode);
+                            runtime.options.mode = drained.visibleMode;
+                        }
+                        this.activateAcceptedGoal(runtime, typeof drained === 'string' ? '' : drained.goalObjective);
+                        return this.runSingle(runtime, drained, next.queueMode, typeof next.message === 'string' ? undefined : next.message.clientMessageId);
+                    });
                     if (this.repeatedAutomaticAssistant(runtime, drained, next.queueMode))
                         break;
                 }
@@ -1021,32 +1210,28 @@ class ConversationKernel {
         runtime.runner.setModel(pending);
         runtime.options.model = runtime.runner.modelSelectionValue();
     }
-    async runSingle(runtime, message, continuationMode) {
-        this.syncPendingModel(runtime);
-        this.consumeQueuedMessage(runtime, typeof message === 'string' ? message : message.text);
+    async runSingle(runtime, message, continuationMode, continuationClientMessageId) {
+        // Display payloads intentionally omit queue identity. Keep the exact
+        // durable owner separately so equal text cannot consume another item.
+        const clientMessageId = continuationClientMessageId || (typeof message === 'string' ? undefined : message.clientMessageId || message.userMessageId);
+        const durable = clientMessageId
+            ? runtime.runner.conversationContinuations().find(item => item.clientMessageId === clientMessageId)
+            : undefined;
+        const consumedMode = continuationMode || durable?.queueMode;
+        const text = typeof message === 'string' ? message : message.text;
+        let accepted = false;
+        const unsubscribe = durable?.queueMode === 'followUp' && clientMessageId
+            ? runtime.runner.subscribeAgentKernelUserMessageStart((content, acceptedId) => {
+                if (acceptedId ? acceptedId === clientMessageId : content === text)
+                    accepted = true;
+            }) : undefined;
         const timeoutMs = this.processTimeoutMs(runtime);
-        if (timeoutMs <= 0) {
-            let tokens;
-            try {
-                tokens = await runtime.runner.process(message);
-            }
-            catch (error) {
-                this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
-                throw error;
-            }
-            if (continuationMode)
-                runtime.runner.consumeConversationContinuation({
-                    content: typeof message === 'string' ? message : message.text,
-                    queueMode: continuationMode,
-                    clientMessageId: typeof message === 'string' ? undefined : message.clientMessageId,
-                });
-            return tokens;
-        }
         let timeout;
         try {
-            let tokens;
-            try {
-                tokens = await Promise.race([
+            this.syncPendingModel(runtime);
+            this.consumeQueuedMessage(runtime, text);
+            const tokens = timeoutMs <= 0 ? await runtime.runner.process(message)
+                : await Promise.race([
                     runtime.runner.process(message),
                     new Promise((_, reject) => {
                         timeout = setTimeout(() => {
@@ -1065,22 +1250,27 @@ class ConversationKernel {
                         }, timeoutMs);
                     }),
                 ]);
+            if (unsubscribe && !accepted) {
+                // Workspace/attachment rejection can resolve error tokens without
+                // accepting input. Resolution alone must not remove a queued row.
+                throw new Error('Queued input was not accepted; it remains paused for correction or retry.');
             }
-            catch (error) {
-                this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
-                throw error;
-            }
-            if (continuationMode)
+            if (consumedMode)
                 runtime.runner.consumeConversationContinuation({
                     content: typeof message === 'string' ? message : message.text,
-                    queueMode: continuationMode,
-                    clientMessageId: typeof message === 'string' ? undefined : message.clientMessageId,
+                    queueMode: consumedMode,
+                    clientMessageId,
                 });
             return tokens;
         }
+        catch (error) {
+            this.consumeFailedAutomaticContinuation(runtime, message, continuationMode);
+            throw error;
+        }
         finally {
             if (timeout)
                 clearTimeout(timeout);
+            unsubscribe?.();
         }
     }
     consumeFailedAutomaticContinuation(runtime, message, continuationMode) {
@@ -1141,13 +1331,18 @@ class ConversationKernel {
         });
         for (const continuation of runner.conversationContinuations()) {
             runtime.pendingNextTurn.push({
-                message: continuation.clientMessageId || continuation.images?.length
+                message: continuation.clientMessageId || continuation.images?.length || continuation.hiddenUserInput
                     ? {
                         text: continuation.content,
                         images: continuation.images,
                         attachments: continuation.attachments,
                         clientMessageId: continuation.clientMessageId,
                         runId: continuation.runId,
+                        visibleUserInput: continuation.visibleUserInput,
+                        visibleMode: continuation.visibleMode,
+                        goalObjective: continuation.goalObjective,
+                        createdAt: continuation.createdAt,
+                        hiddenUserInput: continuation.hiddenUserInput,
                     }
                     : continuation.content,
                 queueMode: continuation.queueMode,
@@ -1155,6 +1350,8 @@ class ConversationKernel {
             this.trackQueuedMessage(runtime, continuation.content, continuation.queueMode);
         }
         runtime.unsubscribe = runner.subscribeWorkEvents(event => {
+            if (runtime.externalOwner?.active && event.runId)
+                runtime.runId = event.runId;
             const routedEvent = {
                 ...event,
                 conversationId: runtime.target.conversationId,
@@ -1177,7 +1374,7 @@ class ConversationKernel {
             for (const listener of this.listeners)
                 listener(event);
         });
-        runner.subscribeAgentKernelUserMessageStart((content, clientMessageId) => {
+        runtime.unsubscribeUserMessageStart = runner.subscribeAgentKernelUserMessageStart((content, clientMessageId) => {
             this.consumeQueuedMessage(runtime, content);
             if (!clientMessageId)
                 return;
@@ -1194,11 +1391,26 @@ class ConversationKernel {
             runtime.runner.recordGuideReceipt(applied);
             runtime.guideEnvelopes.delete(clientMessageId);
         });
-        runtime.unsubscribeRootInboxWake = runner.subscribeRootInboxWake(message => {
-            this.enqueueRootInboxWake(runtime, message);
+        runtime.unsubscribeRootInboxWake = runner.subscribeRootInboxWake((message, options) => {
+            this.enqueueRootInboxWake(runtime, message, options?.wakeup !== false);
             return true;
+        }, ids => {
+            const retired = new Set(ids);
+            const before = runtime.pendingNextTurn.length;
+            runtime.pendingNextTurn = runtime.pendingNextTurn.filter(item => {
+                if (item.queueMode !== 'followUp' || typeof item.message === 'string'
+                    || !item.message.hiddenUserInput || item.message.clientMessageId)
+                    return true;
+                const id = item.message.text.match(/^\[Root subagent inbox id=([0-9a-f-]{36})\b/i)?.[1];
+                return !id || !retired.has(id);
+            });
+            if (runtime.pendingNextTurn.length !== before)
+                this.emitQueueUpdate(runtime);
         });
         this.runtimes.set(target.runtimeKey, runtime);
+        // An already-read inbox entry is not replayed by the mailbox listener.
+        // Reconcile saved result receipts after hydrating its continuation copy.
+        runner.acknowledgeSubagentSettlementReceipts();
         return runtime;
     }
     scheduleGoalContinuation(runtime, completedRunId) {
@@ -1207,7 +1419,7 @@ class ConversationKernel {
         runtime.runner.flushWorkspaceConversationState();
         runtime.goalContinuationTimer = setTimeout(() => {
             runtime.goalContinuationTimer = undefined;
-            if (runtime.runId !== completedRunId || runtime.activePromise)
+            if (runtime.preparingArchive || runtime.runId !== completedRunId || runtime.activePromise)
                 return;
             this.queueState(runtime);
             if (runtime.pendingNextTurn.length > 0
@@ -1238,19 +1450,64 @@ class ConversationKernel {
         }
         setImmediate(() => {
             runtime.pendingContinuationRunId = undefined;
-            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId || runtime.queuePaused)
+            if (runtime.preparingArchive || runtime.runId !== runId || runtime.activePromise || runtime.externalOwner || runtime.stopRequestedRunId === runId || runtime.queuePaused)
                 return;
             const next = runtime.pendingNextTurn.shift();
             if (!next)
                 return;
-            const message = typeof next.message === 'string'
-                ? { text: next.message, runId }
-                : { ...next.message, runId: next.message.runId || runId };
-            void this.prompt(message, runtime.target, runtime.options, next.queueMode).catch(() => {
+            const delivery = next.queueMode === 'followUp' ? this.drainQueuedFollowUpMessage(next.message) : next.message;
+            const message = typeof delivery === 'string'
+                ? { text: delivery, runId }
+                : { ...delivery, runId: delivery.runId || runId };
+            void this.runPendingQueueItem(runtime, next, async () => {
+                if (message.visibleMode && ['build', 'chat', 'plan', 'goal'].includes(message.visibleMode)) {
+                    this.setMode(runtime.target, message.visibleMode);
+                }
+                return this.prompt(message, runtime.target, runtime.options, next.queueMode);
+            }).catch(() => {
                 // Agent.process and the work-run finalizer already publish the error.
             });
         });
     }
+    async runPendingQueueItem(runtime, next, execute) {
+        const queuedMessage = typeof next.message === 'string' ? undefined : next.message;
+        const id = queuedMessage?.clientMessageId;
+        if (next.queueMode !== 'followUp' || !id)
+            return execute();
+        let accepted = false;
+        const unsubscribe = runtime.runner.subscribeAgentKernelUserMessageStart((content, clientMessageId) => {
+            // Normal in-run dequeues omit display identity, but retain the exact
+            // execution text. Never let an unrelated Guide accept this queue row.
+            if (clientMessageId ? clientMessageId === id : content === queuedMessage.text)
+                accepted = true;
+        });
+        try {
+            return await execute();
+        }
+        catch (error) {
+            // Model/title/setup failures before user-message acceptance must leave
+            // the same row manageable. A provider failure after acceptance must
+            // never replay the already submitted user input after restart/resume.
+            runtime.queuePaused = true;
+            throw error;
+        }
+        finally {
+            unsubscribe();
+            if (accepted)
+                runtime.runner.consumeConversationContinuation({
+                    content: queuedMessage.text, clientMessageId: id, queueMode: 'followUp',
+                });
+            else if (runtime.runner.conversationContinuations().some(item => item.clientMessageId === id && item.queueMode === 'followUp')) {
+                // Cooperative Stop can turn a rejected process into a resolved outer
+                // result. Restore on every unaccepted exit, including failed archive;
+                // the pause/archive guards still prevent any automatic execution.
+                if (!runtime.pendingNextTurn.some(item => typeof item.message !== 'string' && item.message.clientMessageId === id))
+                    runtime.pendingNextTurn.unshift(next);
+                runtime.queuePaused = true;
+            }
+            this.emitQueueUpdate(runtime);
+        }
+    }
     startGoalDrivenBuild(runtime) {
         if (runtime.goalContinuationTimer) {
             clearTimeout(runtime.goalContinuationTimer);
@@ -1294,17 +1551,22 @@ class ConversationKernel {
         runner.ensureConversationSnapshot(target.conversationId);
         return runner;
     }
-    enqueueRootInboxWake(runtime, message) {
+    enqueueRootInboxWake(runtime, message, wakeup = false) {
+        const acceptedWhileActive = !!runtime.activePromise;
         queueMicrotask(() => {
             const rootInboxId = message.match(/^\[Root subagent inbox id=([0-9a-f-]{36})\b/i)?.[1];
             if (rootInboxId && !runtime.runner.subagents.readRootInbox().some(item => item.id === rootInboxId))
                 return;
+            if (runtime.queuePaused || runtime.runner.subagents.isSchedulingPaused())
+                return;
             if (runtime.activePromise) {
                 if (!runtime.pendingNextTurn.some(item => typeof item.message === 'string' ? item.message === message : item.message.text === message)) {
                     runtime.pendingNextTurn.push({ message: { text: message, hiddenUserInput: true }, queueMode: 'followUp' });
                 }
                 return;
             }
+            if (!wakeup && !acceptedWhileActive)
+                return;
             void this.prompt({ text: message, hiddenUserInput: true }, runtime.target, runtime.options, 'followUp').catch(error => {
                 runtime.runner.recordWorkStatus(`Subagent result follow-up failed: ${error instanceof Error ? error.message : String(error)}`);
             });
@@ -1427,6 +1689,9 @@ class ConversationKernel {
                     images: queuedMessage.images?.map(image => ({ ...image })),
                     attachments: queuedMessage.attachments?.map(attachment => ({ ...attachment })),
                     createdAt: queuedMessage.createdAt,
+                    visibleUserInput: queuedMessage.visibleUserInput,
+                    visibleMode: queuedMessage.visibleMode,
+                    goalObjective: queuedMessage.goalObjective,
                 }]);
             this.trackQueuedMessage(runtime, prompt, 'followUp');
             runtime.runner.recordWorkStatus(runtime.stopRequestedRunId === runtime.runId
@@ -1475,13 +1740,13 @@ class ConversationKernel {
     }
     trackQueuedMessage(runtime, message, queueMode) {
         this.queueState(runtime);
-        const list = queueMode === 'steer' ? runtime.queued.steering : runtime.queued.followUp;
-        list.push(message);
+        if (queueMode === 'steer')
+            runtime.queued.steering.push(message);
     }
     consumeQueuedMessage(runtime, message) {
         this.queueState(runtime);
         let changed = false;
-        for (const key of ['steering', 'followUp']) {
+        for (const key of ['steering']) {
             const index = runtime.queued[key].indexOf(message);
             if (index >= 0) {
                 runtime.queued[key].splice(index, 1);
@@ -1491,13 +1756,6 @@ class ConversationKernel {
         if (changed)
             this.emitQueueUpdate(runtime);
     }
-    replaceTrackedQueuedMessage(runtime, oldMessage, nextMessage, queueMode) {
-        this.queueState(runtime);
-        const list = queueMode === 'steer' ? runtime.queued.steering : runtime.queued.followUp;
-        const index = list.indexOf(oldMessage);
-        if (index >= 0)
-            list[index] = nextMessage;
-    }
     emitQueueUpdate(runtime) {
         this.queueState(runtime);
         runtime.runner.emitWorkEvent({
@@ -1524,8 +1782,14 @@ class ConversationKernel {
             runtime.queued = { steering: [], followUp: [] };
         if (!Array.isArray(runtime.queued.steering))
             runtime.queued.steering = [];
-        if (!Array.isArray(runtime.queued.followUp))
-            runtime.queued.followUp = [];
+        // Follow-up order belongs to the pending entries, not a second text-only
+        // ledger. Repeated text, edits and user-message-start callbacks must not
+        // independently remove/reorder that projection. Internal auto-continuations
+        // without user identity remain outside the visible user queue.
+        runtime.queued.followUp = runtime.pendingNextTurn
+            .filter(item => item.queueMode === 'followUp' && (typeof item.message === 'string'
+            || item.message.hiddenUserInput !== true || !!item.message.clientMessageId))
+            .map(item => typeof item.message === 'string' ? item.message : item.message.text);
         return runtime;
     }
     normalizeTarget(input) {