devchain-cli 0.20.3 → 0.22.0

package/dist/server/modules/sessions/services/sessions-message-pool.service.js

@@ -12,8 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionsMessagePoolService = exports.FAILURE_NOTICE_SOURCE = void 0;
+exports.SessionsMessagePoolService = exports.HUMAN_DRAFT_IDLE_GRACE_MS = exports.FAILURE_NOTICE_SOURCE = void 0;
 const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
 const crypto_1 = require("crypto");
 const sessions_service_1 = require("./sessions.service");
 const session_coordinator_service_1 = require("./session-coordinator.service");
@@ -25,10 +26,21 @@ const storage_interface_1 = require("../../storage/interfaces/storage.interface"
 const logger_1 = require("../../../common/logging/logger");
 const terminal_io_service_1 = require("../../terminal/services/terminal-io/terminal-io.service");
 const provider_adapter_factory_1 = require("../../providers/adapters/provider-adapter.factory");
+const message_pool_types_1 = require("./message-pool.types");
+const session_human_prompt_state_changed_1 = require("../../events/catalog/session.human-prompt-state-changed");
+const human_prompt_state_service_1 = require("../../terminal/services/human-prompt-state.service");
 const delivery_failure_disclosure_1 = require("./delivery-failure-disclosure");
-var message_pool_types_1 = require("./message-pool.types");
-Object.defineProperty(exports, "FAILURE_NOTICE_SOURCE", { enumerable: true, get: function () { return message_pool_types_1.FAILURE_NOTICE_SOURCE; } });
+var message_pool_types_2 = require("./message-pool.types");
+Object.defineProperty(exports, "FAILURE_NOTICE_SOURCE", { enumerable: true, get: function () { return message_pool_types_2.FAILURE_NOTICE_SOURCE; } });
 const logger = (0, logger_1.createLogger)('SessionsMessagePoolService');
+exports.HUMAN_DRAFT_IDLE_GRACE_MS = 2_000;
+function canStartDeferredClaimMutation(claim) {
+    return claim.state.phase === 'preparing' && !claim.state.cancellationReason;
+}
+function deferredClaimCancellationResult(claim, discardedCount) {
+    const reason = claim?.state.phase === 'preparing' ? claim.state.cancellationReason : undefined;
+    return reason ? { success: false, discardedCount, reason } : null;
+}
 const DEFAULT_CONFIG = {
     enabled: true,
     delayMs: 10000,
@@ -46,9 +58,12 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     providerAdapterFactory;
     messageLog;
     failureNotifier;
+    humanPromptState;
     pools = new Map();
+    deferredLanes = new Map();
     config;
-    constructor(sessions, coordinator, terminalIO, settings, storage, activityStream, providerAdapterFactory, messageLog, failureNotifier) {
+    closing = false;
+    constructor(sessions, coordinator, terminalIO, settings, storage, activityStream, providerAdapterFactory, messageLog, failureNotifier, humanPromptState) {
         this.sessions = sessions;
         this.coordinator = coordinator;
         this.terminalIO = terminalIO;
@@ -58,6 +73,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         this.providerAdapterFactory = providerAdapterFactory;
         this.messageLog = messageLog;
         this.failureNotifier = failureNotifier;
+        this.humanPromptState = humanPromptState;
         this.config = this.loadConfigFromSettings();
         logger.info({ config: this.config }, 'SessionsMessagePoolService initialized with config');
     }
@@ -108,6 +124,12 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             a.maxMessages === b.maxMessages &&
             a.separator === b.separator);
     }
+    resolveDeliveryMode(options) {
+        if ((0, message_pool_types_1.isMessageDeliveryMode)(options.deliveryMode)) {
+            return options.deliveryMode;
+        }
+        return (0, message_pool_types_1.deliveryModeFromLegacyImmediate)(options.immediate);
+    }
     resetPoolTimers(agentId, pool, newConfig) {
         if (pool.timer) {
             clearTimeout(pool.timer);
@@ -142,13 +164,35 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         }, remaining);
     }
     async enqueue(agentId, text, options = {}) {
-        const { source = 'unknown', submitKeys = ['Enter'], preKeys, preDelayMs, senderAgentId, immediate = false, clientMessageId, failureDisclosure = 'legacy', } = options;
+        const { source = 'unknown', submitKeys = ['Enter'], preKeys, preDelayMs, senderAgentId, clientMessageId, failureDisclosure = 'legacy', } = options;
         const { projectId, agentName } = await this.resolveProjectInfo(agentId, options);
-        const projectConfig = this.getConfigForProject(projectId, failureDisclosure);
         const logEntryId = (0, crypto_1.randomUUID)();
         const timestamp = Date.now();
-        if (immediate || !projectConfig.enabled) {
-            const reason = immediate ? 'immediate flag' : 'pooling disabled';
+        const deliveryMode = this.resolveDeliveryMode(options);
+        if (options.deferWhileHumanTyping || options.humanPromptSubmit || deliveryMode === 'on_idle') {
+            return this.enqueueSerialized({
+                agentId,
+                text,
+                source,
+                submitKeys,
+                preKeys,
+                preDelayMs,
+                senderAgentId,
+                clientMessageId,
+                failureDisclosure,
+                projectId,
+                agentName,
+                logEntryId,
+                timestamp,
+                deliveryMode,
+                deferWhileHumanTyping: options.deferWhileHumanTyping === true,
+                humanPromptSubmit: options.humanPromptSubmit === true,
+            });
+        }
+        const projectConfig = this.getConfigForProject(projectId, failureDisclosure);
+        const immediateDelivery = deliveryMode === 'immediate';
+        if (immediateDelivery || !projectConfig.enabled) {
+            const reason = immediateDelivery ? 'delivery mode' : 'pooling disabled';
             logger.debug({ agentId, projectId, source, reason }, 'Bypassing pool, delivering immediately');
             const logEntry = {
                 id: logEntryId,
@@ -175,7 +219,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             this.broadcastPoolsUpdate();
             try {
                 const { nonce: deliveredNonce, unconfirmed, skipped, retryCount, } = await this.deliverMessage(agentId, text, submitKeys, {
-                    skipConfirmation: immediate,
+                    skipConfirmation: immediateDelivery,
                     preKeys,
                     preDelayMs,
                 });
@@ -316,29 +360,288 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         }, pool.config.delayMs);
         return { status: 'queued', poolSize: pool.messages.length, logEntryId };
     }
+    async enqueueSerialized(input) {
+        while (true) {
+            const step = await this.coordinator.withAgentLock(input.agentId, async () => {
+                const activeSession = this.sessions.getActiveSessionForAgent(input.agentId);
+                const existingLane = this.deferredLanes.get(input.agentId);
+                if (existingLane && existingLane.sessionId !== activeSession?.id) {
+                    return {
+                        detachment: this.detachDeferredLaneUnderAgentLock(existingLane, 'Target session was replaced before deferred delivery'),
+                    };
+                }
+                const result = await this.enqueueSerializedUnderAgentLock(input);
+                const claim = result.status === 'queued' &&
+                    input.deliveryMode === 'on_idle' &&
+                    activeSession?.activityState === 'idle'
+                    ? this.claimDeferredLaneUnderAgentLock(input.agentId, activeSession.id, false)
+                    : null;
+                return { result, claim };
+            });
+            if ('result' in step) {
+                if (!step.claim)
+                    return step.result;
+                const flushResult = await this.deliverDeferredClaim(step.claim);
+                if (!flushResult.success) {
+                    return { status: 'failed', error: flushResult.reason, logEntryId: input.logEntryId };
+                }
+                if (flushResult.deliveredCount === 0) {
+                    const logEntry = this.messageLog.getById(input.logEntryId);
+                    return {
+                        status: logEntry?.status ?? 'queued',
+                        ...(logEntry?.error ? { error: logEntry.error } : {}),
+                        logEntryId: input.logEntryId,
+                    };
+                }
+                return {
+                    status: flushResult.outcome === 'unconfirmed' ? 'unconfirmed' : 'delivered',
+                    logEntryId: input.logEntryId,
+                };
+            }
+            await this.settleDeferredLaneDetachment(step.detachment);
+        }
+    }
+    async enqueueSerializedUnderAgentLock(input) {
+        const duplicate = this.findDuplicate(input);
+        if (duplicate)
+            return duplicate;
+        const projectConfig = this.getConfigForProject(input.projectId, input.failureDisclosure);
+        const activeSession = this.sessions.getActiveSessionForAgent(input.agentId);
+        const promptState = activeSession?.tmuxSessionId
+            ? this.humanPromptState.getState(activeSession.tmuxSessionId)
+            : null;
+        const heldGeneration = input.deferWhileHumanTyping && promptState && promptState.phase !== 'inactive'
+            ? promptState.generation
+            : undefined;
+        if (heldGeneration !== undefined || input.deliveryMode === 'on_idle') {
+            return this.enqueueDeferredUnderAgentLock(input, projectConfig, activeSession, heldGeneration);
+        }
+        if (input.humanPromptSubmit || input.deliveryMode === 'immediate' || !projectConfig.enabled) {
+            const logEntry = this.createLogEntry(input, true);
+            this.messageLog.addEntry(logEntry);
+            this.activityStream.broadcastEnqueued(logEntry);
+            this.broadcastPoolsUpdate();
+            return this.deliverImmediateUnderAgentLock(input, logEntry);
+        }
+        return this.enqueueProtectedPoolUnderAgentLock(input, projectConfig);
+    }
+    findDuplicate(input) {
+        if (!input.clientMessageId)
+            return null;
+        const existing = this.messageLog.findByClientMessageId(input.clientMessageId, input.agentId, input.source);
+        return existing ? { status: existing.status, logEntryId: existing.id } : null;
+    }
+    createLogEntry(input, immediate) {
+        return {
+            id: input.logEntryId,
+            timestamp: input.timestamp,
+            projectId: input.projectId,
+            agentId: input.agentId,
+            agentName: input.agentName,
+            text: input.text,
+            source: input.source,
+            senderAgentId: input.senderAgentId,
+            clientMessageId: input.clientMessageId,
+            status: 'queued',
+            immediate,
+        };
+    }
+    createPooledMessage(input, options) {
+        return {
+            text: input.text,
+            source: input.source,
+            timestamp: input.timestamp,
+            submitKeys: input.submitKeys,
+            senderAgentId: input.senderAgentId,
+            logEntryId: input.logEntryId,
+            clientMessageId: input.clientMessageId,
+            failureDisclosure: input.failureDisclosure,
+            deferWhileHumanTyping: input.deferWhileHumanTyping,
+            requiresProviderIdle: options?.requiresProviderIdle === true,
+            heldGeneration: options?.heldGeneration,
+        };
+    }
+    async enqueueProtectedPoolUnderAgentLock(input, projectConfig) {
+        if (this.getSharedQueuedCount(input.agentId) >= projectConfig.maxMessages) {
+            return this.capacityFailure(input.failureDisclosure);
+        }
+        let pool = this.pools.get(input.agentId);
+        if (!pool) {
+            pool = this.createAgentPool(input.agentId, input.projectId, projectConfig);
+        }
+        else if (!this.configsEqual(pool.config, projectConfig)) {
+            pool.config = projectConfig;
+            if (pool.messages.length > 0)
+                this.resetPoolTimers(input.agentId, pool, projectConfig);
+        }
+        const logEntry = this.createLogEntry(input, false);
+        this.messageLog.addEntry(logEntry);
+        pool.messages.push(this.createPooledMessage(input));
+        this.activityStream.broadcastEnqueued(logEntry);
+        this.broadcastPoolsUpdate();
+        if (pool.messages.length >= pool.config.maxMessages) {
+            const result = await this.flushPoolUnderAgentLock(input.agentId);
+            if (!result.success)
+                return { status: 'failed', error: result.reason };
+            if (result.outcome === 'deferred') {
+                return {
+                    status: 'queued',
+                    poolSize: this.getSharedQueuedCount(input.agentId),
+                    logEntryId: input.logEntryId,
+                };
+            }
+            return {
+                status: result.outcome === 'unconfirmed' ? 'unconfirmed' : 'delivered',
+                logEntryId: input.logEntryId,
+            };
+        }
+        this.schedulePoolDebounce(input.agentId, pool);
+        return {
+            status: 'queued',
+            poolSize: this.getSharedQueuedCount(input.agentId),
+            logEntryId: input.logEntryId,
+        };
+    }
+    async enqueueDeferredUnderAgentLock(input, projectConfig, activeSession, heldGeneration) {
+        if (!activeSession?.tmuxSessionId) {
+            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, 'No active session', 'no_active_session');
+            return { status: 'failed', error: failure.error };
+        }
+        if (this.getSharedQueuedCount(input.agentId) >= projectConfig.maxMessages) {
+            return this.capacityFailure(input.failureDisclosure);
+        }
+        let lane = this.deferredLanes.get(input.agentId);
+        if (!lane) {
+            lane = {
+                sessionId: activeSession.id,
+                tmuxSessionName: activeSession.tmuxSessionId,
+                agentId: input.agentId,
+                projectId: input.projectId,
+                messages: [],
+                separator: projectConfig.separator,
+                requiredGeneration: heldGeneration ?? null,
+                quietTimer: null,
+                quietBaseline: null,
+                activeClaim: null,
+            };
+            this.deferredLanes.set(input.agentId, lane);
+        }
+        lane.separator = projectConfig.separator;
+        const logEntry = this.createLogEntry(input, input.deliveryMode === 'immediate' || !projectConfig.enabled);
+        const message = this.createPooledMessage(input, {
+            requiresProviderIdle: input.deliveryMode === 'on_idle',
+            heldGeneration,
+        });
+        this.messageLog.addEntry(logEntry);
+        lane.messages.push(message);
+        if (heldGeneration !== undefined)
+            this.rebindLaneGeneration(lane, heldGeneration);
+        this.activityStream.broadcastEnqueued(logEntry);
+        this.broadcastPoolsUpdate();
+        if (lane.requiredGeneration !== null) {
+            this.ensureHumanQuietTimerUnderAgentLock(lane);
+        }
+        return {
+            status: 'queued',
+            poolSize: this.getSharedQueuedCount(input.agentId),
+            logEntryId: input.logEntryId,
+        };
+    }
+    capacityFailure(failureDisclosure) {
+        const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(failureDisclosure, 'Message pool capacity reached', 'pool_capacity_exceeded');
+        return { status: 'failed', error: failure.error };
+    }
+    getSharedQueuedCount(agentId) {
+        return ((this.pools.get(agentId)?.messages.length ?? 0) +
+            (this.deferredLanes.get(agentId)?.messages.length ?? 0));
+    }
+    createAgentPool(agentId, projectId, config) {
+        const pool = {
+            messages: [],
+            timer: null,
+            maxWaitTimer: null,
+            firstEnqueueTime: Date.now(),
+            config,
+            projectId,
+        };
+        this.pools.set(agentId, pool);
+        pool.maxWaitTimer = setTimeout(() => {
+            void this.flushNow(agentId);
+        }, config.maxWaitMs);
+        return pool;
+    }
+    schedulePoolDebounce(agentId, pool) {
+        if (pool.timer)
+            clearTimeout(pool.timer);
+        pool.timer = setTimeout(() => {
+            void this.flushNow(agentId);
+        }, pool.config.delayMs);
+    }
     async flushNow(agentId) {
+        while (true) {
+            const step = await this.coordinator.withAgentLock(agentId, async () => {
+                const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+                const existingLane = this.deferredLanes.get(agentId);
+                if (existingLane && existingLane.sessionId !== activeSession?.id) {
+                    return {
+                        detachment: this.detachDeferredLaneUnderAgentLock(existingLane, 'Target session was replaced before deferred delivery'),
+                    };
+                }
+                return { result: await this.flushPoolUnderAgentLock(agentId) };
+            });
+            if ('result' in step)
+                return step.result;
+            await this.settleDeferredLaneDetachment(step.detachment);
+        }
+    }
+    async flushPoolUnderAgentLock(agentId) {
         const pool = this.pools.get(agentId);
         if (!pool || pool.messages.length === 0) {
-            logger.debug({ agentId }, 'No messages to flush');
             return { success: true, deliveredCount: 0 };
         }
-        if (pool.timer) {
-            clearTimeout(pool.timer);
-            pool.timer = null;
+        this.clearPoolTimers(pool);
+        this.pools.delete(agentId);
+        const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+        const promptState = activeSession?.tmuxSessionId
+            ? this.humanPromptState.getState(activeSession.tmuxSessionId)
+            : null;
+        const protectedMessages = promptState?.phase !== 'inactive'
+            ? pool.messages.filter((message) => message.deferWhileHumanTyping)
+            : [];
+        const deliverableMessages = protectedMessages.length > 0
+            ? pool.messages.filter((message) => !message.deferWhileHumanTyping)
+            : [...pool.messages];
+        if (protectedMessages.length > 0 &&
+            activeSession?.tmuxSessionId &&
+            promptState &&
+            !this.closing) {
+            await this.moveMessagesToDeferredLaneUnderAgentLock(agentId, pool.projectId, pool.config.separator, activeSession, protectedMessages, promptState.generation);
         }
-        if (pool.maxWaitTimer) {
-            clearTimeout(pool.maxWaitTimer);
-            pool.maxWaitTimer = null;
+        else if (protectedMessages.length > 0 && this.closing) {
+            await this.failDeferredLane({
+                sessionId: activeSession?.id ?? 'shutdown',
+                tmuxSessionName: activeSession?.tmuxSessionId ?? 'shutdown',
+                agentId,
+                projectId: pool.projectId,
+                messages: protectedMessages,
+                separator: pool.config.separator,
+                requiredGeneration: promptState?.generation ?? null,
+                quietTimer: null,
+                quietBaseline: null,
+                activeClaim: null,
+            }, 'Service stopped before human-held delivery', false);
         }
-        const messages = [...pool.messages];
-        const poolConfig = pool.config;
-        this.pools.delete(agentId);
-        logger.info({ agentId, projectId: pool.projectId, messageCount: messages.length }, 'Flushing message pool');
-        let result = { success: true, deliveredCount: messages.length };
-        await this.coordinator.withAgentLock(agentId, async () => {
-            result = await this.deliverBatch(agentId, messages, poolConfig.separator);
-        });
-        return result;
+        if (deliverableMessages.length === 0) {
+            this.broadcastPoolsUpdate();
+            return this.closing
+                ? {
+                    success: false,
+                    discardedCount: protectedMessages.length,
+                    reason: 'Service stopped before human-held delivery',
+                }
+                : { success: true, deliveredCount: 0, outcome: 'deferred' };
+        }
+        return this.deliverBatch(agentId, deliverableMessages, pool.config.separator);
     }
     async flushAll() {
         const pendingPools = Array.from(this.pools.entries()).map(([agentId, pool]) => ({
@@ -352,26 +655,36 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     }
     getPoolStats() {
         const now = Date.now();
-        return Array.from(this.pools.entries()).map(([agentId, pool]) => ({
-            agentId,
-            messageCount: pool.messages.length,
-            waitingMs: now - pool.firstEnqueueTime,
-        }));
+        const agentIds = new Set([...this.pools.keys(), ...this.deferredLanes.keys()]);
+        return Array.from(agentIds).map((agentId) => {
+            const pool = this.pools.get(agentId);
+            const deferredLane = this.deferredLanes.get(agentId);
+            const oldestMessageTime = Math.min(pool?.messages[0]?.timestamp ?? Number.POSITIVE_INFINITY, deferredLane?.messages[0]?.timestamp ?? Number.POSITIVE_INFINITY);
+            return {
+                agentId,
+                messageCount: (pool?.messages.length ?? 0) + (deferredLane?.messages.length ?? 0),
+                waitingMs: now - oldestMessageTime,
+            };
+        });
     }
     getPoolDetails(projectId) {
         const now = Date.now();
         const PREVIEW_LENGTH = 100;
         const details = [];
-        for (const [agentId, pool] of this.pools.entries()) {
-            if (pool.messages.length === 0)
+        const agentIds = new Set([...this.pools.keys(), ...this.deferredLanes.keys()]);
+        for (const agentId of agentIds) {
+            const pool = this.pools.get(agentId);
+            const deferredLane = this.deferredLanes.get(agentId);
+            const pooledMessages = [...(pool?.messages ?? []), ...(deferredLane?.messages ?? [])].sort((a, b) => a.timestamp - b.timestamp);
+            if (pooledMessages.length === 0)
                 continue;
-            const firstMessage = pool.messages[0];
+            const firstMessage = pooledMessages[0];
             const logEntry = this.messageLog.getById(firstMessage.logEntryId);
-            const poolProjectId = logEntry?.projectId ?? 'unknown';
+            const poolProjectId = logEntry?.projectId ?? pool?.projectId ?? deferredLane?.projectId ?? 'unknown';
             const agentName = logEntry?.agentName ?? 'unknown';
             if (projectId && poolProjectId !== projectId)
                 continue;
-            const messages = pool.messages.map((msg) => {
+            const messages = pooledMessages.map((msg) => {
                 const preview = msg.text.length > PREVIEW_LENGTH ? msg.text.slice(0, PREVIEW_LENGTH) + '...' : msg.text;
                 return {
                     id: msg.logEntryId,
@@ -380,22 +693,65 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                     timestamp: msg.timestamp,
                 };
             });
-            details.push({
+            const humanHeldMessageCount = deferredLane && deferredLane.requiredGeneration !== null ? deferredLane.messages.length : 0;
+            const humanReleaseEligibleAt = humanHeldMessageCount > 0 && deferredLane
+                ? this.humanPromptState.getManualReleaseEligibleAt(deferredLane.tmuxSessionName)
+                : null;
+            const detail = {
                 agentId,
                 agentName,
                 projectId: poolProjectId,
-                messageCount: pool.messages.length,
-                waitingMs: now - pool.firstEnqueueTime,
+                messageCount: pooledMessages.length,
+                humanHeldMessageCount,
+                waitingMs: now - firstMessage.timestamp,
                 messages,
-            });
+            };
+            if (humanReleaseEligibleAt !== null) {
+                detail.humanReleaseEligibleAt = humanReleaseEligibleAt;
+            }
+            details.push(detail);
         }
         details.sort((a, b) => b.waitingMs - a.waitingMs);
         return details;
     }
+    async releaseHumanHeldMessages(agentId, projectId) {
+        return this.coordinator.withAgentLock(agentId, async () => {
+            const lane = this.deferredLanes.get(agentId);
+            const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+            if (!lane ||
+                lane.projectId !== projectId ||
+                !activeSession?.tmuxSessionId ||
+                activeSession.id !== lane.sessionId ||
+                activeSession.tmuxSessionId !== lane.tmuxSessionName ||
+                lane.requiredGeneration === null) {
+                return { status: 'not_found' };
+            }
+            const eligibleAt = this.humanPromptState.getManualReleaseEligibleAt(lane.tmuxSessionName);
+            if (eligibleAt === null || Date.now() < eligibleAt) {
+                return { status: 'not_ready', eligibleAt };
+            }
+            const state = this.humanPromptState.getState(lane.tmuxSessionName);
+            if (state.phase !== 'draft_active') {
+                return { status: 'not_ready', eligibleAt: null };
+            }
+            const transition = this.humanPromptState.transitionToAwaiting(lane.tmuxSessionName, state.generation, true);
+            if (!transition.accepted) {
+                return { status: 'not_ready', eligibleAt: null };
+            }
+            await this.handleHumanPromptStateChangedUnderAgentLock(agentId, {
+                sessionId: lane.sessionId,
+                tmuxSessionName: lane.tmuxSessionName,
+                generation: transition.state.generation,
+                phase: 'awaiting_stable_idle',
+            });
+            return { status: 'released' };
+        });
+    }
     async onModuleDestroy() {
+        this.closing = true;
         const poolStats = this.getPoolStats();
         const totalMessages = poolStats.reduce((sum, p) => sum + p.messageCount, 0);
-        logger.info({ agentCount: poolStats.length, totalMessages }, 'Shutting down message pool, flushing pending messages...');
+        logger.info({ agentCount: poolStats.length, totalMessages }, 'Shutting down message pool, flushing default lanes and failing deferred lanes...');
         for (const [agentId, pool] of this.pools.entries()) {
             if (pool.timer) {
                 clearTimeout(pool.timer);
@@ -407,17 +763,45 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             }
             logger.debug({ agentId }, 'Cleared timers for agent pool');
         }
-        const SHUTDOWN_TIMEOUT_MS = 5000;
-        const flushPromise = this.flushAll();
-        const timeoutPromise = new Promise((resolve) => setTimeout(() => {
-            const remainingPools = this.pools.size;
-            const remainingMessages = Array.from(this.pools.values()).reduce((sum, p) => sum + p.messages.length, 0);
-            if (remainingMessages > 0) {
-                logger.warn({ remainingPools, remainingMessages, timeoutMs: SHUTDOWN_TIMEOUT_MS }, 'Shutdown flush timeout reached, some messages may be lost');
+        const deferredLanes = Array.from(this.deferredLanes.values());
+        const deferredSettlements = [];
+        for (const lane of deferredLanes) {
+            const detachment = await this.coordinator.withAgentLock(lane.agentId, async () => {
+                const current = this.deferredLanes.get(lane.agentId);
+                return current === lane
+                    ? this.detachDeferredLaneUnderAgentLock(lane, 'Service stopped before deferred delivery')
+                    : null;
+            });
+            if (lane.requiredGeneration !== null) {
+                this.humanPromptState.clearSession(lane.tmuxSessionName);
+            }
+            if (detachment) {
+                deferredSettlements.push(this.settleDeferredLaneDetachment(detachment, false));
             }
-            resolve();
-        }, SHUTDOWN_TIMEOUT_MS));
-        await Promise.race([flushPromise, timeoutPromise]);
+        }
+        if (deferredLanes.length > 0) {
+            logger.info({
+                agentCount: deferredLanes.length,
+                totalMessages: deferredLanes.reduce((sum, lane) => sum + lane.messages.length, 0),
+            }, 'Settling deferred delivery lanes before terminal shutdown');
+        }
+        const SHUTDOWN_TIMEOUT_MS = 5000;
+        const shutdownWork = Promise.all([...deferredSettlements, this.flushAll()]).then(() => undefined);
+        let timeout;
+        const timeoutPromise = new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                const remainingPools = this.pools.size;
+                const remainingMessages = this.getPoolStats().reduce((sum, pool) => sum + pool.messageCount, 0);
+                if (remainingMessages > 0) {
+                    logger.warn({ remainingPools, remainingMessages, timeoutMs: SHUTDOWN_TIMEOUT_MS }, 'Shutdown flush timeout reached, some messages may be lost');
+                }
+                resolve();
+            }, SHUTDOWN_TIMEOUT_MS);
+        });
+        await Promise.race([shutdownWork, timeoutPromise]);
+        if (timeout)
+            clearTimeout(timeout);
+        void shutdownWork.catch((error) => logger.error({ error }, 'Message pool shutdown settlement failed'));
         logger.info('Message pool shutdown complete');
     }
     getMessageLog(options) {
@@ -429,6 +813,385 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     getMessageById(messageId) {
         return this.messageLog.getMessageById(messageId);
     }
+    async handleHumanPromptStateChanged(event) {
+        const session = this.sessions.getSession(event.sessionId);
+        if (!session?.agentId || session.tmuxSessionId !== event.tmuxSessionName)
+            return;
+        const agentId = session.agentId;
+        while (true) {
+            const step = await this.coordinator.withAgentLock(agentId, async () => {
+                const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+                const existingLane = this.deferredLanes.get(agentId);
+                if (activeSession?.id === event.sessionId &&
+                    existingLane &&
+                    existingLane.sessionId !== event.sessionId) {
+                    return {
+                        detachment: this.detachDeferredLaneUnderAgentLock(existingLane, 'Target session was replaced before deferred delivery'),
+                    };
+                }
+                await this.handleHumanPromptStateChangedUnderAgentLock(agentId, event);
+                return { done: true };
+            });
+            if ('done' in step)
+                return;
+            await this.settleDeferredLaneDetachment(step.detachment);
+        }
+    }
+    async handleHumanPromptStateChangedUnderAgentLock(agentId, event) {
+        if (event.phase === 'draft_active') {
+            await this.promoteProtectedPoolMessagesUnderAgentLock(agentId, event);
+        }
+        const lane = this.deferredLanes.get(agentId);
+        if (!lane ||
+            lane.sessionId !== event.sessionId ||
+            lane.tmuxSessionName !== event.tmuxSessionName) {
+            return;
+        }
+        this.rebindLaneGeneration(lane, event.generation);
+        if (event.phase === 'draft_active') {
+            this.clearDeferredLaneTimer(lane);
+        }
+        else {
+            this.ensureHumanQuietTimerUnderAgentLock(lane);
+        }
+        this.broadcastPoolsUpdate();
+    }
+    async promoteProtectedPoolMessagesUnderAgentLock(agentId, event) {
+        const pool = this.pools.get(agentId);
+        if (!pool)
+            return;
+        const protectedMessages = pool.messages.filter((message) => message.deferWhileHumanTyping);
+        if (protectedMessages.length === 0)
+            return;
+        const session = this.sessions.getSession(event.sessionId);
+        const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+        if (!session?.tmuxSessionId ||
+            session.tmuxSessionId !== event.tmuxSessionName ||
+            activeSession?.id !== event.sessionId) {
+            return;
+        }
+        pool.messages = pool.messages.filter((message) => !message.deferWhileHumanTyping);
+        if (pool.messages.length === 0) {
+            this.clearPoolTimers(pool);
+            this.pools.delete(agentId);
+        }
+        await this.moveMessagesToDeferredLaneUnderAgentLock(agentId, pool.projectId, pool.config.separator, activeSession, protectedMessages, event.generation);
+    }
+    async handleSessionActivityChanged(event) {
+        const session = this.sessions.getSession(event.sessionId);
+        if (!session?.agentId || event.state !== 'idle')
+            return;
+        await this.flushDeferredLane(session.agentId, event.sessionId);
+    }
+    async handleSessionStopped(event) {
+        const session = this.sessions.getSession(event.sessionId);
+        if (!session?.agentId)
+            return;
+        const agentId = session.agentId;
+        await this.failMatchingDeferredLane(agentId, event.sessionId, 'Target session stopped before deferred delivery');
+    }
+    async handleSessionCrashed(event) {
+        const session = this.sessions.getSession(event.sessionId);
+        if (!session?.agentId)
+            return;
+        const agentId = session.agentId;
+        await this.failMatchingDeferredLane(agentId, event.sessionId, 'Target session crashed before deferred delivery');
+    }
+    async flushDeferredLane(agentId, expectedSessionId, quietGraceElapsed = false) {
+        const claim = await this.coordinator.withAgentLock(agentId, async () => this.claimDeferredLaneUnderAgentLock(agentId, expectedSessionId, quietGraceElapsed));
+        if (!claim)
+            return { success: true, deliveredCount: 0 };
+        return this.deliverDeferredClaim(claim);
+    }
+    async deliverDeferredClaim(claim) {
+        const result = await this.deliverBatchToTarget(claim.agentId, claim.messages, claim.separator, { sessionId: claim.sessionId, tmuxSessionName: claim.tmuxSessionName }, claim.quietSnapshot ?? undefined, claim);
+        await this.coordinator.withAgentLock(claim.agentId, async () => this.completeDeferredClaimUnderAgentLock(claim, result));
+        return result;
+    }
+    claimDeferredLaneUnderAgentLock(agentId, expectedSessionId, quietGraceElapsed) {
+        const lane = this.deferredLanes.get(agentId);
+        const expectedSession = this.sessions.getSession(expectedSessionId);
+        const activeSession = this.sessions.getActiveSessionForAgent(agentId);
+        if (!lane ||
+            lane.activeClaim ||
+            lane.sessionId !== expectedSessionId ||
+            expectedSession?.status !== 'running' ||
+            expectedSession.tmuxSessionId !== lane.tmuxSessionName ||
+            activeSession?.id !== expectedSessionId) {
+            return null;
+        }
+        let quietSnapshot = null;
+        if (lane.requiredGeneration !== null) {
+            quietSnapshot = this.humanPromptState.getQuietSnapshot(lane.tmuxSessionName);
+            if (!quietGraceElapsed ||
+                !quietSnapshot ||
+                quietSnapshot.expectedGeneration !== lane.requiredGeneration ||
+                !lane.quietBaseline ||
+                !this.quietSnapshotsEqual(lane.quietBaseline, quietSnapshot)) {
+                const current = this.humanPromptState.getState(lane.tmuxSessionName);
+                if (current.phase === 'inactive') {
+                    lane.requiredGeneration = null;
+                    lane.quietBaseline = null;
+                }
+                else {
+                    this.rebindLaneGeneration(lane, current.generation);
+                    if (current.phase === 'awaiting_stable_idle') {
+                        this.ensureHumanQuietTimerUnderAgentLock(lane, true);
+                    }
+                    return null;
+                }
+            }
+        }
+        if (lane.messages.some((message) => message.requiresProviderIdle) &&
+            expectedSession.activityState !== 'idle') {
+            if (lane.requiredGeneration !== null) {
+                this.ensureHumanQuietTimerUnderAgentLock(lane, true);
+            }
+            return null;
+        }
+        this.clearDeferredLaneTimer(lane);
+        let resolveCompletion;
+        const completion = new Promise((resolve) => {
+            resolveCompletion = resolve;
+        });
+        const claim = {
+            agentId,
+            sessionId: lane.sessionId,
+            tmuxSessionName: lane.tmuxSessionName,
+            projectId: lane.projectId,
+            messages: [...lane.messages],
+            separator: lane.separator,
+            quietSnapshot: lane.requiredGeneration !== null ? quietSnapshot : null,
+            state: { phase: 'preparing' },
+            completion,
+            resolveCompletion,
+        };
+        lane.activeClaim = claim;
+        return claim;
+    }
+    completeDeferredClaimUnderAgentLock(claim, result) {
+        if (claim.state.phase === 'complete')
+            return;
+        const cancellationReason = claim.state.phase === 'preparing' ? claim.state.cancellationReason : undefined;
+        const lane = this.deferredLanes.get(claim.agentId);
+        const ownsLane = lane?.sessionId === claim.sessionId && lane.activeClaim === claim ? lane : null;
+        if (ownsLane)
+            ownsLane.activeClaim = null;
+        if (cancellationReason) {
+            claim.state = { phase: 'complete', outcome: 'failed' };
+            claim.resolveCompletion(null);
+            return;
+        }
+        if (ownsLane && result.outcome !== 'deferred') {
+            const claimedIds = new Set(claim.messages.map((message) => message.logEntryId));
+            ownsLane.messages.splice(0, ownsLane.messages.length, ...ownsLane.messages.filter((message) => !claimedIds.has(message.logEntryId)));
+        }
+        const outcome = result.success
+            ? (result.outcome ?? 'delivered')
+            : 'failed';
+        claim.state = { phase: 'complete', outcome };
+        if (!ownsLane) {
+            const failureLane = claim.detachReason && result.outcome === 'deferred'
+                ? this.copyDeferredLaneWithMessages(claim, claim.messages)
+                : null;
+            claim.resolveCompletion(failureLane);
+            return;
+        }
+        if (ownsLane.messages.length === 0) {
+            this.clearDeferredLaneTimer(ownsLane);
+            this.deferredLanes.delete(claim.agentId);
+            this.broadcastPoolsUpdate();
+            claim.resolveCompletion(null);
+            return;
+        }
+        const state = this.humanPromptState.getState(ownsLane.tmuxSessionName);
+        if (state.phase === 'inactive') {
+            ownsLane.requiredGeneration = null;
+            ownsLane.quietBaseline = null;
+            setTimeout(() => {
+                void this.flushDeferredLane(claim.agentId, ownsLane.sessionId).catch((error) => logger.error({ agentId: claim.agentId, error }, 'Deferred follow-up delivery failed'));
+            }, 0);
+        }
+        else {
+            this.rebindLaneGeneration(ownsLane, state.generation);
+            if (state.phase === 'awaiting_stable_idle') {
+                this.ensureHumanQuietTimerUnderAgentLock(ownsLane, true);
+            }
+        }
+        this.broadcastPoolsUpdate();
+        claim.resolveCompletion(null);
+    }
+    async failMatchingDeferredLane(agentId, sessionId, reason, notifySenders = true) {
+        const detachment = await this.coordinator.withAgentLock(agentId, async () => {
+            const lane = this.deferredLanes.get(agentId);
+            return !lane || lane.sessionId !== sessionId
+                ? null
+                : this.detachDeferredLaneUnderAgentLock(lane, reason);
+        });
+        if (detachment) {
+            await this.settleDeferredLaneDetachment(detachment, notifySenders);
+        }
+    }
+    detachDeferredLaneUnderAgentLock(lane, reason) {
+        if (this.deferredLanes.get(lane.agentId) === lane) {
+            this.deferredLanes.delete(lane.agentId);
+        }
+        this.clearDeferredLaneTimer(lane);
+        const claim = lane.activeClaim;
+        lane.activeClaim = null;
+        if (!claim || claim.state.phase === 'complete') {
+            return {
+                reason,
+                failureLane: this.copyDeferredLaneWithMessages(lane, lane.messages),
+                claimCompletion: null,
+            };
+        }
+        claim.detachReason = reason;
+        if (claim.state.phase === 'preparing') {
+            claim.state = { phase: 'preparing', cancellationReason: reason };
+            return {
+                reason,
+                failureLane: this.copyDeferredLaneWithMessages(lane, lane.messages),
+                claimCompletion: null,
+            };
+        }
+        const claimedIds = new Set(claim.messages.map((message) => message.logEntryId));
+        const unclaimedMessages = lane.messages.filter((message) => !claimedIds.has(message.logEntryId));
+        return {
+            reason,
+            failureLane: unclaimedMessages.length > 0
+                ? this.copyDeferredLaneWithMessages(lane, unclaimedMessages)
+                : null,
+            claimCompletion: claim.completion,
+        };
+    }
+    async settleDeferredLaneDetachment(detachment, notifySenders = true) {
+        if (detachment.failureLane) {
+            await this.failDeferredLane(detachment.failureLane, detachment.reason, notifySenders);
+        }
+        if (!detachment.claimCompletion)
+            return;
+        const lateFailureLane = await detachment.claimCompletion;
+        if (lateFailureLane) {
+            await this.failDeferredLane(lateFailureLane, detachment.reason, notifySenders);
+        }
+    }
+    copyDeferredLaneWithMessages(lane, messages) {
+        return {
+            sessionId: lane.sessionId,
+            tmuxSessionName: lane.tmuxSessionName,
+            agentId: lane.agentId,
+            projectId: lane.projectId,
+            messages: [...messages],
+            separator: lane.separator,
+            requiredGeneration: null,
+            quietTimer: null,
+            quietBaseline: null,
+            activeClaim: null,
+        };
+    }
+    async failDeferredLane(lane, reason, notifySenders = true) {
+        this.clearDeferredLaneTimer(lane);
+        const batchId = (0, crypto_1.randomUUID)();
+        const failureDisclosure = (0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(lane.messages);
+        const batchFailure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(failureDisclosure, reason, 'no_active_session');
+        for (const message of lane.messages) {
+            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(message.failureDisclosure, reason, 'no_active_session');
+            this.messageLog.update(message.logEntryId, {
+                status: 'failed',
+                batchId,
+                error: failure.error,
+                failureCode: failure.failureCode,
+            });
+            const entry = this.messageLog.getById(message.logEntryId);
+            if (entry)
+                this.activityStream.broadcastFailed(entry);
+        }
+        this.broadcastPoolsUpdate();
+        logger.warn({
+            agentId: lane.agentId,
+            sessionId: lane.sessionId,
+            messageCount: lane.messages.length,
+            error: batchFailure.error,
+        }, 'Deferred delivery lane discarded');
+        if (!notifySenders)
+            return;
+        await this.failureNotifier
+            .notifySendersOfFailure(lane.messages, lane.agentId, batchFailure.error)
+            .catch((error) => logger.warn({
+            agentId: lane.agentId,
+            error: this.disclosedLogError(failureDisclosure, error),
+        }, 'Failure notification error (best-effort)'));
+    }
+    clearPoolTimers(pool) {
+        if (pool.timer)
+            clearTimeout(pool.timer);
+        if (pool.maxWaitTimer)
+            clearTimeout(pool.maxWaitTimer);
+        pool.timer = null;
+        pool.maxWaitTimer = null;
+    }
+    clearDeferredLaneTimer(lane) {
+        if (lane.quietTimer)
+            clearTimeout(lane.quietTimer);
+        lane.quietTimer = null;
+        lane.quietBaseline = null;
+    }
+    rebindLaneGeneration(lane, generation) {
+        if (lane.requiredGeneration !== generation)
+            this.clearDeferredLaneTimer(lane);
+        lane.requiredGeneration = generation;
+        for (const message of lane.messages)
+            message.heldGeneration = generation;
+    }
+    ensureHumanQuietTimerUnderAgentLock(lane, restart = false) {
+        if (lane.activeClaim)
+            return;
+        if (restart)
+            this.clearDeferredLaneTimer(lane);
+        if (lane.quietTimer)
+            return;
+        const snapshot = this.humanPromptState.getQuietSnapshot(lane.tmuxSessionName);
+        if (!snapshot || snapshot.expectedGeneration !== lane.requiredGeneration)
+            return;
+        lane.quietBaseline = snapshot;
+        lane.quietTimer = setTimeout(() => {
+            lane.quietTimer = null;
+            void this.flushDeferredLane(lane.agentId, lane.sessionId, true).catch((error) => logger.error({ agentId: lane.agentId, error }, 'Human-quiet delivery failed'));
+        }, exports.HUMAN_DRAFT_IDLE_GRACE_MS);
+    }
+    quietSnapshotsEqual(left, right) {
+        return (left.expectedGeneration === right.expectedGeneration &&
+            left.executedInputEpoch === right.executedInputEpoch &&
+            left.meaningfulOutputEpoch === right.meaningfulOutputEpoch);
+    }
+    async moveMessagesToDeferredLaneUnderAgentLock(agentId, projectId, separator, activeSession, messages, generation) {
+        if (!activeSession.tmuxSessionId)
+            return;
+        let lane = this.deferredLanes.get(agentId);
+        if (!lane) {
+            lane = {
+                sessionId: activeSession.id,
+                tmuxSessionName: activeSession.tmuxSessionId,
+                agentId,
+                projectId,
+                messages: [],
+                separator,
+                requiredGeneration: generation,
+                quietTimer: null,
+                quietBaseline: null,
+                activeClaim: null,
+            };
+            this.deferredLanes.set(agentId, lane);
+        }
+        lane.separator = separator;
+        lane.messages.push(...messages);
+        this.rebindLaneGeneration(lane, generation);
+        const state = this.humanPromptState.getState(lane.tmuxSessionName);
+        if (state.phase === 'awaiting_stable_idle')
+            this.ensureHumanQuietTimerUnderAgentLock(lane);
+        this.broadcastPoolsUpdate();
+    }
     async deliverBatch(agentId, messages, separator = this.config.separator) {
         const batchId = (0, crypto_1.randomUUID)();
         const failureDisclosure = (0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(messages);
@@ -460,21 +1223,43 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             }, 'Failure notification error (best-effort)'));
             return { success: false, discardedCount: messages.length, reason: batchFailure.error };
         }
-        const tmuxSessionId = session.tmuxSessionId;
-        const baseText = messages.map((m) => m.text).join(separator);
+        return this.deliverBatchToTarget(agentId, messages, separator, {
+            sessionId: session.id,
+            tmuxSessionName: session.tmuxSessionId,
+        });
+    }
+    async deliverBatchToTarget(agentId, messages, separator, target, quietSnapshot, claim) {
+        const batchId = (0, crypto_1.randomUUID)();
+        const failureDisclosure = (0, delivery_failure_disclosure_1.getStrictestFailureDisclosure)(messages);
+        const baseText = messages.map((message) => message.text).join(separator);
         const submitKeys = messages[messages.length - 1]?.submitKeys ?? ['Enter'];
         try {
             const postPasteDelayMs = await this.providerAdapterFactory.getPostPasteDelayMsForAgent(agentId);
-            const result = await this.terminalIO.deliver({ name: tmuxSessionId }, baseText, {
-                agentId,
-                submitKeys,
-                postPasteDelayMs,
-            });
+            const result = claim
+                ? await this.terminalIO.deliverGuarded({ name: target.tmuxSessionName }, baseText, { agentId, submitKeys, postPasteDelayMs }, quietSnapshot, {
+                    canStartMutation: () => canStartDeferredClaimMutation(claim),
+                    markMutationStarted: () => {
+                        if (canStartDeferredClaimMutation(claim)) {
+                            claim.state = { phase: 'mutating' };
+                        }
+                    },
+                })
+                : await this.terminalIO.deliver({ name: target.tmuxSessionName }, baseText, {
+                    agentId,
+                    submitKeys,
+                    postPasteDelayMs,
+                });
+            const cancellation = deferredClaimCancellationResult(claim, messages.length);
+            if (cancellation)
+                return cancellation;
+            if ('deferred' in result) {
+                return { success: true, deliveredCount: 0, outcome: 'deferred' };
+            }
             const deliveredAt = Date.now();
             const status = result.confirmed ? 'delivered' : 'unconfirmed';
             const entries = [];
-            for (const msg of messages) {
-                this.messageLog.update(msg.logEntryId, {
+            for (const message of messages) {
+                this.messageLog.update(message.logEntryId, {
                     status,
                     batchId,
                     deliveredAt,
@@ -483,7 +1268,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                     retryCount: result.retryCount,
                     failureCode: result.confirmed ? undefined : 'paste_not_confirmed',
                 });
-                const entry = this.messageLog.getById(msg.logEntryId);
+                const entry = this.messageLog.getById(message.logEntryId);
                 if (entry)
                     entries.push(entry);
             }
@@ -494,13 +1279,6 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                 this.activityStream.broadcastUnconfirmed(batchId, entries);
             }
             this.broadcastPoolsUpdate();
-            logger.info({
-                agentId,
-                sessionId: session.id,
-                messageCount: messages.length,
-                batchId,
-                confirmed: result.confirmed,
-            }, 'Batch delivered to agent session');
             return {
                 success: true,
                 deliveredCount: messages.length,
@@ -509,72 +1287,140 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         }
         catch (error) {
             const errorMsg = error instanceof Error ? error.message : String(error);
+            const cancellation = deferredClaimCancellationResult(claim, messages.length);
+            if (cancellation)
+                return cancellation;
             const failureCode = errorMsg.includes('send keys')
                 ? 'send_keys_failed'
                 : 'tmux_error';
             const batchFailure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(failureDisclosure, errorMsg, failureCode);
-            logger.error({ agentId, sessionId: session.id, error: batchFailure.error }, 'Failed to deliver batch to agent session');
-            for (const msg of messages) {
-                const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(msg.failureDisclosure, errorMsg, failureCode);
-                this.messageLog.update(msg.logEntryId, {
+            logger.error({ agentId, sessionId: target.sessionId, error: batchFailure.error }, 'Failed to deliver batch to exact agent session');
+            for (const message of messages) {
+                const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(message.failureDisclosure, errorMsg, failureCode);
+                this.messageLog.update(message.logEntryId, {
                     status: 'failed',
                     batchId,
                     error: failure.error,
                     failureCode: failure.failureCode,
                 });
-                const entry = this.messageLog.getById(msg.logEntryId);
+                const entry = this.messageLog.getById(message.logEntryId);
                 if (entry)
                     this.activityStream.broadcastFailed(entry);
             }
             this.broadcastPoolsUpdate();
             await this.failureNotifier
                 .notifySendersOfFailure(messages, agentId, batchFailure.error)
-                .catch((err) => logger.warn({
+                .catch((notifyError) => logger.warn({
                 agentId,
-                error: failureDisclosure === 'project-safe' ? delivery_failure_disclosure_1.PROJECT_SAFE_DELIVERY_ERROR : err,
+                error: failureDisclosure === 'project-safe' ? delivery_failure_disclosure_1.PROJECT_SAFE_DELIVERY_ERROR : notifyError,
             }, 'Failure notification error (best-effort)'));
             return { success: false, discardedCount: messages.length, reason: batchFailure.error };
         }
     }
     async deliverMessage(agentId, text, submitKeys, opts) {
+        return this.coordinator.withAgentLock(agentId, () => this.deliverMessageUnderAgentLock(agentId, text, submitKeys, opts));
+    }
+    async deliverMessageUnderAgentLock(agentId, text, submitKeys, opts) {
         const activeSessions = await this.sessions.listActiveSessions();
-        const session = activeSessions.find((s) => s.agentId === agentId);
-        if (!session || !session.tmuxSessionId) {
+        const session = activeSessions.find((candidate) => candidate.agentId === agentId);
+        if (!session?.tmuxSessionId)
             throw new Error(`No active session for agent ${agentId}`);
+        const postPasteDelayMs = await this.providerAdapterFactory.getPostPasteDelayMsForAgent(agentId);
+        if (opts?.skipConfirmation) {
+            const delivery = await this.terminalIO.deliverImmediate({ name: session.tmuxSessionId }, text, {
+                submitKeys,
+                postPasteDelayMs,
+                confirm: false,
+                preKeys: opts.preKeys,
+                preDelayMs: opts.preDelayMs,
+            });
+            return {
+                nonce: delivery.nonce,
+                skipped: true,
+                retryCount: 0,
+                sessionId: session.id,
+                tmuxSessionName: session.tmuxSessionId,
+            };
         }
-        let result = {
-            nonce: '',
-            retryCount: 0,
+        const delivery = await this.terminalIO.deliver({ name: session.tmuxSessionId }, text, {
+            agentId,
+            submitKeys,
+            postPasteDelayMs,
+            preKeys: opts?.preKeys,
+            preDelayMs: opts?.preDelayMs,
+        });
+        return {
+            nonce: delivery.nonce,
+            unconfirmed: !delivery.confirmed,
+            retryCount: delivery.retryCount,
+            sessionId: session.id,
+            tmuxSessionName: session.tmuxSessionId,
         };
-        await this.coordinator.withAgentLock(agentId, async () => {
-            const postPasteDelayMs = await this.providerAdapterFactory.getPostPasteDelayMsForAgent(agentId);
-            if (opts?.skipConfirmation) {
-                const delivery = await this.terminalIO.deliverImmediate({ name: session.tmuxSessionId }, text, {
-                    submitKeys,
-                    postPasteDelayMs,
-                    confirm: false,
-                    preKeys: opts?.preKeys,
-                    preDelayMs: opts?.preDelayMs,
-                });
-                result = { nonce: delivery.nonce, skipped: true, retryCount: 0 };
+    }
+    async deliverImmediateUnderAgentLock(input, logEntry) {
+        try {
+            const activeSession = this.sessions.getActiveSessionForAgent(input.agentId);
+            const expectedSubmit = input.humanPromptSubmit && activeSession?.tmuxSessionId
+                ? {
+                    sessionId: activeSession.id,
+                    tmuxSessionName: activeSession.tmuxSessionId,
+                    generation: this.humanPromptState.getState(activeSession.tmuxSessionId).generation,
+                }
+                : null;
+            const delivery = await this.deliverMessageUnderAgentLock(input.agentId, input.text, input.submitKeys, {
+                skipConfirmation: input.deliveryMode === 'immediate',
+                preKeys: input.preKeys,
+                preDelayMs: input.preDelayMs,
+            });
+            const status = delivery.unconfirmed ? 'unconfirmed' : 'delivered';
+            const deliveredAt = Date.now();
+            this.messageLog.update(logEntry.id, {
+                status,
+                deliveredAt,
+                nonce: delivery.skipped ? undefined : delivery.nonce,
+                confirmedAt: delivery.skipped || delivery.unconfirmed ? undefined : deliveredAt,
+                retryCount: delivery.retryCount,
+                failureCode: delivery.unconfirmed ? 'paste_not_confirmed' : undefined,
+            });
+            const updated = this.messageLog.getById(logEntry.id);
+            if (updated) {
+                if (delivery.unconfirmed)
+                    this.activityStream.broadcastUnconfirmed(logEntry.id, [updated]);
+                else
+                    this.activityStream.broadcastDelivered(logEntry.id, [updated]);
             }
-            else {
-                const delivery = await this.terminalIO.deliver({ name: session.tmuxSessionId }, text, {
-                    agentId,
-                    submitKeys,
-                    postPasteDelayMs,
-                    preKeys: opts?.preKeys,
-                    preDelayMs: opts?.preDelayMs,
-                });
-                result = {
-                    nonce: delivery.nonce,
-                    unconfirmed: !delivery.confirmed,
-                    retryCount: delivery.retryCount,
-                };
+            if (expectedSubmit &&
+                expectedSubmit.sessionId === delivery.sessionId &&
+                expectedSubmit.tmuxSessionName === delivery.tmuxSessionName) {
+                await this.completeHumanSubmitUnderAgentLock(input.agentId, delivery.sessionId, delivery.tmuxSessionName, expectedSubmit.generation);
             }
+            return { status, logEntryId: logEntry.id };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, errorMsg, 'tmux_error');
+            logger.error({ agentId: input.agentId, source: input.source, error: failure.error }, 'Immediate delivery failed');
+            this.messageLog.update(logEntry.id, {
+                status: 'failed',
+                error: failure.error,
+                failureCode: failure.failureCode,
+            });
+            const failed = this.messageLog.getById(logEntry.id);
+            if (failed)
+                this.activityStream.broadcastFailed(failed);
+            return { status: 'failed', error: failure.error, logEntryId: logEntry.id };
+        }
+    }
+    async completeHumanSubmitUnderAgentLock(agentId, sessionId, tmuxSessionName, expectedGeneration) {
+        const transition = this.humanPromptState.transitionToAwaiting(tmuxSessionName, expectedGeneration);
+        if (!transition.accepted)
+            return;
+        await this.handleHumanPromptStateChangedUnderAgentLock(agentId, {
+            sessionId,
+            tmuxSessionName,
+            generation: transition.state.generation,
+            phase: 'awaiting_stable_idle',
         });
-        logger.info({ agentId, sessionId: session.id, unconfirmed: result.unconfirmed }, 'Immediate message delivered');
-        return result;
     }
     broadcastPoolsUpdate() {
         const pools = this.getPoolDetails();
@@ -602,6 +1448,30 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     }
 };
 exports.SessionsMessagePoolService = SessionsMessagePoolService;
+__decorate([
+    (0, event_emitter_1.OnEvent)(session_human_prompt_state_changed_1.sessionHumanPromptStateChangedEvent.name, { suppressErrors: false }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsMessagePoolService.prototype, "handleHumanPromptStateChanged", null);
+__decorate([
+    (0, event_emitter_1.OnEvent)('session.activity.changed', { async: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsMessagePoolService.prototype, "handleSessionActivityChanged", null);
+__decorate([
+    (0, event_emitter_1.OnEvent)('session.stopped', { async: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsMessagePoolService.prototype, "handleSessionStopped", null);
+__decorate([
+    (0, event_emitter_1.OnEvent)('session.crashed', { async: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsMessagePoolService.prototype, "handleSessionCrashed", null);
 exports.SessionsMessagePoolService = SessionsMessagePoolService = __decorate([
     (0, common_1.Injectable)(),
     __param(4, (0, common_1.Inject)(storage_interface_1.STORAGE_SERVICE)),
@@ -611,6 +1481,7 @@ exports.SessionsMessagePoolService = SessionsMessagePoolService = __decorate([
         settings_service_1.SettingsService, Object, message_activity_stream_service_1.MessageActivityStreamService,
         provider_adapter_factory_1.ProviderAdapterFactory,
         message_log_service_1.MessageLogService,
-        delivery_failure_notifier_service_1.DeliveryFailureNotifierService])
+        delivery_failure_notifier_service_1.DeliveryFailureNotifierService,
+        human_prompt_state_service_1.HumanPromptStateService])
 ], SessionsMessagePoolService);
 //# sourceMappingURL=sessions-message-pool.service.js.map