devchain-cli 0.21.0 → 0.22.1

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

@@ -12,7 +12,7 @@ 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");
@@ -27,10 +27,20 @@ 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_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,
@@ -48,10 +58,12 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     providerAdapterFactory;
     messageLog;
     failureNotifier;
+    humanPromptState;
     pools = new Map();
-    idleLanes = 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;
@@ -61,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');
     }
@@ -156,12 +169,14 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         const logEntryId = (0, crypto_1.randomUUID)();
         const timestamp = Date.now();
         const deliveryMode = this.resolveDeliveryMode(options);
-        if (deliveryMode === 'on_idle') {
-            return this.enqueueOnIdle({
+        if (options.deferWhileHumanTyping || options.humanPromptSubmit || deliveryMode === 'on_idle') {
+            return this.enqueueSerialized({
                 agentId,
                 text,
                 source,
                 submitKeys,
+                preKeys,
+                preDelayMs,
                 senderAgentId,
                 clientMessageId,
                 failureDisclosure,
@@ -169,6 +184,9 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
                 agentName,
                 logEntryId,
                 timestamp,
+                deliveryMode,
+                deferWhileHumanTyping: options.deferWhileHumanTyping === true,
+                humanPromptSubmit: options.humanPromptSubmit === true,
             });
         }
         const projectConfig = this.getConfigForProject(projectId, failureDisclosure);
@@ -342,48 +360,79 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         }, pool.config.delayMs);
         return { status: 'queued', poolSize: pool.messages.length, logEntryId };
     }
-    async enqueueOnIdle(input) {
-        const activeSession = this.sessions.getActiveSessionForAgent(input.agentId);
-        if (input.clientMessageId) {
-            const existing = this.messageLog.findByClientMessageId(input.clientMessageId, input.agentId, input.source);
-            if (existing) {
-                return { status: existing.status, logEntryId: existing.id };
-            }
-        }
-        let detachedLane;
-        const currentLane = this.idleLanes.get(input.agentId);
-        if (currentLane && currentLane.sessionId !== activeSession?.id) {
-            this.idleLanes.delete(input.agentId);
-            detachedLane = currentLane;
-        }
-        if (!activeSession) {
-            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, 'No active session', 'no_active_session');
-            if (detachedLane) {
-                await this.failIdleLane(detachedLane, 'Target session is no longer active');
+    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,
+                };
             }
-            return { status: 'failed', error: failure.error };
+            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);
-        let lane = this.idleLanes.get(input.agentId);
-        if (lane) {
-            lane.separator = projectConfig.separator;
-        }
-        if ((lane?.messages.length ?? 0) >= projectConfig.maxMessages) {
-            const failure = (0, delivery_failure_disclosure_1.classifyDeliveryFailure)(input.failureDisclosure, 'Message pool capacity reached', 'pool_capacity_exceeded');
-            return { status: 'failed', error: failure.error };
+        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 (!lane) {
-            lane = {
-                sessionId: activeSession.id,
-                agentId: input.agentId,
-                projectId: input.projectId,
-                messages: [],
-                firstEnqueueTime: input.timestamp,
-                separator: projectConfig.separator,
-            };
-            this.idleLanes.set(input.agentId, lane);
+        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);
         }
-        const 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,
@@ -394,10 +443,11 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             senderAgentId: input.senderAgentId,
             clientMessageId: input.clientMessageId,
             status: 'queued',
-            immediate: false,
+            immediate,
         };
-        this.messageLog.addEntry(logEntry);
-        lane.messages.push({
+    }
+    createPooledMessage(input, options) {
+        return {
             text: input.text,
             source: input.source,
             timestamp: input.timestamp,
@@ -406,60 +456,192 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             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();
-        const exactSessionIsIdle = activeSession.activityState === 'idle';
-        const detachedFailure = detachedLane
-            ? this.failIdleLane(detachedLane, 'Target session was replaced before idle delivery')
-            : Promise.resolve();
-        if (exactSessionIsIdle) {
-            const [, flushResult] = await Promise.all([
-                detachedFailure,
-                this.flushIdleLane(input.agentId, activeSession.id),
-            ]);
-            if (!flushResult.success) {
-                return { status: 'failed', error: flushResult.reason, logEntryId: input.logEntryId };
-            }
-            if (flushResult.deliveredCount === 0) {
-                const logEntry = this.messageLog.getById(input.logEntryId);
+        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: logEntry?.status ?? 'queued',
-                    ...(logEntry?.error ? { error: logEntry.error } : {}),
+                    status: 'queued',
+                    poolSize: this.getSharedQueuedCount(input.agentId),
                     logEntryId: input.logEntryId,
                 };
             }
             return {
-                status: flushResult.outcome === 'unconfirmed' ? 'unconfirmed' : 'delivered',
+                status: result.outcome === 'unconfirmed' ? 'unconfirmed' : 'delivered',
                 logEntryId: input.logEntryId,
             };
         }
-        await detachedFailure;
-        return { status: 'queued', poolSize: lane.messages.length, 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]) => ({
@@ -473,14 +655,14 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
     }
     getPoolStats() {
         const now = Date.now();
-        const agentIds = new Set([...this.pools.keys(), ...this.idleLanes.keys()]);
+        const agentIds = new Set([...this.pools.keys(), ...this.deferredLanes.keys()]);
         return Array.from(agentIds).map((agentId) => {
             const pool = this.pools.get(agentId);
-            const idleLane = this.idleLanes.get(agentId);
-            const oldestMessageTime = Math.min(pool?.messages[0]?.timestamp ?? Number.POSITIVE_INFINITY, idleLane?.firstEnqueueTime ?? Number.POSITIVE_INFINITY);
+            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) + (idleLane?.messages.length ?? 0),
+                messageCount: (pool?.messages.length ?? 0) + (deferredLane?.messages.length ?? 0),
                 waitingMs: now - oldestMessageTime,
             };
         });
@@ -489,16 +671,16 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
         const now = Date.now();
         const PREVIEW_LENGTH = 100;
         const details = [];
-        const agentIds = new Set([...this.pools.keys(), ...this.idleLanes.keys()]);
+        const agentIds = new Set([...this.pools.keys(), ...this.deferredLanes.keys()]);
         for (const agentId of agentIds) {
             const pool = this.pools.get(agentId);
-            const idleLane = this.idleLanes.get(agentId);
-            const pooledMessages = [...(pool?.messages ?? []), ...(idleLane?.messages ?? [])].sort((a, b) => a.timestamp - b.timestamp);
+            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 = pooledMessages[0];
             const logEntry = this.messageLog.getById(firstMessage.logEntryId);
-            const poolProjectId = logEntry?.projectId ?? pool?.projectId ?? idleLane?.projectId ?? 'unknown';
+            const poolProjectId = logEntry?.projectId ?? pool?.projectId ?? deferredLane?.projectId ?? 'unknown';
             const agentName = logEntry?.agentName ?? 'unknown';
             if (projectId && poolProjectId !== projectId)
                 continue;
@@ -511,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: 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 default lanes and clearing idle lanes...');
+        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);
@@ -538,26 +763,45 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             }
             logger.debug({ agentId }, 'Cleared timers for agent pool');
         }
-        const idleLanes = Array.from(this.idleLanes.values());
-        this.idleLanes.clear();
-        if (idleLanes.length > 0) {
+        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));
+            }
+        }
+        if (deferredLanes.length > 0) {
             logger.info({
-                agentCount: idleLanes.length,
-                totalMessages: idleLanes.reduce((sum, lane) => sum + lane.messages.length, 0),
-            }, 'Clearing idle delivery lanes without terminal delivery');
-            await Promise.all(idleLanes.map((lane) => this.failIdleLane(lane, 'Service stopped before idle delivery', false)));
+                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 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');
-            }
-            resolve();
-        }, SHUTDOWN_TIMEOUT_MS));
-        await Promise.race([flushPromise, timeoutPromise]);
+        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) {
@@ -569,50 +813,285 @@ 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.flushIdleLane(session.agentId, event.sessionId);
+        await this.flushDeferredLane(session.agentId, event.sessionId);
     }
     async handleSessionStopped(event) {
         const session = this.sessions.getSession(event.sessionId);
         if (!session?.agentId)
             return;
-        await this.failMatchingIdleLane(session.agentId, event.sessionId, 'Target session stopped before idle delivery');
+        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;
-        await this.failMatchingIdleLane(session.agentId, event.sessionId, 'Target session crashed before idle delivery');
+        const agentId = session.agentId;
+        await this.failMatchingDeferredLane(agentId, event.sessionId, 'Target session crashed before deferred delivery');
     }
-    async flushIdleLane(agentId, expectedSessionId) {
-        let result = { success: true, deliveredCount: 0 };
-        await this.coordinator.withAgentLock(agentId, async () => {
-            const expectedSession = this.sessions.getSession(expectedSessionId);
-            const activeSession = this.sessions.getActiveSessionForAgent(agentId);
-            const lane = this.idleLanes.get(agentId);
-            if (!lane ||
-                lane.sessionId !== expectedSessionId ||
-                expectedSession?.status !== 'running' ||
-                expectedSession.activityState !== 'idle' ||
-                activeSession?.id !== expectedSessionId) {
-                return;
+    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;
+                }
             }
-            this.idleLanes.delete(agentId);
-            result = await this.deliverBatch(agentId, [...lane.messages], lane.separator);
+        }
+        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;
         });
-        return result;
+        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;
     }
-    async failMatchingIdleLane(agentId, sessionId, reason) {
-        const lane = this.idleLanes.get(agentId);
-        if (!lane || lane.sessionId !== sessionId)
+    completeDeferredClaimUnderAgentLock(claim, result) {
+        if (claim.state.phase === 'complete')
             return;
-        this.idleLanes.delete(agentId);
-        await this.failIdleLane(lane, reason);
+        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);
+        }
     }
-    async failIdleLane(lane, reason, notifySenders = true) {
+    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');
@@ -634,7 +1113,7 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             sessionId: lane.sessionId,
             messageCount: lane.messages.length,
             error: batchFailure.error,
-        }, 'Idle delivery lane discarded');
+        }, 'Deferred delivery lane discarded');
         if (!notifySenders)
             return;
         await this.failureNotifier
@@ -644,6 +1123,75 @@ let SessionsMessagePoolService = class SessionsMessagePoolService {
             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);
@@ -675,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,
@@ -698,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);
             }
@@ -709,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,
@@ -724,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();
@@ -817,6 +1448,12 @@ 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),
@@ -844,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