@canonmsg/codex-plugin 0.32.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, 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, 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 { 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';
@@ -816,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();
@@ -991,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(() => { });
     }
@@ -1028,7 +1125,7 @@ export async function main() {
             messageId: session.currentTurnId ?? undefined,
             turnId: session.currentTurnId,
             blocks: [],
-        }).catch(() => { });
+        });
     }
     function upsertCodexTextSegment(session, event) {
         const next = applyTextSegmentBlock({
@@ -1091,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) {
@@ -1239,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 {
@@ -1897,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,
@@ -1967,12 +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();
@@ -2211,8 +2347,49 @@ export async function main() {
                 session.currentTurnSilenced = false;
                 result = await runTurnOnce();
             }
-            if (journaledInput)
-                await endpoint.setInboundState(inboundId, 'settled', 'native-completed');
+            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.
@@ -2231,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;
@@ -2256,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);
@@ -2275,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);
@@ -2287,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;
@@ -2328,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) {
@@ -2362,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);
@@ -2375,8 +2496,18 @@ 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);
@@ -2415,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);
@@ -2725,7 +2858,6 @@ export async function main() {
             });
         },
         onError: (error) => console.error('[canon-codex] Endpoint input deferred:', error), });
-    inbound.start();
     const stream = new CanonStream({
         endpoint,
         agentId,
@@ -2768,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(() => { });
         }
@@ -2779,15 +2912,20 @@ export async function main() {
     await reconnectRecovery.recoverNow().catch((error) => {
         console.error('[canon-codex] Startup recovery failed:', error instanceof Error ? error.message : error);
     });
+    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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,7 @@
     "@canonmsg/agent-sdk": "^11.0.0",
     "@canonmsg/agent-tools": "^0.11.0",
     "@canonmsg/coding-agent-host": "^0.9.0",
-    "@canonmsg/core": "^13.0.0",
+    "@canonmsg/core": "^13.0.3",
     "@canonmsg/rich-cards": "^0.10.6",
     "ws": "^8.21.3"
   },