@canonmsg/codex-plugin 0.32.3 → 0.32.5

package/dist/host.d.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { type TurnArtifactRoutingDecision, type TurnArtifactRoutingMode, type RecoveryCheckpointTracker } from '@canonmsg/coding-agent-host';
 import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimeFact, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type PreparedExecutionEnvironment, type WorkspaceOption, type CanonWorkspaceRootMetadata, type DeliveryIntent, type RuntimeStreamingPayload, type TurnLifecycleState, type TurnOutputBlock, type TurnVerbosity, type TurnVerbosityConfig } from '@canonmsg/core';
+import type { EndpointInboundHandoff } from '@canonmsg/core';
 import type { AgentReplyAuthorityV1 } from '@canonmsg/backend-contracts';
 import { CodexConversationAdapter, type CodexSandboxMode } from './adapter.js';
 import { CodexAppServerAdapter, type CodexSkillMetadata } from './app-server-adapter.js';
@@ -36,8 +37,7 @@ interface Session {
         planMode?: boolean;
         intent: DeliveryIntent;
         sourceMessageId?: string | null;
-        /** A recovery gate rejected this input before any native execution. */
-        recoveryDeferred?: boolean;
+        inboundHandoff?: EndpointInboundHandoff;
         markAccepted?: boolean;
         imagePaths?: string[];
         mediaAddDirs?: string[];
@@ -64,6 +64,7 @@ interface Session {
     currentReplyAuthority: AgentReplyAuthorityV1 | null;
     /** Cancels Canon interactions created by the currently running Codex turn. */
     currentTurnAbortController: AbortController | null;
+    currentInboundHandoff?: EndpointInboundHandoff;
     /**
      * The verbosity the RUNNING turn was opened with. Promoted off the queue
      * entry at `runNextTurn` and never re-read mid-turn, so the live writer, the

package/dist/host.js

@@ -1072,9 +1072,7 @@ export async function main() {
     }
     async function markQueuedPromptsRejected(conversationId, prompts) {
         await Promise.all(prompts.map(async (prompt) => {
-            if (prompt.recoveryDeferred && prompt.sourceMessageId) {
-                await endpoint.setInboundState(`message:${conversationId}:${prompt.sourceMessageId}`, 'settled', 'canceled-before-execution');
-            }
+            await prompt.inboundHandoff?.cancel('canceled-before-execution');
             if (!prompt.markAccepted || !prompt.sourceMessageId)
                 return Promise.resolve();
             return client.updateMessageDisposition(conversationId, prompt.sourceMessageId, 'rejected').catch(() => { });
@@ -1082,10 +1080,12 @@ export async function main() {
     }
     function settleRejectedPromptCheckpoints(conversationId, prompts) {
         const checkpoints = recoveryCheckpointsFor(conversationId);
-        for (const prompt of prompts)
-            checkpoints.settle(prompt.sourceMessageId);
+        for (const prompt of prompts) {
+            if (!prompt.inboundHandoff || prompt.inboundHandoff.phase === 'settled')
+                checkpoints.settle(prompt.sourceMessageId);
+        }
     }
-    function removeQueuedPrompt(conversationId, sourceMessageId) {
+    async function removeQueuedPrompt(conversationId, sourceMessageId) {
         const session = sessions.get(conversationId);
         if (!session || session.queue.length === 0)
             return;
@@ -1093,6 +1093,7 @@ export async function main() {
         if (removed.length === 0)
             return;
         session.queue = session.queue.filter((prompt) => prompt.sourceMessageId !== sourceMessageId);
+        await Promise.all(removed.map((prompt) => prompt.inboundHandoff?.cancel('message-deleted')));
         settleRejectedPromptCheckpoints(conversationId, removed);
         writeTurn(session);
     }
@@ -1267,13 +1268,11 @@ export async function main() {
         if (!session)
             return;
         session.closed = true;
-        // The local queue is going away, but never-started deferred input still
-        // belongs to the durable inbox. Release only that queue's dedupe ownership
-        // so an eligible reoffer can reconstruct it after eviction or removal.
+        // Closing a native session relinquishes only unsubmitted Canon work.
         for (const prompt of session.queue) {
-            if (prompt.recoveryDeferred && prompt.sourceMessageId)
-                acceptedInboundMessageIds.delete(prompt.sourceMessageId);
+            void prompt.inboundHandoff?.release('session-closed').catch(console.error);
         }
+        void session.currentInboundHandoff?.release('session-closed').catch(console.error);
         session.currentTurnAbortController?.abort(new Error('Codex session closed'));
         session.currentTurnAbortController = null;
         stopVisibleWorkSignal(session);
@@ -1291,6 +1290,7 @@ export async function main() {
     async function resetRuntimeSession(session) {
         const conversationId = session.conversationId;
         session.resetRequested = true;
+        void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
         const droppedPrompts = session.queue.splice(0);
         await markQueuedPromptsRejected(conversationId, droppedPrompts);
         settleRejectedPromptCheckpoints(conversationId, droppedPrompts);
@@ -1516,6 +1516,7 @@ export async function main() {
         const nextPrompt = {
             prompt,
             skillInvocationText: turn.skillInvocationText,
+            inboundHandoff: turn.inboundHandoff,
             intent,
             sourceMessageId,
             markAccepted,
@@ -1941,8 +1942,9 @@ export async function main() {
         knownConversationIds.add(input.conversationId);
         if (input.turnDispatch && input.turnDispatch.kind !== 'run_turn') {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed server-dispatched turn: ${input.turnDispatch.reason}`);
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         if (input.message.metadata?.type === 'plan_approval_reply') {
@@ -1950,8 +1952,9 @@ export async function main() {
                 // A service agent never advertises or enters plan mode. Consume stale
                 // replies left by an older coding descriptor instead of turning them
                 // into hidden plan/implementation prompts after an upgrade or restart.
-                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-                await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+                if (await input.inboundHandoff.settle('not-dispatched')) {
+                    recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+                }
                 return;
             }
             const planId = readString(input.message.metadata, 'planId');
@@ -1959,8 +1962,9 @@ export async function main() {
                 senderId: input.message.senderId,
                 metadata: input.message.metadata,
             })) {
-                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-                await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+                if (await input.inboundHandoff.settle('not-dispatched')) {
+                    recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+                }
                 return;
             }
             const session = await getOrCreateSession(input.conversationId);
@@ -1974,6 +1978,7 @@ export async function main() {
             enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve', {
                 canUseCodexAppTools: input.isOwner || serviceAgentMode,
                 requestingUserId: getCodexRequestingUserId(input.message),
+                inboundHandoff: input.inboundHandoff,
             });
             return;
         }
@@ -2034,8 +2039,9 @@ export async function main() {
             : decideAutoReply(participantContext, behavior);
         if (!autoReply.allow) {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}" (${autoReply.reason})`);
@@ -2070,8 +2076,9 @@ export async function main() {
                 },
                 ...(input.replyAuthority ? { replyAuthority: input.replyAuthority } : {}),
             }).catch(() => { });
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         session.activeSelfContextId = activeSelfContextId;
@@ -2090,10 +2097,12 @@ export async function main() {
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
                 ...resolveCodexTurnModes(participantContext, input.message),
+                inboundHandoff: input.inboundHandoff,
                 skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
                 replyAuthority: input.replyAuthority ?? null,
             });
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
+            void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
             session.currentTurnAbortController?.abort(new CodexTurnCanceledError('Codex turn interrupted by a newer message'));
             await session.adapter.interrupt().catch(() => { });
             clearStreaming(input.conversationId);
@@ -2102,6 +2111,7 @@ export async function main() {
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
             ...resolveCodexTurnModes(participantContext, input.message),
+            inboundHandoff: input.inboundHandoff,
             skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
             replyAuthority: input.replyAuthority ?? null,
         });
@@ -2151,7 +2161,7 @@ export async function main() {
             return;
         }
         const inboundId = nextTurn.sourceMessageId ? `message:${session.conversationId}:${nextTurn.sourceMessageId}` : null;
-        let journaledInput = false;
+        session.currentInboundHandoff = nextTurn.inboundHandoff;
         let inputDeferred = false;
         let preserveUnclaimedInput = false;
         let completedOutput;
@@ -2380,10 +2390,33 @@ export async function main() {
             // Canon-origin queues must retain a durable execution owner, including
             // legacy queues restored before endpoint migration. Native continuations
             // without a Canon source message remain a separate operator path.
-            if (inboundId && !await endpoint.claimInbound(inboundId))
+            const handoff = nextTurn.inboundHandoff ?? (inboundId ? await endpoint.acquireInbound(inboundId) : undefined);
+            session.currentInboundHandoff = handoff ?? undefined;
+            if (inboundId && !handoff) {
+                preserveUnclaimedInput = true;
                 return;
-            journaledInput = !!inboundId;
-            let result = await runTurnOnce();
+            }
+            if (handoff && (session.resetRequested || session.currentTurnAbortController?.signal.reason instanceof CodexTurnCanceledError)) {
+                await handoff.cancel('canceled-before-execution');
+            }
+            else if (handoff && (session.closed || session.currentTurnAbortController?.signal.aborted)) {
+                await handoff.release('session-closed');
+            }
+            const started = handoff
+                ? await endpoint.startInbound(handoff, runTurnOnce)
+                : { status: 'submitted', value: await runTurnOnce() };
+            if (started.status !== 'submitted') {
+                if (started.status === 'deferred' && !session.closed && !session.resetRequested
+                    && !session.currentTurnAbortController?.signal.aborted) {
+                    nextTurn.inboundHandoff = handoff ?? undefined;
+                    session.queue.unshift(nextTurn);
+                    inputDeferred = true;
+                }
+                preserveUnclaimedInput = inputDeferred || handoff?.phase === 'released';
+                clearStreaming(session.conversationId);
+                return;
+            }
+            let result = started.value;
             if (!result.interrupted
                 && !result.finalMessage
                 && result.exitCode
@@ -2427,7 +2460,7 @@ export async function main() {
                     : { kind: 'none', reason: result.interrupted ? 'interrupted' : session.currentTurnSilenced ? 'silent' : 'empty' };
             const record = {
                 version: 1, turnId: session.currentTurnId, conversationId: session.conversationId,
-                sourceMessageId: journaledInput ? nextTurn.sourceMessageId : null,
+                sourceMessageId: inboundId ? nextTurn.sourceMessageId : null,
                 nativeThreadId: result.threadId, createdAt: new Date().toISOString(), output,
                 audience: conversationCache.has(session.conversationId) ? {
                     memberIds: [...conversationCache.get(session.conversationId).memberIds].sort(),
@@ -2551,31 +2584,12 @@ export async function main() {
                 await deliverCompletedOutput(completedOutput);
         }
         catch (error) {
-            if (!journaledInput && inboundId && error instanceof Error
-                && 'code' in error && error.code === 'SYNC_NOT_READY') {
-                // Recovery can be invalidated after the inbox offers an input. No
-                // native work has started: keep this same queued turn for the host
-                // heartbeat instead of publishing a failure or suppressing its retry
-                // through the accepted-message dedupe cache.
-                if (session.resetRequested || session.currentTurnAbortController?.signal.reason instanceof CodexTurnCanceledError) {
-                    await endpoint.setInboundState(inboundId, 'settled', 'canceled-before-execution');
-                }
-                else {
-                    preserveUnclaimedInput = true;
-                    if (!session.closed && !session.currentTurnAbortController?.signal.aborted) {
-                        nextTurn.recoveryDeferred = true;
-                        session.queue.unshift(nextTurn);
-                        inputDeferred = true;
-                    }
-                    else {
-                        // A closed/shutting-down session cannot retain the local queue.
-                        // Leave its durable offer available to the next live session.
-                        acceptedInboundMessageIds.delete(nextTurn.sourceMessageId);
-                    }
-                }
-                // The attempt may already have published its empty thinking row.
-                // With no native output there is nothing to hand off or salvage.
+            if (!nativeCompleted && inboundId && session.currentInboundHandoff?.phase !== 'submitted') {
+                // A store/preflight failure proves no native callback ran. The shared
+                // inbox can reoffer it; a generic failure reply is not completion proof.
+                preserveUnclaimedInput = session.currentInboundHandoff?.phase !== 'settled';
                 clearStreaming(session.conversationId);
+                console.error('[canon-codex] Native input awaits handoff recovery:', error);
                 return;
             }
             if (nativeCompleted) {
@@ -2626,8 +2640,26 @@ export async function main() {
         finally {
             if (completedOutput)
                 activeCompletedOutputs.delete(completedOutput.turnId);
+            const handoff = session.currentInboundHandoff;
+            if (!inputDeferred && handoff && handoff.phase !== 'submitted' && handoff.phase !== 'settled') {
+                preserveUnclaimedInput = true;
+                try {
+                    await handoff.release('native-preflight');
+                }
+                catch (error) {
+                    // Keep the existing queue/heartbeat as the local retry owner if the
+                    // durable release itself fails. Never silently discard the handle.
+                    if (!session.closed && !session.currentTurnAbortController?.signal.aborted) {
+                        nextTurn.inboundHandoff = handoff;
+                        session.queue.unshift(nextTurn);
+                        inputDeferred = true;
+                    }
+                    console.error('[canon-codex] Failed to release unsubmitted input:', error);
+                }
+            }
             session.currentTurnAbortController?.abort(new Error('Codex turn ended'));
             session.currentTurnAbortController = null;
+            session.currentInboundHandoff = undefined;
             if (!preserveUnclaimedInput)
                 recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
             stopVisibleWorkSignal(session);
@@ -2650,30 +2682,6 @@ export async function main() {
             }
         }
     }
-    const acceptedInboundMessageIds = new Set();
-    const inFlightInboundMessageIds = new Set();
-    function claimInboundMessageId(messageId) {
-        if (!messageId)
-            return true;
-        if (acceptedInboundMessageIds.has(messageId) || inFlightInboundMessageIds.has(messageId))
-            return false;
-        inFlightInboundMessageIds.add(messageId);
-        return true;
-    }
-    function settleInboundMessageId(messageId, accepted) {
-        if (!messageId)
-            return;
-        inFlightInboundMessageIds.delete(messageId);
-        if (!accepted)
-            return;
-        acceptedInboundMessageIds.add(messageId);
-        while (acceptedInboundMessageIds.size > 2_048) {
-            const oldest = acceptedInboundMessageIds.values().next().value;
-            if (!oldest)
-                break;
-            acceptedInboundMessageIds.delete(oldest);
-        }
-    }
     const hostAvailableExecutionModes = serviceAgentMode
         ? ['locked']
         : [...EXECUTION_ENVIRONMENT_MODES];
@@ -2804,6 +2812,7 @@ export async function main() {
         }
         console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${type} signal`);
         if (session.running) {
+            void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
             session.currentTurnAbortController?.abort(new CodexTurnCanceledError(`Codex turn interrupted by ${type}`));
         }
         if (type === 'stop_and_drop') {
@@ -2945,17 +2954,19 @@ export async function main() {
                 await endpoint.setInboundState(event.id, 'settled', 'own-message');
                 return;
             }
-            if (!claimInboundMessageId(message.id))
+            const handoff = await endpoint.acquireInbound(event.id);
+            if (!handoff)
                 return;
             recoveryCheckpointsFor(payload.conversationId).track(message.id);
             if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
                 console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
-                recoveryCheckpointsFor(payload.conversationId).settle(message.id);
-                settleInboundMessageId(message.id, true);
-                await endpoint.setInboundState(`message:${payload.conversationId}:${message.id}`, 'settled', 'observe-only');
+                if (await handoff.settle('observe-only')) {
+                    recoveryCheckpointsFor(payload.conversationId).settle(message.id);
+                }
                 return;
             }
             await enqueueInboundMessage({
+                inboundHandoff: handoff,
                 conversationId: payload.conversationId,
                 message,
                 senderName: message.senderName || message.senderId,
@@ -2966,8 +2977,8 @@ export async function main() {
                 provenance: payload.provenance,
                 turnDispatch: payload.turnDispatch,
                 replyAuthority: payload.replyAuthority,
-            }).then(() => settleInboundMessageId(message.id, true), (error) => {
-                settleInboundMessageId(message.id, false);
+            }).catch(async (error) => {
+                await handoff.release('queue-failed');
                 console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Failed to queue inbound message:`, error instanceof Error ? error.message : error);
                 throw error;
             });
@@ -2983,7 +2994,7 @@ export async function main() {
                     data: payload });
             },
             onMessageDeleted: (payload) => {
-                removeQueuedPrompt(payload.conversationId, payload.messageId);
+                void removeQueuedPrompt(payload.conversationId, payload.messageId).catch(console.error);
             },
             onConversationUpdated: (payload) => {
                 handleConversationUpdated(payload);
@@ -3063,6 +3074,7 @@ export async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         for (const session of sessions.values()) {
+            void session.currentInboundHandoff?.release('host-shutdown').catch(console.error);
             session.currentTurnAbortController?.abort(new Error('Codex host shutting down'));
         }
         runtimeRequests.dispose();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.32.3",
+  "version": "0.32.5",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -32,10 +32,10 @@
     "smoke:protocol": "node scripts/smoke-protocol.mjs"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^11.0.1",
+    "@canonmsg/agent-sdk": "^11.0.2",
     "@canonmsg/agent-tools": "^0.11.0",
-    "@canonmsg/coding-agent-host": "^0.9.0",
-    "@canonmsg/core": "^13.0.4",
+    "@canonmsg/coding-agent-host": "^0.10.0",
+    "@canonmsg/core": "^13.0.5",
     "@canonmsg/rich-cards": "^0.10.6",
     "ws": "^8.21.3"
   },