@canonmsg/codex-plugin 0.31.0 → 0.32.1

package/dist/completed-output.d.ts

@@ -0,0 +1,60 @@
+import type { SendMessageOptions } from '@canonmsg/core';
+export interface CodexCompletedOutput {
+    version: 1;
+    turnId: string;
+    conversationId: string;
+    sourceMessageId: string | null;
+    nativeThreadId: string | null;
+    createdAt: string;
+    audience: {
+        memberIds: string[];
+        membershipRevision?: number;
+    } | null;
+    output: {
+        kind: 'message';
+        text: string;
+        options: SendMessageOptions & {
+            messageId: string;
+        };
+    } | {
+        kind: 'plan';
+        body: {
+            conversationId: string;
+            interactionKind: 'plan';
+            planId: string;
+            expiresAt: number;
+            title: string;
+            body: string;
+            turnId: string;
+            responseUserId?: string;
+        };
+    } | {
+        kind: 'none';
+        reason: 'silent' | 'interrupted' | 'empty';
+    };
+}
+/** A completed native result is replayable output, never permission to run it again. */
+export declare function createCodexCompletedOutputJournal(directory: string, scope: unknown): {
+    save(record: CodexCompletedOutput): void;
+    list(): CodexCompletedOutput[];
+    remove(turnId: string): void;
+};
+export declare function codexPlanOutputOperationId(record: CodexCompletedOutput): string;
+/** A new delivery after restart must not silently adopt a changed audience. */
+export declare function assertCodexCompletedOutputAudience(record: CodexCompletedOutput, current: {
+    memberIds: string[];
+    membershipRevision?: number;
+} | null): void;
+/** Deleting nonblank streaming text promotes it to chat history on the server. */
+export declare function clearCodexStreamingWithCompletedSilence(options: {
+    records: CodexCompletedOutput[];
+    read(): Promise<unknown>;
+    blank(turnId: string): Promise<void>;
+    clear(): Promise<void>;
+}): Promise<void>;
+/** Delete plaintext only after the exact output is durable and its input is settled. */
+export declare function handoffCodexCompletedOutput(record: CodexCompletedOutput, handlers: {
+    publish(record: CodexCompletedOutput): Promise<void>;
+    settle(record: CodexCompletedOutput): Promise<void>;
+    remove(turnId: string): void;
+}): Promise<void>;

package/dist/completed-output.js

@@ -0,0 +1,149 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** A completed native result is replayable output, never permission to run it again. */
+export function createCodexCompletedOutputJournal(directory, scope) {
+    const folder = join(directory, createHash('sha256').update(JSON.stringify(scope)).digest('hex'));
+    const filename = (turnId) => join(folder, `${createHash('sha256').update(turnId).digest('hex')}.json`);
+    function syncDirectory() {
+        const fd = openSync(folder, 'r');
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    function validate(record) {
+        if (record.version !== 1 || typeof record.turnId !== 'string' || !record.turnId
+            || typeof record.conversationId !== 'string' || !record.conversationId || typeof record.createdAt !== 'string'
+            || !['message', 'plan', 'none'].includes(record.output?.kind)
+            || (record.output.kind === 'message' && (typeof record.output.text !== 'string' || typeof record.output.options?.messageId !== 'string'))
+            || (record.output.kind === 'plan' && (record.output.body?.planId !== record.turnId || record.output.body?.conversationId !== record.conversationId))
+            || (record.output.kind === 'none' && !['silent', 'interrupted', 'empty'].includes(record.output.reason))) {
+            throw new Error('Invalid completed Codex output record; operator reconciliation is required');
+        }
+    }
+    function recoverTemporaryFiles() {
+        for (const name of readdirSync(folder)) {
+            const match = /^([a-f0-9]{64})\.(\d+)\.[a-f0-9-]+\.tmp$/.exec(name);
+            if (!match)
+                continue;
+            try {
+                process.kill(Number(match[2]), 0);
+                continue;
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH')
+                    continue;
+            }
+            const path = join(folder, name);
+            let record;
+            try {
+                record = JSON.parse(readFileSync(path, 'utf8'));
+                validate(record);
+            }
+            catch {
+                // A torn write never established a completed result. Its input stays
+                // uncertain; the native transcript is the remaining recovery source.
+                unlinkSync(path);
+                throw new Error('Incomplete Codex output write removed; reconcile its native transcript');
+            }
+            const destination = filename(record.turnId);
+            if (destination !== join(folder, `${match[1]}.json`))
+                throw new Error('Completed Codex output temporary file identity mismatch');
+            if (existsSync(destination)) {
+                if (readFileSync(destination, 'utf8') !== JSON.stringify(record))
+                    throw new Error('Conflicting completed Codex outputs require reconciliation');
+                unlinkSync(path);
+            }
+            else
+                renameSync(path, destination);
+            syncDirectory();
+        }
+    }
+    return {
+        save(record) {
+            validate(record);
+            mkdirSync(folder, { recursive: true, mode: 0o700 });
+            const path = filename(record.turnId);
+            const serialized = JSON.stringify(record);
+            if (existsSync(path)) {
+                if (readFileSync(path, 'utf8') !== serialized)
+                    throw new Error('Completed Codex output cannot be replaced');
+                return;
+            }
+            const temporary = `${path.slice(0, -5)}.${process.pid}.${randomUUID()}.tmp`;
+            try {
+                const fd = openSync(temporary, 'wx', 0o600);
+                try {
+                    writeFileSync(fd, serialized);
+                    fsyncSync(fd);
+                }
+                finally {
+                    closeSync(fd);
+                }
+                renameSync(temporary, path);
+                syncDirectory();
+            }
+            catch (error) {
+                try {
+                    unlinkSync(temporary);
+                }
+                catch { /* Renamed records remain recoverable. */ }
+                throw error;
+            }
+        },
+        list() {
+            if (!existsSync(folder))
+                return [];
+            recoverTemporaryFiles();
+            return readdirSync(folder).filter((name) => name.endsWith('.json')).map((name) => {
+                const record = JSON.parse(readFileSync(join(folder, name), 'utf8'));
+                validate(record);
+                if (filename(record.turnId) !== join(folder, name))
+                    throw new Error('Completed Codex output identity mismatch');
+                return record;
+            }).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        },
+        remove(turnId) {
+            try {
+                unlinkSync(filename(turnId));
+                syncDirectory();
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        },
+    };
+}
+export function codexPlanOutputOperationId(record) {
+    return createHash('sha256').update(JSON.stringify(['codex-plan-output', record.conversationId, record.turnId])).digest('hex');
+}
+/** A new delivery after restart must not silently adopt a changed audience. */
+export function assertCodexCompletedOutputAudience(record, current) {
+    if (!record.audience || !current
+        || (record.audience.membershipRevision !== undefined && record.audience.membershipRevision !== current.membershipRevision)
+        || JSON.stringify([...record.audience.memberIds].sort()) !== JSON.stringify([...current.memberIds].sort())) {
+        throw new Error('Completed Codex output audience changed; operator reconciliation is required');
+    }
+}
+/** Deleting nonblank streaming text promotes it to chat history on the server. */
+export async function clearCodexStreamingWithCompletedSilence(options) {
+    const silentTurns = new Set(options.records.filter((record) => record.output.kind === 'none' && record.output.reason === 'silent').map((record) => record.turnId));
+    if (!silentTurns.size)
+        return;
+    const value = await options.read();
+    const turnId = value?.turnId ?? value?.messageId;
+    if (!turnId || !silentTurns.has(turnId))
+        return;
+    await options.blank(turnId);
+    await options.clear();
+}
+/** Delete plaintext only after the exact output is durable and its input is settled. */
+export async function handoffCodexCompletedOutput(record, handlers) {
+    await handlers.publish(record);
+    await handlers.settle(record);
+    handlers.remove(record.turnId);
+}

package/dist/host-lifecycle.d.ts

@@ -2,3 +2,12 @@ export interface LongLivedStream {
     start(): Promise<void>;
 }
 export declare function startCodexStreamInBackground(stream: LongLivedStream, onError: (error: unknown) => void): void;
+/** Only fully initialized sessions may be reused by another inbound offer. */
+export declare function initializeCodexSession<T>(options: {
+    key: string;
+    sessions: Map<string, T>;
+    create(): Promise<T>;
+    cleanup(): void;
+}): Promise<T>;
+/** Only an explicit local policy/configuration error may settle an unstarted input. */
+export declare function classifyCodexSessionStart(error: unknown): 'configuration_required' | 'deferred';

package/dist/host-lifecycle.js

@@ -1,3 +1,20 @@
+import { ExecutionEnvironmentError } from '@canonmsg/core';
 export function startCodexStreamInBackground(stream, onError) {
     stream.start().catch(onError);
 }
+/** Only fully initialized sessions may be reused by another inbound offer. */
+export async function initializeCodexSession(options) {
+    try {
+        const session = await options.create();
+        options.sessions.set(options.key, session);
+        return session;
+    }
+    catch (error) {
+        options.cleanup();
+        throw error;
+    }
+}
+/** Only an explicit local policy/configuration error may settle an unstarted input. */
+export function classifyCodexSessionStart(error) {
+    return error instanceof ExecutionEnvironmentError ? 'configuration_required' : 'deferred';
+}

package/dist/host.js

@@ -2,11 +2,11 @@
 import { setDefaultResultOrder } from 'node:dns';
 import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { dirname } from 'node:path';
+import { dirname, join } from 'node:path';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
-import { buildTrailBlockId, buildUndeliverableFinalNotice, captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, PLAN_BLOCK_TITLE, resolveTurnArtifactRouting, collectMissedInboundMessages, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildCanonGroupContext, buildCompactGroupContextLines, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createRuntimeHeartbeat, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, releaseConversationEnvironment, resolveLocalRuntimeSessionState, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, isSilentTurnSuppressed, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { buildTrailBlockId, buildUndeliverableFinalNotice, captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, PLAN_BLOCK_TITLE, resolveTurnArtifactRouting, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, } from '@canonmsg/coding-agent-host';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildCanonGroupContext, buildCompactGroupContextLines, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createRuntimeHeartbeat, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CANON_DIR, runtimePlanDescriptor, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, releaseConversationEnvironment, resolveLocalRuntimeSessionState, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, sendMessageWithRetry, isPendingCanonOperation, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, isSilentTurnSuppressed, resolveSilentTurnDelivery, resolveTurnVerbosity, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { validateCard } from '@canonmsg/rich-cards';
 import { CodexConversationAdapter, } from './adapter.js';
 import { CodexAppServerAdapter, } from './app-server-adapter.js';
@@ -16,7 +16,8 @@ import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThrea
 import { deriveCodexPermissionEnvelope, mapCanonPermissionToCodex, } from './permission-mode.js';
 import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
-import { startCodexStreamInBackground } from './host-lifecycle.js';
+import { classifyCodexSessionStart, initializeCodexSession, startCodexStreamInBackground } from './host-lifecycle.js';
+import { clearCodexStreamingWithCompletedSilence, assertCodexCompletedOutputAudience, createCodexCompletedOutputJournal, codexPlanOutputOperationId, handoffCodexCompletedOutput } from './completed-output.js';
 import { createCodexControlPoller } from './control-channel.js';
 import { runCli, acquireLock } from '@canonmsg/core';
 import { runCodexWorkSessionHost } from './work-session-cli.js';
@@ -688,7 +689,8 @@ export async function main() {
         lockHandle?.release();
         throw error;
     }
-    const client = new CanonClient(apiKey, baseUrl);
+    const client = new CanonClient(apiKey, baseUrl, { environmentId: resolvedAgent.environmentId, streamUrl });
+    const endpoint = await client.getEndpoint();
     const rtdb = initRTDBAuth(client, { rtdbUrl, firebaseApiKey });
     const typingSignals = createTypingStatusPublisher({
         setTyping: (conversationId, typing, status) => status
@@ -815,6 +817,94 @@ export async function main() {
         hostMode: true,
         rtdb,
     });
+    const endpointIdentity = await endpoint.ready();
+    const completedOutputs = createCodexCompletedOutputJournal(join(CANON_DIR, 'codex-completed-output'), {
+        runtimeId, environmentId: endpointIdentity.environmentId, principalId: endpointIdentity.principalId,
+        ownershipVersion: endpointIdentity.ownershipVersion ?? null, installationId: endpointIdentity.installationId,
+    });
+    const activeCompletedOutputs = new Set();
+    const recoveringOutputRooms = new Map();
+    let recoveringCompletedOutputs;
+    async function publishCompletedPlan(record) {
+        if (record.output.kind !== 'plan')
+            throw new Error('Expected completed Codex plan');
+        const operationId = codexPlanOutputOperationId(record);
+        if (await endpoint.getOperation(operationId)) {
+            return client.waitForOperation(operationId, { timeoutMs: 5_000 });
+        }
+        return endpoint.executeResult({ action: 'create_interaction', body: record.output.body }, { operationId });
+    }
+    runtimeRequests.register('plan', {
+        ...runtimePlanDescriptor,
+        async create(input) {
+            const record = completedOutputs.list().find((item) => item.turnId === input.requestId && item.conversationId === input.conversationId);
+            if (!record || record.output.kind !== 'plan')
+                return runtimePlanDescriptor.create(input);
+            const created = await publishCompletedPlan(record);
+            return { requestId: created.planId, expiresAt: created.expiresAt, messageId: created.messageId };
+        },
+    });
+    async function deliverCompletedOutput(record, alreadyPublished = false) {
+        await handoffCodexCompletedOutput(record, {
+            publish: async () => {
+                if (alreadyPublished)
+                    return;
+                if (record.output.kind === 'none') {
+                    if (record.output.reason === 'silent')
+                        await clearCompletedSilentStreaming(record.conversationId);
+                    return;
+                }
+                if (record.output.kind === 'plan')
+                    await publishCompletedPlan(record);
+                else {
+                    const existing = await client.getMessageOperation(record.conversationId, record.output.options.messageId);
+                    if (existing)
+                        await client.waitForOperation(existing.operationId, { timeoutMs: 5_000 });
+                    else
+                        await sendMessageWithRetryChunked(client, record.conversationId, record.output.text, record.output.options, { timeoutMs: 5_000 });
+                }
+            },
+            settle: async () => {
+                if (record.sourceMessageId)
+                    await endpoint.setInboundState(`message:${record.conversationId}:${record.sourceMessageId}`, 'settled', 'native-output-handed-off');
+            },
+            remove: completedOutputs.remove,
+        });
+    }
+    function recoverCompletedOutputs() {
+        if (recoveringCompletedOutputs)
+            return recoveringCompletedOutputs;
+        recoveringCompletedOutputs = (async () => {
+            for (const record of completedOutputs.list()) {
+                if (activeCompletedOutputs.has(record.turnId) || sessions.get(record.conversationId)?.running)
+                    continue;
+                const recovery = (async () => {
+                    const existing = record.output.kind === 'plan'
+                        ? await endpoint.getOperation(codexPlanOutputOperationId(record))
+                        : record.output.kind === 'message'
+                            ? await client.getMessageOperation(record.conversationId, record.output.options.messageId)
+                            : undefined;
+                    if (record.output.kind !== 'none' && !existing) {
+                        assertCodexCompletedOutputAudience(record, await client.getConversation(record.conversationId));
+                    }
+                    await deliverCompletedOutput(record);
+                })();
+                recoveringOutputRooms.set(record.conversationId, recovery);
+                try {
+                    await recovery;
+                }
+                catch (error) {
+                    // Retain unresolved output, including rejected/uncertain delivery.
+                    // Never rescan workspace files or submit another native turn here.
+                    console.error(`[canon-codex] Completed output ${record.turnId} awaits delivery reconciliation:`, error);
+                }
+                finally {
+                    recoveringOutputRooms.delete(record.conversationId);
+                }
+            }
+        })().finally(() => { recoveringCompletedOutputs = undefined; });
+        return recoveringCompletedOutputs;
+    }
     const sessions = new Map();
     const pendingSessionCreations = new Map();
     const recoveryCheckpointTrackers = new Map();
@@ -861,6 +951,8 @@ export async function main() {
                 ...payload.changes,
                 memberIds,
             });
+            void client.rememberConversation(conversationCache.get(payload.conversationId))
+                .catch((error) => console.error('[canon] Failed to persist conversation update:', error));
         }
         if (membershipChange) {
             pendingMembershipChanges.set(payload.conversationId, membershipChange);
@@ -988,6 +1080,14 @@ export async function main() {
         settleRejectedPromptCheckpoints(conversationId, removed);
         writeTurn(session);
     }
+    async function clearCompletedSilentStreaming(conversationId) {
+        await clearCodexStreamingWithCompletedSilence({
+            records: completedOutputs.list().filter((record) => record.conversationId === conversationId),
+            read: () => rtdb.read(`/streaming/${conversationId}/${agentId}`),
+            blank: (turnId) => runtimeState.writeStreaming(conversationId, { text: '', status: 'thinking', messageId: turnId, turnId, blocks: [] }),
+            clear: () => runtimeState.clearStreaming(conversationId),
+        });
+    }
     function clearStreaming(conversationId) {
         runtimeState.clearStreaming(conversationId).catch(() => { });
     }
@@ -1025,7 +1125,7 @@ export async function main() {
             messageId: session.currentTurnId ?? undefined,
             turnId: session.currentTurnId,
             blocks: [],
-        }).catch(() => { });
+        });
     }
     function upsertCodexTextSegment(session, event) {
         const next = applyTextSegmentBlock({
@@ -1088,7 +1188,7 @@ export async function main() {
     }
     async function handoffFinalMessage(conversationId) {
         await sleep(FINAL_MESSAGE_HANDOFF_MS);
-        clearStreaming(conversationId);
+        await runtimeState.clearStreaming(conversationId);
         typingSignals.clear(conversationId).catch(() => { });
     }
     function refreshVisibleWorkSignal(session) {
@@ -1236,136 +1336,146 @@ export async function main() {
                 workspaceCwd,
                 allowWorktrees: sessionExecutionMode === 'worktree',
             });
-            try {
-                const persistedMapping = resolveLocalRuntimeSessionState(runtimeId, {
-                    conversationId,
-                    baseCwd: environment.baseCwd,
-                    executionMode: environment.mode,
-                    resumeField: 'threadId',
-                    configuredBaseCwds: workspaceOptions.map((workspace) => workspace.cwd),
-                    availableExecutionModes: hostAvailableExecutionModes,
-                });
-                if (persistedMapping.status === 'configuration_required') {
-                    throw new ExecutionEnvironmentError(persistedMapping.message, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
-                }
-                if (persistedMapping.status === 'adopted'
-                    && (persistedMapping.state.baseCwd !== environment.baseCwd
-                        || persistedMapping.state.executionMode !== environment.mode)) {
-                    const restoredEnvironment = prepareConversationEnvironment({
-                        agentId,
+            let createdAdapter;
+            return initializeCodexSession({
+                key: conversationId,
+                sessions,
+                create: async () => {
+                    const persistedMapping = resolveLocalRuntimeSessionState(runtimeId, {
                         conversationId,
-                        workspaceCwd: persistedMapping.state.baseCwd,
-                        allowWorktrees: persistedMapping.state.executionMode === 'worktree',
+                        baseCwd: environment.baseCwd,
+                        executionMode: environment.mode,
+                        resumeField: 'threadId',
+                        configuredBaseCwds: workspaceOptions.map((workspace) => workspace.cwd),
+                        availableExecutionModes: hostAvailableExecutionModes,
                     });
-                    if (restoredEnvironment.mode !== persistedMapping.state.executionMode) {
-                        releaseConversationEnvironment(restoredEnvironment);
-                        throw new ExecutionEnvironmentError(`Conversation ${conversationId} requires local execution mode ${persistedMapping.state.executionMode}, but workspace ${persistedMapping.state.baseCwd} can only be opened in ${restoredEnvironment.mode} mode.`, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
+                    if (persistedMapping.status === 'configuration_required') {
+                        throw new ExecutionEnvironmentError(persistedMapping.message, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
                     }
-                    releaseConversationEnvironment(environment);
-                    environment = restoredEnvironment;
-                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Restoring saved local runtime → ${environment.mode} (${environment.baseCwd})`);
-                }
-                const sessionCwd = environment.cwd;
-                const policy = resolveCodexEffectiveRuntimePolicy({
-                    args,
-                    config: null,
-                    permissionEnvelope: codexPermissionEnvelope,
-                    environment,
-                    serviceAgentMode,
-                });
-                const modelGuard = buildCodexModelGuardMessage(policy.model, codexCliStatus);
-                if (modelGuard) {
-                    throw new ExecutionEnvironmentError(modelGuard, modelGuard);
-                }
-                const storedThreadId = loadStoredThreadId(runtimeId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint, {
-                    ...(persistedMapping.status === 'new' || !persistedMapping.state.workspaceId
-                        ? {}
-                        : { workspaceId: persistedMapping.state.workspaceId }),
-                    allowLegacyPolicyMigration: persistedMapping.status !== 'new',
-                });
-                const effectiveModel = policy.model ?? codexDefaultModel;
-                const initialEffortResolution = resolveCodexEffortForModel({
-                    models: codexModels,
-                    model: effectiveModel,
-                    requestedEffort: configuredCodexEffort,
-                });
-                const initialEffort = initialEffortResolution.value;
-                const adapter = useAppServer
-                    ? new CodexAppServerAdapter({
-                        cwd: sessionCwd,
-                        threadId: storedThreadId,
-                        codexBin,
-                        model: policy.model ?? null,
-                        reasoningEffort: initialEffort,
-                        sandbox: policy.sandbox,
-                        addDirs: args['add-dir'] ?? [],
-                        configOverrides: args.config ?? [],
-                        fullAuto: policy.fullAuto,
-                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
-                        dynamicTools: codexDynamicTools,
-                    })
-                    : new CodexConversationAdapter({
+                    if (persistedMapping.status === 'adopted'
+                        && (persistedMapping.state.baseCwd !== environment.baseCwd
+                            || persistedMapping.state.executionMode !== environment.mode)) {
+                        const restoredEnvironment = prepareConversationEnvironment({
+                            agentId,
+                            conversationId,
+                            workspaceCwd: persistedMapping.state.baseCwd,
+                            allowWorktrees: persistedMapping.state.executionMode === 'worktree',
+                        });
+                        if (restoredEnvironment.mode !== persistedMapping.state.executionMode) {
+                            releaseConversationEnvironment(restoredEnvironment);
+                            throw new ExecutionEnvironmentError(`Conversation ${conversationId} requires local execution mode ${persistedMapping.state.executionMode}, but workspace ${persistedMapping.state.baseCwd} can only be opened in ${restoredEnvironment.mode} mode.`, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
+                        }
+                        releaseConversationEnvironment(environment);
+                        environment = restoredEnvironment;
+                        console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Restoring saved local runtime → ${environment.mode} (${environment.baseCwd})`);
+                    }
+                    const sessionCwd = environment.cwd;
+                    const policy = resolveCodexEffectiveRuntimePolicy({
+                        args,
+                        config: null,
+                        permissionEnvelope: codexPermissionEnvelope,
+                        environment,
+                        serviceAgentMode,
+                    });
+                    const modelGuard = buildCodexModelGuardMessage(policy.model, codexCliStatus);
+                    if (modelGuard) {
+                        throw new ExecutionEnvironmentError(modelGuard, modelGuard);
+                    }
+                    const storedThreadId = loadStoredThreadId(runtimeId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint, {
+                        ...(persistedMapping.status === 'new' || !persistedMapping.state.workspaceId
+                            ? {}
+                            : { workspaceId: persistedMapping.state.workspaceId }),
+                        allowLegacyPolicyMigration: persistedMapping.status !== 'new',
+                    });
+                    const effectiveModel = policy.model ?? codexDefaultModel;
+                    const initialEffortResolution = resolveCodexEffortForModel({
+                        models: codexModels,
+                        model: effectiveModel,
+                        requestedEffort: configuredCodexEffort,
+                    });
+                    const initialEffort = initialEffortResolution.value;
+                    const adapter = useAppServer
+                        ? new CodexAppServerAdapter({
+                            cwd: sessionCwd,
+                            threadId: storedThreadId,
+                            codexBin,
+                            model: policy.model ?? null,
+                            reasoningEffort: initialEffort,
+                            sandbox: policy.sandbox,
+                            addDirs: args['add-dir'] ?? [],
+                            configOverrides: args.config ?? [],
+                            fullAuto: policy.fullAuto,
+                            bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                            dynamicTools: codexDynamicTools,
+                        })
+                        : new CodexConversationAdapter({
+                            cwd: sessionCwd,
+                            threadId: storedThreadId,
+                            codexBin,
+                            model: policy.model ?? null,
+                            reasoningEffort: initialEffort,
+                            sandbox: policy.sandbox,
+                            codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
+                            addDirs: args['add-dir'] ?? [],
+                            configOverrides: args.config ?? [],
+                            fullAuto: policy.fullAuto,
+                            bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                        });
+                    createdAdapter = adapter;
+                    const session = {
+                        conversationId,
                         cwd: sessionCwd,
-                        threadId: storedThreadId,
-                        codexBin,
-                        model: policy.model ?? null,
-                        reasoningEffort: initialEffort,
-                        sandbox: policy.sandbox,
-                        codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
-                        addDirs: args['add-dir'] ?? [],
-                        configOverrides: args.config ?? [],
-                        fullAuto: policy.fullAuto,
-                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                        environment,
+                        adapter,
+                        queue: [],
+                        running: false,
+                        state: buildCodexInitialSessionState({
+                            model: effectiveModel ?? undefined,
+                            permissionMode: policy.permissionMode,
+                            effort: initialEffort,
+                        }),
+                        policyFingerprint: policy.fingerprint,
+                        turnState: 'idle',
+                        currentTurnId: null,
+                        currentTurnOpenedAt: null,
+                        currentTurnUpdatedAt: null,
+                        currentTurnCanUseCodexAppTools: false,
+                        currentReplyAuthority: null,
+                        currentTurnAbortController: null,
+                        // Corrected by the first turn that runs; a session with no turn
+                        // publishes nothing anyway, and quiet is never an accident.
+                        turnVerbosity: 'verbose',
+                        currentTurnSilenced: false,
+                        activeSelfContextId: null,
+                        lastAcceptedIntent: null,
+                        resetRequested: false,
+                        lastActivity: Date.now(),
+                        typingKeepaliveTimer: null,
+                        closed: false,
+                        turnLiveText: '',
+                        turnBlocks: [],
+                        turnCommandBlocks: createCommandBlockTracker(),
+                    };
+                    await controlPoller.baseline([conversationId]);
+                    await runtimeState.patchAgentSessionSnapshot(conversationId, {
+                        configurationStatus: 'ready',
+                        lastError: null,
                     });
-                const session = {
-                    conversationId,
-                    cwd: sessionCwd,
-                    environment,
-                    adapter,
-                    queue: [],
-                    running: false,
-                    state: buildCodexInitialSessionState({
-                        model: effectiveModel ?? undefined,
-                        permissionMode: policy.permissionMode,
-                        effort: initialEffort,
-                    }),
-                    policyFingerprint: policy.fingerprint,
-                    turnState: 'idle',
-                    currentTurnId: null,
-                    currentTurnOpenedAt: null,
-                    currentTurnUpdatedAt: null,
-                    currentTurnCanUseCodexAppTools: false,
-                    currentReplyAuthority: null,
-                    currentTurnAbortController: null,
-                    // Corrected by the first turn that runs; a session with no turn
-                    // publishes nothing anyway, and quiet is never an accident.
-                    turnVerbosity: 'verbose',
-                    currentTurnSilenced: false,
-                    activeSelfContextId: null,
-                    lastAcceptedIntent: null,
-                    resetRequested: false,
-                    lastActivity: Date.now(),
-                    typingKeepaliveTimer: null,
-                    closed: false,
-                    turnLiveText: '',
-                    turnBlocks: [],
-                    turnCommandBlocks: createCommandBlockTracker(),
-                };
-                sessions.set(conversationId, session);
-                await controlPoller.baseline([conversationId]);
-                await runtimeState.patchAgentSessionSnapshot(conversationId, {
-                    configurationStatus: 'ready',
-                    lastError: null,
-                });
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
-                writeState(session);
-                writeTurn(session);
-                return session;
-            }
-            catch (error) {
-                releaseConversationEnvironment(environment);
-                throw error;
-            }
+                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
+                    writeState(session);
+                    writeTurn(session);
+                    return session;
+                },
+                cleanup: () => {
+                    try {
+                        if (createdAdapter instanceof CodexAppServerAdapter)
+                            createdAdapter.close();
+                    }
+                    finally {
+                        releaseConversationEnvironment(environment);
+                    }
+                },
+            });
         })();
         pendingSessionCreations.set(conversationId, creation);
         try {
@@ -1787,6 +1897,7 @@ export async function main() {
         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');
             return;
         }
         if (input.message.metadata?.type === 'plan_approval_reply') {
@@ -1795,6 +1906,7 @@ export async function main() {
                 // 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');
                 return;
             }
             const planId = readString(input.message.metadata, 'planId');
@@ -1803,6 +1915,7 @@ export async function main() {
                 metadata: input.message.metadata,
             })) {
                 recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+                await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
                 return;
             }
             const session = await getOrCreateSession(input.conversationId);
@@ -1877,6 +1990,7 @@ export async function main() {
         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');
             return;
         }
         console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}" (${autoReply.reason})`);
@@ -1890,6 +2004,11 @@ export async function main() {
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
+            // No native input has been claimed or submitted. The endpoint can offer
+            // this input again after a service/storage failure; do not settle it or
+            // misreport a temporary API failure as missing local configuration.
+            if (classifyCodexSessionStart(error) === 'deferred')
+                throw error;
             await runtimeState.patchAgentSessionSnapshot(input.conversationId, {
                 configurationStatus: 'configuration_required',
                 lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
@@ -1907,6 +2026,7 @@ 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');
             return;
         }
         session.activeSelfContextId = activeSelfContextId;
@@ -1959,10 +2079,36 @@ export async function main() {
     async function runNextTurn(session) {
         if (session.running || session.closed)
             return;
+        // Reserve the room before awaiting recovery so a new turn cannot race an
+        // older completion's streaming teardown. The queue remains unclaimed on
+        // failure and the ordinary host heartbeat retries it.
+        session.running = true;
+        try {
+            await recoveringOutputRooms.get(session.conversationId);
+            for (const record of completedOutputs.list()) {
+                if (record.conversationId === session.conversationId && record.output.kind === 'none' && record.output.reason === 'silent') {
+                    await deliverCompletedOutput(record);
+                }
+            }
+        }
+        catch (error) {
+            session.running = false;
+            console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Prior completion still needs cleanup:`, error);
+            return;
+        }
+        if (session.closed || sessions.get(session.conversationId) !== session) {
+            session.running = false;
+            return;
+        }
         const nextTurn = session.queue.shift();
-        if (!nextTurn)
+        if (!nextTurn) {
+            session.running = false;
             return;
-        session.running = true;
+        }
+        const inboundId = nextTurn.sourceMessageId ? `message:${session.conversationId}:${nextTurn.sourceMessageId}` : null;
+        let journaledInput = false;
+        let completedOutput;
+        let nativeCompleted = false;
         session.state.lastError = undefined;
         session.state.state = 'running';
         session.currentTurnId = randomUUID();
@@ -2180,6 +2326,12 @@ export async function main() {
                 skillInvocationText: nextTurn.skillInvocationText,
                 onServerRequest: (request) => handleCodexServerRequest(session, request, nextTurn.requestingUserId ?? null, nextTurn.sourceMessageId ?? null),
             });
+            // 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))
+                return;
+            journaledInput = !!inboundId;
             let result = await runTurnOnce();
             if (!result.interrupted
                 && !result.finalMessage
@@ -2195,6 +2347,49 @@ export async function main() {
                 session.currentTurnSilenced = false;
                 result = await runTurnOnce();
             }
+            nativeCompleted = true;
+            const turnTrail = buildFinalTurnTrail(session);
+            const deliveryMetadata = {
+                turnId: session.currentTurnId,
+                turnSemantics: 'turn_complete',
+                ...(nextTurn.sourceMessageId ? { sourceMessageId: nextTurn.sourceMessageId } : {}),
+                deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                ...(turnTrail.length > 0 ? { turnTrail } : {}),
+            };
+            const canDeliver = !result.interrupted && !!result.finalMessage && resolveSilentTurnDelivery({
+                silenced: session.currentTurnSilenced, finalText: result.finalMessage,
+            }) === 'deliver';
+            const responseRouting = buildCodexTurnResponseRouting({ requestingUserId: nextTurn.requestingUserId, ownerId });
+            const output = canDeliver && nextTurn.planMode
+                ? { kind: 'plan', body: {
+                        conversationId: session.conversationId, interactionKind: 'plan', planId: session.currentTurnId,
+                        expiresAt: Date.now() + PLAN_REVIEW_TIMEOUT_MS, title: 'Codex Plan', body: result.finalMessage, turnId: session.currentTurnId,
+                        ...(responseRouting.responseUserId ? { responseUserId: responseRouting.responseUserId } : {}),
+                    } }
+                : canDeliver || (!result.interrupted && !!result.exitCode)
+                    ? { kind: 'message', text: canDeliver ? result.finalMessage : formatCodexTurnFailure(result.errorText), options: {
+                            messageId: buildCodexMessageId(session, canDeliver ? 'final' : 'error'),
+                            ...(session.currentReplyAuthority ? { replyAuthority: session.currentReplyAuthority } : {}),
+                            ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
+                            metadata: deliveryMetadata,
+                        } }
+                    : { 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,
+                nativeThreadId: result.threadId, createdAt: new Date().toISOString(), output,
+                audience: conversationCache.has(session.conversationId) ? {
+                    memberIds: [...conversationCache.get(session.conversationId).memberIds].sort(),
+                    ...(conversationCache.get(session.conversationId).membershipRevision !== undefined
+                        ? { membershipRevision: conversationCache.get(session.conversationId).membershipRevision } : {}),
+                } : null,
+            };
+            // This is the first local evidence that native work completed. A crash
+            // before this fsynced record remains uncertain and needs its transcript;
+            // after it, recovery only republishes the exact saved Canon output.
+            completedOutputs.save(record);
+            completedOutput = record;
+            activeCompletedOutputs.add(record.turnId);
             // Both the artifact gate and the final delivery weigh silence against
             // this text, and they must weigh the same one — set it before any
             // completion branch runs, including the ones that route first.
@@ -2213,23 +2408,10 @@ export async function main() {
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
-            if (!result.interrupted
-                && result.finalMessage
-                && nextTurn.planMode
-                // A plan card carries the model's final text into the conversation as a
-                // visible, actionable artifact — it IS posting. Silence is strict here
-                // too: a silenced plan turn falls through to the silent teardown below
-                // and raises no card.
-                && resolveSilentTurnDelivery({
-                    silenced: session.currentTurnSilenced,
-                    finalText: result.finalMessage,
-                }) === 'deliver') {
+            if (completedOutput.output.kind === 'plan') {
                 await routeArtifactsOnce();
-                const responseRouting = buildCodexTurnResponseRouting({
-                    requestingUserId: nextTurn.requestingUserId,
-                    ownerId,
-                });
-                const planId = session.currentTurnId ?? randomUUID();
+                const plan = completedOutput.output.body;
+                const planId = plan.planId;
                 let planCreated = false;
                 let resolvePlanCreated;
                 let rejectPlanCreated;
@@ -2238,17 +2420,14 @@ export async function main() {
                     rejectPlanCreated = reject;
                 });
                 const planReview = runtimeRequests.request('plan', session.conversationId, {
-                    title: 'Codex Plan',
-                    body: result.finalMessage,
-                    ...(responseRouting.responseUserId
-                        ? { responseUserId: responseRouting.responseUserId }
-                        : {}),
-                    ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                    title: plan.title, body: plan.body, turnId: plan.turnId,
+                    ...(plan.responseUserId ? { responseUserId: plan.responseUserId } : {}),
                 }, {
                     requestId: planId,
-                    expiresAt: Date.now() + PLAN_REVIEW_TIMEOUT_MS,
+                    expiresAt: plan.expiresAt,
                     responderPolicy: 'infer',
-                    onCreated: () => {
+                    onCreated: async () => {
+                        await deliverCompletedOutput(completedOutput, true);
                         planCreated = true;
                         session.turnState = 'waiting_input';
                         writeTurn(session);
@@ -2257,7 +2436,7 @@ export async function main() {
                 });
                 void planReview.then((planResult) => {
                     resolvePlanCreated();
-                    enqueueCodexPlanReviewResult(session, planResult, responseRouting.responseUserId ?? null);
+                    enqueueCodexPlanReviewResult(session, planResult, plan.responseUserId ?? null);
                 }).catch((error) => {
                     if (!planCreated) {
                         rejectPlanCreated(error);
@@ -2269,40 +2448,16 @@ export async function main() {
                 await handoffFinalMessage(session.conversationId);
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent plan approval card`);
             }
-            else if (!result.interrupted
-                && result.finalMessage
-                // A turn that called `no_reply` posts nothing. The failure branches
-                // below are deliberately outside this gate: silence suppresses the
-                // MODEL's reply, never Canon's own "this turn broke" diagnostic.
-                && resolveSilentTurnDelivery({
-                    silenced: session.currentTurnSilenced,
-                    finalText: result.finalMessage,
-                }) === 'deliver') {
+            else if (completedOutput.output.kind === 'message' && canDeliver) {
                 if (isRecoverableCodexThreadError(result.errorText)) {
                     clearStoredThread();
                 }
                 await routeArtifactsOnce();
-                const turnTrail = buildFinalTurnTrail(session);
-                await sendMessageWithRetryChunked(client, session.conversationId, result.finalMessage, {
-                    messageId: buildCodexMessageId(session, 'final'),
-                    ...(session.currentReplyAuthority
-                        ? { replyAuthority: session.currentReplyAuthority }
-                        : {}),
-                    ...(session.activeSelfContextId
-                        ? { selfContextId: session.activeSelfContextId }
-                        : {}),
-                    metadata: {
-                        turnId: session.currentTurnId,
-                        turnSemantics: 'turn_complete',
-                        ...(nextTurn.sourceMessageId ? { sourceMessageId: nextTurn.sourceMessageId } : {}),
-                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
-                    },
-                });
+                await deliverCompletedOutput(completedOutput);
                 await handoffFinalMessage(session.conversationId);
-                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${completedOutput.output.text.length} chars)`);
             }
-            else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+            else if (completedOutput.output.kind === 'message') {
                 await routeArtifactsOnce();
                 const userVisibleError = formatCodexTurnFailure(result.errorText);
                 session.state.lastError = userVisibleError;
@@ -2310,23 +2465,7 @@ export async function main() {
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
-                const turnTrail = buildFinalTurnTrail(session);
-                await sendMessageWithRetryChunked(client, session.conversationId, userVisibleError, {
-                    messageId: buildCodexMessageId(session, 'error'),
-                    ...(session.currentReplyAuthority
-                        ? { replyAuthority: session.currentReplyAuthority }
-                        : {}),
-                    ...(session.activeSelfContextId
-                        ? { selfContextId: session.activeSelfContextId }
-                        : {}),
-                    metadata: {
-                        turnId: session.currentTurnId,
-                        turnSemantics: 'turn_complete',
-                        ...(nextTurn.sourceMessageId ? { sourceMessageId: nextTurn.sourceMessageId } : {}),
-                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
-                    },
-                });
+                await deliverCompletedOutput(completedOutput);
                 await handoffFinalMessage(session.conversationId);
             }
             else if (!result.interrupted) {
@@ -2344,7 +2483,7 @@ export async function main() {
                     // typing dots go together — leaving dots behind the removed row for
                     // the handoff window reads as "started to answer, then gave up".
                     await blankCodexStreaming(session);
-                    clearStreaming(session.conversationId);
+                    await runtimeState.clearStreaming(session.conversationId);
                     stopVisibleWorkSignal(session);
                 }
                 await handoffFinalMessage(session.conversationId);
@@ -2357,8 +2496,23 @@ export async function main() {
                 typingSignals.clear(session.conversationId).catch(() => { });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
             }
+            if (completedOutput.output.kind === 'none')
+                await deliverCompletedOutput(completedOutput);
         }
         catch (error) {
+            if (nativeCompleted) {
+                session.state.lastError = completedOutput
+                    ? 'Native work completed; its saved Canon output awaits delivery reconciliation.'
+                    : 'Native work completed, but its output could not be journaled. Operator reconciliation is required.';
+                writeState(session);
+                console.error(`[canon-codex] Native completion ${session.currentTurnId} needs reconciliation:`, error);
+                return;
+            }
+            if (isPendingCanonOperation(error)) {
+                session.state.lastError = 'Canon delivery remains pending reconciliation.';
+                writeState(session);
+                return;
+            }
             const message = error instanceof ExecutionEnvironmentError
                 ? error.userMessage
                 : error instanceof CanonApiError
@@ -2392,6 +2546,8 @@ export async function main() {
             console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
         }
         finally {
+            if (completedOutput)
+                activeCompletedOutputs.delete(completedOutput.turnId);
             session.currentTurnAbortController?.abort(new Error('Codex turn ended'));
             session.currentTurnAbortController = null;
             recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
@@ -2653,75 +2809,10 @@ export async function main() {
             console.error(`[canon-codex] Runtime ${operation} failed:`, error);
         },
     });
-    let startupRecoveryComplete = false;
     async function recoverInboundMessageGaps() {
-        // A reconnect can reveal conversations created while this host was
-        // offline. Refresh before sweeping cursors; this is one REST reconciliation
-        // pass, not an automatic retry loop.
-        const knownBeforeRefresh = new Set(knownConversationIds);
+        // Refresh discovery only. Timeline reconstruction is never authorization to
+        // execute historical turns; admitted pending work lives in the endpoint inbox.
         await refreshKnownConversationIds(true);
-        const conversationsDiscoveredWhileOffline = startupRecoveryComplete
-            ? new Set([...knownConversationIds].filter((id) => !knownBeforeRefresh.has(id)))
-            : new Set();
-        for (const conversationId of knownConversationIds) {
-            const recoveryCheckpoints = recoveryCheckpointsFor(conversationId);
-            const recoveryBatch = recoveryCheckpoints.reserveBatch();
-            try {
-                const cursor = loadRuntimeSessionState(runtimeId, {
-                    conversationId,
-                    baseCwd: workingDir,
-                })?.lastInboundMessageId ?? null;
-                const recovered = await collectMissedInboundMessages({
-                    fetchPage: (before) => client.getMessagesPage(conversationId, STARTUP_RECOVERY_PAGE_SIZE, before),
-                    cursor,
-                    agentId,
-                    requireContiguousCursor: true,
-                    noCursorMode: conversationsDiscoveredWhileOffline.has(conversationId)
-                        ? 'bounded-window'
-                        : 'latest-only',
-                });
-                recoveryBatch.commit(recovered.messages.map((message) => message.id), recovered.mode === 'incomplete-gap' ? recovered.recoveryCursor : null);
-                if (recovered.mode === 'incomplete-gap') {
-                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] recovery_incomplete_gap: cursor is missing; replaying ${recovered.messages.length} bounded inbound message(s) before advancing to ${recovered.recoveryCursor ?? 'no cursor'}`);
-                }
-                for (const message of recovered.messages) {
-                    const isPlanReply = isCodexPlanApprovalReply(message.metadata, serviceAgentMode);
-                    if (!isPlanReply && !shouldTriggerAgentTurn({
-                        senderType: message.senderType,
-                        metadata: message.metadata,
-                    }).allow) {
-                        recoveryCheckpoints.settle(message.id);
-                        continue;
-                    }
-                    if (!claimInboundMessageId(message.id))
-                        continue;
-                    try {
-                        await enqueueInboundMessage({
-                            conversationId,
-                            message,
-                            senderName: message.senderName || message.senderId,
-                            isOwner: message.senderId === ownerId,
-                            behavior: recovered.newestPage.behavior,
-                            activeSelfContextId: recovered.newestPage.activeSelfContextIdByMessageId?.[message.id] ?? null,
-                            selfContexts: recovered.newestPage.selfContexts,
-                            hydratedPage: recovered.newestPage,
-                        });
-                        settleInboundMessageId(message.id, true);
-                    }
-                    catch (error) {
-                        settleInboundMessageId(message.id, false);
-                        throw error;
-                    }
-                }
-                if (recovered.messages.length > 0) {
-                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Recovered ${recovered.messages.length} inbound message(s) (${recovered.mode})`);
-                }
-            }
-            catch (error) {
-                recoveryBatch.cancel();
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Recovery failed:`, error instanceof Error ? error.message : error);
-            }
-        }
     }
     const reconnectRecovery = createReconnectRecoveryCoordinator(recoverInboundMessageGaps);
     const observeReconnectRecovery = (reason, recovery) => {
@@ -2731,39 +2822,50 @@ export async function main() {
             console.error(`[canon-codex] ${reason} recovery failed:`, error instanceof Error ? error.message : error);
         });
     };
+    const inbound = endpoint.acceptInbound({ kind: 'message.created',
+        offer: async (event) => {
+            const payload = event.data;
+            const message = payload.message;
+            if (message.senderId === agentId) {
+                await endpoint.setInboundState(event.id, 'settled', 'own-message');
+                return;
+            }
+            if (!claimInboundMessageId(message.id))
+                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');
+                return;
+            }
+            await enqueueInboundMessage({
+                conversationId: payload.conversationId,
+                message,
+                senderName: message.senderName || message.senderId,
+                isOwner: message.isOwner ?? (ownerId != null && message.senderId === ownerId),
+                behavior: payload.behavior,
+                activeSelfContextId: payload.activeSelfContextId,
+                selfContexts: payload.selfContexts,
+                provenance: payload.provenance,
+                turnDispatch: payload.turnDispatch,
+                replyAuthority: payload.replyAuthority,
+            }).then(() => settleInboundMessageId(message.id, true), (error) => {
+                settleInboundMessageId(message.id, false);
+                console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Failed to queue inbound message:`, error instanceof Error ? error.message : error);
+                throw error;
+            });
+        },
+        onError: (error) => console.error('[canon-codex] Endpoint input deferred:', error), });
     const stream = new CanonStream({
-        apiKey,
+        endpoint,
         agentId,
-        streamUrl,
         handler: {
             onMessage: (payload) => {
-                const message = payload.message;
-                if (message.senderId === agentId)
-                    return;
-                if (!claimInboundMessageId(message.id))
-                    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);
-                    return;
-                }
-                void enqueueInboundMessage({
-                    conversationId: payload.conversationId,
-                    message,
-                    senderName: message.senderName || message.senderId,
-                    isOwner: message.isOwner ?? (ownerId != null && message.senderId === ownerId),
-                    behavior: payload.behavior,
-                    activeSelfContextId: payload.activeSelfContextId,
-                    selfContexts: payload.selfContexts,
-                    provenance: payload.provenance,
-                    turnDispatch: payload.turnDispatch,
-                    replyAuthority: payload.replyAuthority,
-                }).then(() => settleInboundMessageId(message.id, true), (error) => {
-                    settleInboundMessageId(message.id, false);
-                    console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Failed to queue inbound message:`, error instanceof Error ? error.message : error);
-                });
+                void inbound.receive({ id: `message:${payload.conversationId}:${payload.message.id}`,
+                    kind: 'message.created', conversationId: payload.conversationId, durable: true,
+                    data: payload });
             },
             onMessageDeleted: (payload) => {
                 removeQueuedPrompt(payload.conversationId, payload.messageId);
@@ -2798,7 +2900,8 @@ export async function main() {
         for (const conversation of conversations) {
             knownConversationIds.add(conversation.id);
             conversationCache.set(conversation.id, conversation);
-            clearStreaming(conversation.id);
+            await clearCompletedSilentStreaming(conversation.id);
+            await runtimeState.clearStreaming(conversation.id);
             runtimeState.clearSessionState(conversation.id).catch(() => { });
             runtimeState.clearTurnState(conversation.id).catch(() => { });
         }
@@ -2809,16 +2912,20 @@ export async function main() {
     await reconnectRecovery.recoverNow().catch((error) => {
         console.error('[canon-codex] Startup recovery failed:', error instanceof Error ? error.message : error);
     });
-    startupRecoveryComplete = true;
+    void recoverCompletedOutputs().catch((error) => console.error('[canon-codex] Completed output recovery failed:', error));
+    inbound.start();
     startCodexStreamInBackground(stream, (error) => {
         console.error('[canon-codex] SSE start error:', error instanceof Error ? error.message : error);
     });
     controlPoller.start();
     const heartbeat = setInterval(() => {
+        void recoverCompletedOutputs().catch((error) => console.error('[canon-codex] Completed output recovery failed:', error));
         for (const session of sessions.values()) {
             writeState(session);
             if (!session.running) {
                 writeTurn(session);
+                if (session.queue.length)
+                    void runNextTurn(session);
             }
         }
         publishLocalHeartbeat();
@@ -2845,6 +2952,7 @@ export async function main() {
         }
         runtimeRequests.dispose();
         stream.stop();
+        await inbound.close();
         await runtimeHeartbeat.dispose();
         for (const session of [...sessions.values()]) {
             await session.adapter.interrupt().catch(() => { });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.31.0",
+  "version": "0.32.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -31,15 +31,15 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^10.4.0",
-    "@canonmsg/agent-tools": "^0.10.0",
-    "@canonmsg/coding-agent-host": "^0.8.0",
-    "@canonmsg/core": "^12.5.0",
-    "@canonmsg/rich-cards": "^0.10.5",
+    "@canonmsg/agent-sdk": "^11.0.0",
+    "@canonmsg/agent-tools": "^0.11.0",
+    "@canonmsg/coding-agent-host": "^0.9.0",
+    "@canonmsg/core": "^13.0.3",
+    "@canonmsg/rich-cards": "^0.10.6",
     "ws": "^8.21.3"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.22.3"
   },
   "keywords": [
     "canon",