@canonmsg/codex-plugin 0.20.0 → 0.22.0

package/dist/host.js

@@ -1,30 +1,25 @@
 #!/usr/bin/env node
 import { setDefaultResultOrder } from 'node:dns';
 import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
-import { getCodexImagePath, inferUploadMimeType, materializeMessageMedia, materializeReplyContextMedia, } from '@canonmsg/agent-sdk';
-import { resolvePackagedBridgeBin } from './bridge-bin.js';
-import { connectBridge } from '@canonmsg/framework';
-import { ConnectionClosedError, JsonRpcError } from '@canonmsg/framework/protocol';
-/** Send failed at the Canon/bridge boundary (turn itself completed). */
-function isBridgeDeliveryError(error) {
-    return error instanceof JsonRpcError || error instanceof ConnectionClosedError;
-}
-import { STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, captureTurnArtifactSnapshot, collectMissedInboundMessages, collectTurnArtifacts, createBufferedNotificationSource, createConversationDirectory, createFinalDelivery, createHitlWaiters, createPortTypingSignals, createRuntimeSignalHandler, createRuntimeWriters, createSessionLifecycle, createTurnQueue, decideAutoReply, handoffFinalMessage, } from '@canonmsg/agent-host';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, resolveQuestionAllowOther, buildCanonTurnContextV2, buildFirstPartyCodingRuntimeDescriptor, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, EXECUTION_ENVIRONMENT_MODES, DEFAULT_RUNTIME_CAPABILITIES, normalizeTurnMetadata, parseRuntimeCardV1, shouldTriggerAgentTurn, renderCanonHostInboundContent, renderCodingHostInboundPrompt, } from '@canonmsg/core/contract';
-import { ExecutionEnvironmentError, buildConfiguredWorkspaceOptionsWithRoots, buildLocalRuntimeId, buildPublicWorkspaceOptions, buildPublicWorkspaceRoots, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, prepareConversationEnvironment, releaseConversationEnvironment, resolveCanonAgent, saveRuntimeSessionState, upsertLocalRuntimeEntry, } from '@canonmsg/core/local';
-import { readHostSessionConfig, resolveHostWorkspaceCwd, } from '@canonmsg/core/host';
-import { CodexAppServerAdapter, } from './app-server-adapter.js';
+import { getCodexImagePath, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
+import { captureTurnArtifactSnapshot, collectTurnArtifacts, } from '@canonmsg/coding-agent-host';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, CanonApiError, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { decideAutoReply, } from './inbound-policy.js';
+import { CodexConversationAdapter, } from './adapter.js';
+import { CodexAppServerAdapter } from './app-server-adapter.js';
 import { CODEX_APP_DYNAMIC_TOOLS, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, } from './codex-app-tools.js';
 import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 import { deriveCodexPermissionEnvelope, mapCanonPermissionToCodex, } from './permission-mode.js';
 import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
-import { attachCodexControlNotifications } from './control-channel.js';
+import { startCodexStreamInBackground } from './host-lifecycle.js';
+import { createCodexControlPoller } from './control-channel.js';
 import { runCli } from './cli-entry.js';
-import { beginCommandBlock, applyCodexMessageToStreamingOutput, claimCommandBlock, createCommandBlockTracker, hasSpeechSegmentText, } from './turn-activity.js';
+import { applyTextSegmentBlock, beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -76,29 +71,10 @@ export function buildCodexLiveSessionConfig(input) {
         executionBranch: input.executionBranch ?? null,
     };
 }
-function buildCodexQueuedInput(input) {
-    return {
-        turnKey: randomUUID(),
-        prompt: input.prompt,
-        intent: input.intent ?? 'queue',
-        sourceMessageId: input.sourceMessageId ?? null,
-        markAccepted: Boolean(input.markAccepted),
-        imagePaths: input.imagePaths ?? [],
-        mediaAddDirs: input.mediaAddDirs ?? [],
-        planMode: Boolean(input.planMode),
-        artifactRoutingMode: input.artifactRoutingMode ?? 'disabled',
-        canUseCodexAppTools: Boolean(input.canUseCodexAppTools),
-    };
-}
 const MAX_SESSIONS = 12;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
-/** Claude's streaming write throttle, adopted for both hosts (bridge plan Phase 2). */
-const STREAMING_THROTTLE_MS = 250;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
-/** Claude's bounded final-delivery retry machine, adopted for both hosts (bridge plan Phase 2). */
-const FINAL_DELIVERY_RETRY_MS = 30_000;
-const MAX_FINAL_DELIVERY_RETRIES = 1;
 const CODEX_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
@@ -106,40 +82,6 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsQueue: true,
     supportsNonFinalPermanentMessages: false,
 };
-function isCodexTraceEnabled() {
-    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
-}
-function createCodexTracePort(port) {
-    if (!isCodexTraceEnabled())
-        return port;
-    return new Proxy(port, {
-        get(target, property, receiver) {
-            if (property !== 'publishStreaming') {
-                return Reflect.get(target, property, receiver);
-            }
-            return async (input) => {
-                const startedAt = Date.now();
-                const textLength = typeof input.text === 'string' ? input.text.length : 0;
-                console.error(`[canon-codex-trace] publishStreaming sent conversation=${input.conversationId} turn=${input.turnId ?? input.messageId ?? 'unknown'} textLen=${textLength}`);
-                try {
-                    const result = await target.publishStreaming(input);
-                    console.error(`[canon-codex-trace] publishStreaming ack conversation=${input.conversationId} ackMs=${Date.now() - startedAt}`);
-                    return result;
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    console.error(`[canon-codex-trace] publishStreaming error conversation=${input.conversationId} ackMs=${Date.now() - startedAt} error=${message}`);
-                    throw error;
-                }
-            };
-        },
-    });
-}
-// This host process resolves and locks exactly one agent profile. The lock
-// handle returned by resolveCanonAgent is held here so the top-level runCli
-// error handler (outside main's scope) can release it on a failed start —
-// there is no core module-global profile-lock to fall back on.
-let activeLockHandle = null;
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let workspaceRoots = [];
@@ -300,15 +242,15 @@ function buildCodexModelOptions(model) {
         ? [{ value: model.trim(), label: modelOptionLabel(model.trim()) }]
         : [];
 }
-async function publishAgentRuntime(port, runtime) {
-    await port.publishHostAgentRuntime({
-        clientType: 'codex',
-        runtime: runtime,
-    });
+async function publishAgentRuntime(agentId, runtime) {
+    await publishHostAgentRuntime(agentId, 'codex', runtime);
 }
-async function loadSessionConfig(port, conversationId) {
-    const raw = await port.getSessionConfig({ conversationId });
-    return readHostSessionConfig(raw, CODEX_SESSION_CONFIG_FIELDS);
+async function loadSessionConfig(conversationId, agentId) {
+    return loadHostSessionConfig({
+        conversationId,
+        agentId,
+        extraStringFields: CODEX_SESSION_CONFIG_FIELDS,
+    });
 }
 function resolveSessionExecutionMode(config) {
     if (config?.executionMode)
@@ -346,7 +288,9 @@ function resolveCodexEffectiveRuntimePolicy(input) {
     }
     const approvalOverride = mapCanonPermissionToCodex(permissionMode);
     const defaultSandbox = (stringArg(input.args, 'sandbox') ?? null);
+    const defaultApprovalPolicy = (stringArg(input.args, 'ask-for-approval') ?? null);
     const sandbox = approvalOverride ? approvalOverride.sandbox : defaultSandbox;
+    const approvalPolicy = approvalOverride ? null : defaultApprovalPolicy;
     const fullAuto = approvalOverride ? approvalOverride.fullAuto : boolArg(input.args, 'full-auto');
     const bypassApprovalsAndSandbox = approvalOverride
         ? approvalOverride.bypassApprovalsAndSandbox
@@ -356,6 +300,7 @@ function resolveCodexEffectiveRuntimePolicy(input) {
         executionMode: input.environment.mode,
         permissionMode: permissionMode ?? null,
         sandbox,
+        approvalPolicy,
         fullAuto,
         bypassApprovalsAndSandbox,
     });
@@ -363,6 +308,7 @@ function resolveCodexEffectiveRuntimePolicy(input) {
         ...(model ? { model } : {}),
         ...(permissionMode ? { permissionMode } : {}),
         sandbox,
+        approvalPolicy,
         fullAuto,
         bypassApprovalsAndSandbox,
         fingerprint,
@@ -420,6 +366,17 @@ function stringArgs(value) {
         ? value.filter((item) => typeof item === 'string' && item.trim().length > 0)
         : undefined;
 }
+function supportsCodexAppServer(codexBin) {
+    if (process.env.CANON_CODEX_TRANSPORT === 'exec')
+        return false;
+    if (process.env.CANON_CODEX_TRANSPORT === 'app-server')
+        return true;
+    const result = spawnSync(codexBin, ['app-server', '--help'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'ignore', 'ignore'],
+    });
+    return result.status === 0;
+}
 function parsePlanCommand(content) {
     const trimmed = content.trimStart();
     if (!trimmed.startsWith('/plan'))
@@ -495,6 +452,7 @@ export async function main() {
             model: { type: 'string' },
             sandbox: { type: 'string' },
             'ask-for-approval': { type: 'string' },
+            'codex-profile': { type: 'string' },
             'add-dir': { type: 'string', multiple: true },
             workspace: { type: 'string', multiple: true },
             'workspace-root': { type: 'string', multiple: true },
@@ -527,52 +485,95 @@ export async function main() {
     }
     const codexBin = typeof args['codex-bin'] === 'string' ? args['codex-bin'] : 'codex';
     const codexCliStatus = detectCodexCliVersion(codexBin);
+    const useAppServer = supportsCodexAppServer(codexBin);
     if (codexCliStatus.version) {
         console.error(`[canon-codex] Detected Codex CLI ${codexCliStatus.version} (${codexBin})`);
     }
     else {
         console.error(`[canon-codex] Could not detect Codex CLI version for ${codexBin}: ${codexCliStatus.error ?? 'unknown result'}`);
     }
-    const { agentName: profileAgentName, profile, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-codex]', expectedClientType: 'codex' });
-    activeLockHandle = lockHandle ?? null;
+    console.error(`[canon-codex] Codex transport: ${useAppServer ? 'app-server' : 'exec --json'}`);
+    const { apiKey, agentId: profileAgentId, agentName: profileAgentName, profile, baseUrl, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-codex]', expectedClientType: 'codex' });
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
-    // ── Canon via the Bridge (bridge-execution-plan Phase 6) ──
-    // The daemon owns the SSE stream, RTDB auth, control polling, dedup and
-    // reconnect; notification handlers register through a buffered source
-    // inside `configure` (replay-safe) and attach after the machinery exists.
-    const notifications = createBufferedNotificationSource([
-        'ready',
-        'connectionState',
-        'onMessage',
-        'onMessageDeleted',
-        'onConversationUpdated',
-        'onSessionControl',
-        'onControlSignal',
-        'onControlPrimitive',
-        'onControlReply',
-    ]);
-    const bridge = await connectBridge({
-        ...(profile ? { profile } : {}),
-        mode: 'auto',
-        ...(resolvePackagedBridgeBin() ? { binPath: resolvePackagedBridgeBin() } : {}),
-        hello: {
-            clientType: 'codex',
-            wantFamilies: ['messages', 'runtime_turn'],
-        },
-        configure: (bridgeClient) => notifications.connect(bridgeClient),
+    const client = new CanonClient(apiKey, baseUrl);
+    const rtdb = initRTDBAuth(client);
+    const typingSignals = createTypingStatusPublisher({
+        setTyping: (conversationId, typing, status) => status
+            ? client.setTyping(conversationId, typing, status)
+            : client.setTyping(conversationId, typing),
     });
-    // The BridgeClient's zod-derived result shapes mirror the core wire types
-    // structurally; the port pins the strong types the host machinery uses.
-    const port = createCodexTracePort(bridge.client);
-    bridge.client.onProtocolError((error) => {
-        console.error(`[canon-codex] Bridge protocol error: ${error.message}`);
+    let agentId;
+    let ownerId = null;
+    let ownerName = null;
+    try {
+        const ctx = await client.getAgentMe();
+        agentId = ctx.agentId;
+        ownerId = ctx.ownerId;
+        ownerName = ctx.ownerName;
+        console.error(`[canon-codex] Connected as ${ctx.displayName || agentId}`);
+    }
+    catch {
+        if (profileAgentId) {
+            agentId = profileAgentId;
+        }
+        else {
+            const auth = await client.getAuthToken();
+            agentId = auth.agentId;
+        }
+        console.error(`[canon-codex] Authenticated as ${agentId}`);
+    }
+    // Shared poll/timeout engine. Built-in `input`/`card` descriptors own
+    // create+poll (codex passes native/responder policy via payload/options).
+    // Approval keeps codex's own resolution shape (no owner-authored outcome
+    // messages / session rules — that is the SDK ApprovalManager's job).
+    const runtimeRequests = new RuntimeRequestManager(client, {
+        agentId,
+        ownerId: ownerId ?? '',
+    });
+    runtimeRequests.register('approval', {
+        kind: 'approval',
+        generateId: () => randomUUID(),
+        create: async ({ client: apiClient, ctx, conversationId, requestId, payload, expiresAt }) => {
+            await apiClient.createRuntimeApprovalRequest({
+                conversationId,
+                approvalId: requestId,
+                toolName: payload.toolName,
+                toolSummary: payload.toolSummary,
+                category: payload.category,
+                risk: payload.risk,
+                riskLevel: payload.riskLevel,
+                native: payload.native,
+                details: payload.details,
+                ...(payload.diff ? { diff: payload.diff } : {}),
+                responseUserId: ctx.ownerId || undefined,
+                allowSessionRule: true,
+                expiresAt,
+                ...(payload.turnId ? { turnId: payload.turnId } : {}),
+            });
+            return { requestId };
+        },
+        consume: async ({ client: apiClient, conversationId, requestId }) => {
+            const response = await apiClient
+                .consumeRuntimeApprovalResponse({ conversationId, approvalId: requestId })
+                .catch(() => null);
+            if (response?.status === 'allow') {
+                return {
+                    state: 'resolved',
+                    result: {
+                        decision: 'allow',
+                        ...(response.sessionRule ? { sessionRule: response.sessionRule } : {}),
+                    },
+                };
+            }
+            if (response?.status === 'deny') {
+                return { state: 'resolved', result: { decision: 'deny' } };
+            }
+            if (response?.status === 'timeout')
+                return { state: 'timeout' };
+            return { state: 'pending' };
+        },
+        timeoutResult: () => ({ decision: 'deny' }),
     });
-    const typingSignals = createPortTypingSignals(port);
-    const agentId = bridge.hello.agentId;
-    const ownerId = bridge.hello.agentContext.ownerId ?? null;
-    const ownerName = bridge.hello.agentContext.ownerName ?? null;
-    console.error(`[canon-codex] Connected as ${bridge.hello.agentName || agentId} `
-        + `(canon-bridge${bridge.spawnedDaemon ? ' spawned' : ''} at ${bridge.socketPath})`);
     const launchArgs = [...process.argv.slice(2)];
     if (!launchArgs.some((arg) => arg === '--cwd' || arg.startsWith('--cwd='))) {
         launchArgs.push('--cwd', workingDir);
@@ -601,81 +602,292 @@ export async function main() {
         lastStartedAt: new Date().toISOString(),
         lastHeartbeatAt: new Date().toISOString(),
     });
-    // ── Conversation directory (shared inbound-ingestion bookkeeping from @canonmsg/agent-host) ──
-    const directory = createConversationDirectory({
+    const runtimeState = createRuntimeStatePublisher({
         agentId,
-        ownerId,
-        ownerName,
-        refreshFloorMs: HEARTBEAT_MS,
-    }, { port });
-    const { conversationCache, knownConversationIds, refreshKnownConversationIds, handleConversationUpdated, markGroupContextModeUsed, loadHydratedInboundContext, } = directory;
+        clientType: 'codex',
+        hostMode: true,
+    });
+    const sessions = new Map();
+    const pendingSessionCreations = new Map();
+    const conversationCache = new Map();
+    const knownConversationIds = new Set();
+    const promptedGroupContextConversationIds = new Set();
+    const pendingMembershipChanges = new Map();
+    let lastKnownConversationRefreshAt = 0;
+    const { getConversationMeta } = createConversationMetadataLoader({
+        client,
+        conversationCache,
+    });
     function resolveWorkspaceIdForBaseCwd(baseCwd) {
         return workspaceOptions.find((option) => option.cwd === baseCwd)?.id;
     }
+    async function refreshKnownConversationIds(force = false) {
+        if (!force && Date.now() - lastKnownConversationRefreshAt < HEARTBEAT_MS) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        knownConversationIds.clear();
+        for (const conversation of conversations) {
+            knownConversationIds.add(conversation.id);
+            conversationCache.set(conversation.id, conversation);
+        }
+        lastKnownConversationRefreshAt = Date.now();
+    }
+    function handleConversationUpdated(payload) {
+        const rawMemberIds = payload.changes.memberIds;
+        if (!Array.isArray(rawMemberIds))
+            return;
+        const memberIds = rawMemberIds.filter((id) => typeof id === 'string');
+        const cached = conversationCache.get(payload.conversationId);
+        const membershipChange = payload.membershipChange
+            ?? (cached ? diffCanonMemberIds(cached.memberIds, memberIds) : null);
+        if (cached) {
+            conversationCache.set(payload.conversationId, {
+                ...cached,
+                memberIds,
+            });
+        }
+        if (membershipChange) {
+            pendingMembershipChanges.set(payload.conversationId, membershipChange);
+        }
+        if (!memberIds.includes(agentId)) {
+            knownConversationIds.delete(payload.conversationId);
+            conversationCache.delete(payload.conversationId);
+        }
+    }
+    function getGroupContextMode(conversationId, conversation) {
+        if (conversation?.type !== 'group')
+            return undefined;
+        if (pendingMembershipChanges.has(conversationId))
+            return 'membership_change';
+        if (!promptedGroupContextConversationIds.has(conversationId))
+            return 'initial';
+        return undefined;
+    }
+    function markGroupContextModeUsed(conversationId, mode) {
+        if (!mode)
+            return;
+        promptedGroupContextConversationIds.add(conversationId);
+        if (mode === 'membership_change') {
+            pendingMembershipChanges.delete(conversationId);
+        }
+    }
+    async function loadHydratedInboundContext(input) {
+        const [conversation, page] = await Promise.all([
+            getConversationMeta(input.conversationId),
+            input.hydratedPage
+                ? Promise.resolve(input.hydratedPage)
+                : client.getMessagesPage(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => null),
+        ]);
+        return buildHydratedInboundContext({
+            agentId,
+            conversationId: input.conversationId,
+            conversation,
+            page,
+            activeSelfContextId: input.activeSelfContextId,
+            selfContexts: input.selfContexts,
+            provenance: input.provenance,
+            message: input.message,
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            ownerId,
+            ownerName,
+            membershipChange: pendingMembershipChanges.get(input.conversationId) ?? null,
+            groupContextMode: getGroupContextMode(input.conversationId, conversation),
+        });
+    }
+    function writeState(session) {
+        const appliedAt = Date.now();
+        const controlState = {};
+        if (session.state.model !== undefined) {
+            controlState.model = { value: session.state.model, source: 'applied', appliedAt };
+        }
+        if (session.state.permissionMode !== undefined) {
+            controlState.permissionMode = { value: session.state.permissionMode, source: 'applied', appliedAt };
+        }
+        if (session.state.effort !== undefined) {
+            controlState.effort = { value: session.state.effort, source: 'applied', appliedAt };
+        }
+        runtimeState.writeSessionState(session.conversationId, {
+            lastError: session.state.lastError,
+            model: session.state.model,
+            permissionMode: session.state.permissionMode,
+            effort: session.state.effort,
+            controlState,
+            cwd: session.cwd,
+            executionMode: session.environment.mode,
+            ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+            ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
+            ...(resolveExecutionFallbackReason(session.environment)
+                ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
+                : {}),
+            hostMode: true,
+            clientType: 'codex',
+            isActive: true,
+            ...(session.state.contextUsage ? { contextUsage: session.state.contextUsage } : {}),
+        }).catch(() => { });
+    }
+    function writeTurn(session) {
+        const isOpenTurn = session.turnState === 'thinking'
+            || session.turnState === 'streaming'
+            || session.turnState === 'tool'
+            || session.turnState === 'waiting_input';
+        runtimeState.writeTurnState(session.conversationId, {
+            turnId: session.currentTurnId,
+            state: session.turnState,
+            queueDepth: session.queue.length,
+            currentSpeakerId: agentId,
+            lastAcceptedIntent: session.lastAcceptedIntent,
+            capabilities: CODEX_RUNTIME_CAPABILITIES,
+            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+            ...(isOpenTurn && session.currentTurnUpdatedAt ? { turnUpdatedAt: session.currentTurnUpdatedAt } : {}),
+            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                ? { completedAt: { '.sv': 'timestamp' } }
+                : {}),
+        }).catch(() => { });
+    }
+    function markTurnProgress(session) {
+        session.currentTurnUpdatedAt = Date.now();
+    }
     async function markQueuedMessageAccepted(conversationId, sourceMessageId, markAccepted) {
         if (!markAccepted || !sourceMessageId)
             return;
-        await port.setDisposition({
-            conversationId,
-            messageId: sourceMessageId,
-            inboundDisposition: 'accepted_now',
+        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
+    }
+    async function markQueuedPromptsRejected(conversationId, prompts) {
+        await Promise.all(prompts.map((prompt) => {
+            if (!prompt.markAccepted || !prompt.sourceMessageId)
+                return Promise.resolve();
+            return client.updateMessageDisposition(conversationId, prompt.sourceMessageId, 'rejected').catch(() => { });
+        }));
+    }
+    function removeQueuedPrompt(conversationId, sourceMessageId) {
+        const session = sessions.get(conversationId);
+        if (!session || session.queue.length === 0)
+            return;
+        const before = session.queue.length;
+        session.queue = session.queue.filter((prompt) => prompt.sourceMessageId !== sourceMessageId);
+        if (session.queue.length !== before) {
+            writeTurn(session);
+        }
+    }
+    function clearStreaming(conversationId) {
+        runtimeState.clearStreaming(conversationId).catch(() => { });
+    }
+    function writeCodexStreaming(session, text, status) {
+        if (text !== null) {
+            session.turnLiveText = text;
+        }
+        runtimeState.writeStreaming(session.conversationId, {
+            text: session.turnLiveText,
+            status,
+            messageId: session.currentTurnId ?? undefined,
+            turnId: session.currentTurnId,
+            blocks: session.turnBlocks,
         }).catch(() => { });
     }
+    function upsertCodexTextSegment(session, event) {
+        const next = applyTextSegmentBlock({
+            turnLiveText: session.turnLiveText,
+            turnBlocks: session.turnBlocks,
+        }, {
+            turnId: session.currentTurnId,
+            itemId: event.itemId,
+            text: event.text,
+        });
+        session.turnLiveText = next.turnLiveText;
+        session.turnBlocks = next.turnBlocks;
+    }
+    function upsertTurnBlock(session, block) {
+        const now = Date.now();
+        const index = session.turnBlocks.findIndex((existing) => existing.id === block.id);
+        const existing = index >= 0 ? session.turnBlocks[index] : null;
+        const next = {
+            ...(existing ?? {
+                sequence: session.turnBlocks.length + 1,
+                createdAt: now,
+            }),
+            ...block,
+            turnId: session.currentTurnId ?? block.id,
+            updatedAt: now,
+        };
+        session.turnBlocks = index >= 0
+            ? [
+                ...session.turnBlocks.slice(0, index),
+                next,
+                ...session.turnBlocks.slice(index + 1),
+            ]
+            : [...session.turnBlocks, next];
+    }
+    function completeTurnBlock(session, id, summary) {
+        const existing = session.turnBlocks.find((block) => block.id === id);
+        if (!existing)
+            return;
+        upsertTurnBlock(session, {
+            id,
+            kind: existing.kind,
+            status: 'completed',
+            title: existing.title,
+            text: existing.text,
+            summary: summary ?? existing.summary,
+        });
+    }
+    function buildFinalTurnTrail(session) {
+        return buildBoundedTurnTrail(session.turnBlocks.map((block) => ({
+            ...block,
+            turnId: session.currentTurnId ?? block.turnId,
+        })));
+    }
     function buildCodexMessageId(session, kind) {
         return `codex-${kind}-${session.currentTurnId ?? randomUUID()}`;
     }
     function buildCodexRuntimeCardOutcomeMessageId(cardId, status) {
         return `codex-card-${cardId}-${status}`;
     }
-    // ── Session manager (generic lifecycle from @canonmsg/agent-host) ──
-    const lifecycle = createSessionLifecycle({
-        maxSessions: MAX_SESSIONS,
-        idleTimeoutMs: IDLE_TIMEOUT_MS,
-        heartbeatMs: HEARTBEAT_MS,
-        idleCheckMs: IDLE_CHECK_MS,
-        logPrefix: '[canon-codex]',
-    }, {
-        knownConversationIds,
-        createSession: (conversationId) => createSessionForConversation(conversationId),
-        isSessionRunning: (session) => session.running,
-        writeTurnOnHeartbeat: (session) => !session.running,
-        writeSessionState: (session) => session.writeState(),
-        writeSessionTurn: (session) => session.writeTurn(),
-        releaseEnvironment: (session) => releaseConversationEnvironment(session.environment),
-        // Codex resume state (thread ids) is persisted during turns, not on close.
-        persistResumeState: () => { },
-        disposeRuntime: (session) => {
-            if ('close' in session.adapter && typeof session.adapter.close === 'function') {
-                session.adapter.close();
-            }
-        },
-        interruptRuntime: (session) => session.adapter.interrupt(),
-        port,
-        publishRuntimeHeartbeat: () => publishRuntimeHeartbeat(),
-        onShutdown: async () => {
-            detachControlNotifications();
-            notifications.detach();
-            await port.clearAgentRuntime().catch(() => { });
-            for (const session of [...sessions.values()]) {
-                await session.adapter.interrupt().catch(() => { });
-            }
-            bridge.client.close();
-        },
-        onShutdownComplete: () => {
-            markLocalRuntimeStopped(runtimeId);
-            lockHandle?.release();
-        },
-    });
-    const { sessions, getOrCreateSession, markSessionPendingInputsRejected, removeQueuedInput, } = lifecycle;
-    /**
-     * Codex-specific new-session reset: clear the stored Codex thread and keep
-     * the Canon session alive (unlike claude, which closes and re-creates).
-     */
+    async function handoffFinalMessage(conversationId) {
+        await sleep(FINAL_MESSAGE_HANDOFF_MS);
+        clearStreaming(conversationId);
+        typingSignals.clear(conversationId).catch(() => { });
+    }
+    function refreshVisibleWorkSignal(session) {
+        if (!session.running || session.closed)
+            return;
+        if (session.turnState !== 'thinking' && session.turnState !== 'tool')
+            return;
+        typingSignals.start(session.conversationId, 'thinking').catch(() => { });
+    }
+    function startVisibleWorkSignal(session) {
+        refreshVisibleWorkSignal(session);
+    }
+    function stopVisibleWorkSignal(session) {
+        if (session.typingKeepaliveTimer) {
+            clearInterval(session.typingKeepaliveTimer);
+            session.typingKeepaliveTimer = null;
+        }
+        typingSignals.clear(session.conversationId).catch(() => { });
+    }
+    function closeSession(conversationId) {
+        const session = sessions.get(conversationId);
+        if (!session)
+            return;
+        session.closed = true;
+        stopVisibleWorkSignal(session);
+        if ('close' in session.adapter && typeof session.adapter.close === 'function') {
+            session.adapter.close();
+        }
+        releaseConversationEnvironment(session.environment);
+        clearStreaming(conversationId);
+        runtimeState.clearSessionState(conversationId).catch(() => { });
+        runtimeState.clearTurnState(conversationId).catch(() => { });
+        typingSignals.clear(conversationId).catch(() => { });
+        typingSignals.dispose(conversationId);
+        sessions.delete(conversationId);
+    }
     async function resetRuntimeSession(session) {
         const conversationId = session.conversationId;
         session.resetRequested = true;
-        const droppedInputs = session.pendingInputs.splice(0);
-        await markSessionPendingInputsRejected(conversationId, droppedInputs);
+        const droppedPrompts = session.queue.splice(0);
+        await markQueuedPromptsRejected(conversationId, droppedPrompts);
         clearStoredThreadId(runtimeId, agentId, conversationId, session.environment.baseCwd, session.environment.mode);
         session.adapter.clearThreadId();
         session.activeSelfContextId = null;
@@ -693,16 +905,40 @@ export async function main() {
             session.lastAcceptedIntent = null;
             session.resetRequested = false;
         }
-        session.stopVisibleWork();
-        session.clearStreaming().catch(() => { });
+        stopVisibleWorkSignal(session);
+        clearStreaming(conversationId);
         typingSignals.clear(conversationId).catch(() => { });
-        session.writeState();
-        session.writeTurn();
+        writeState(session);
+        writeTurn(session);
+    }
+    function evictOldestIdle() {
+        let oldest = null;
+        for (const session of sessions.values()) {
+            if (session.running)
+                continue;
+            if (!oldest || session.lastActivity < oldest.lastActivity)
+                oldest = session;
+        }
+        if (oldest) {
+            console.error(`[canon-codex] [${oldest.conversationId.slice(0, 8)}] Evicting idle session`);
+            closeSession(oldest.conversationId);
+        }
     }
-    /** Runtime-specific session construction, invoked via the lifecycle's getOrCreateSession. */
-    function createSessionForConversation(conversationId) {
-        return (async () => {
-            const config = await loadSessionConfig(port, conversationId);
+    async function getOrCreateSession(conversationId) {
+        knownConversationIds.add(conversationId);
+        const existing = sessions.get(conversationId);
+        if (existing && !existing.closed) {
+            existing.lastActivity = Date.now();
+            return existing;
+        }
+        const pending = pendingSessionCreations.get(conversationId);
+        if (pending)
+            return pending;
+        if (sessions.size >= MAX_SESSIONS) {
+            evictOldestIdle();
+        }
+        const creation = (async () => {
+            const config = await loadSessionConfig(conversationId, agentId);
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -727,123 +963,41 @@ export async function main() {
                 const initialEffort = config?.effort && CODEX_EFFORT_VALUES.has(config.effort)
                     ? config.effort
                     : null;
-                const adapter = 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: CODEX_APP_DYNAMIC_TOOLS,
-                });
-                // eslint-disable-next-line prefer-const -- session must be declared before the module closures but assigned after them
-                let session;
-                // ── Per-session RTDB writers (generic skeleton from @canonmsg/agent-host) ──
-                // Snapshot streaming behind claude's 250ms min-interval write gate —
-                // deliberate behavior parity (bridge plan Phase 2): rapid runtime
-                // events coalesce into one trailing RTDB write; terminal states
-                // (waiting_input, clear) still bypass the gate.
-                const writers = createRuntimeWriters({
-                    conversationId,
-                    agentId,
-                    capabilities: CODEX_RUNTIME_CAPABILITIES,
-                    fallbackTurnId: `codex-${conversationId}`,
-                    streamingMode: 'snapshot',
-                    streamingThrottleMs: STREAMING_THROTTLE_MS,
-                    requestedControls: {},
-                }, {
-                    session: () => session,
-                    port,
-                    buildSessionStateExtras: (writerSession) => ({
-                        ...(writerSession.state.lastError !== undefined
-                            ? { lastError: writerSession.state.lastError }
-                            : {}),
-                        cwd: writerSession.cwd,
-                        executionMode: writerSession.environment.mode,
-                        ...(writerSession.environment.branch ? { executionBranch: writerSession.environment.branch } : {}),
-                        ...(writerSession.environment.worktreePath ? { worktreePath: writerSession.environment.worktreePath } : {}),
-                        ...(resolveExecutionFallbackReason(writerSession.environment)
-                            ? { executionFallbackReason: resolveExecutionFallbackReason(writerSession.environment) ?? undefined }
-                            : {}),
-                        clientType: 'codex',
-                    }),
-                    formatControlError: (error) => error instanceof Error && error.message.trim()
-                        ? error.message.trim()
-                        : 'Codex did not apply that control.',
-                });
-                // ── HITL input waiter (generic skeleton from @canonmsg/agent-host) ──
-                const hitlWaiters = createHitlWaiters({
-                    conversationId,
-                    replyTimeoutMs: 30 * 60_000,
-                }, {
-                    session: () => session,
-                    port,
-                });
-                // ── Canon turn queue (generic skeleton from @canonmsg/agent-host) ──
-                const turnQueue = createTurnQueue({ conversationId }, {
-                    session: () => session,
-                    isSessionRunning: (queueSession) => queueSession.running,
-                    markSessionRunning: (queueSession) => { queueSession.running = true; },
-                    prepareInput: async () => { },
-                    sendInput: (input) => { void executeTurn(input); },
-                    interruptRuntime: (queueSession) => queueSession.adapter.interrupt(),
-                    port,
-                    writers: {
-                        writeTurn: () => writers.writeTurn(),
-                        stopVisibleWorkSignal: () => writers.stopVisibleWorkSignal(),
-                        clearStreaming: () => writers.clearStreaming(),
-                    },
-                });
-                // ── Final delivery (claude's bounded retry machine, adopted for codex) ──
-                const finalDelivery = createFinalDelivery({
-                    conversationId,
-                    logPrefix: '[canon-codex]',
-                    delivery: { mode: 'retry', retryMs: FINAL_DELIVERY_RETRY_MS, maxRetries: MAX_FINAL_DELIVERY_RETRIES },
-                }, {
-                    session: () => session,
-                    port,
-                    typingSignals,
-                    writers: {
-                        writeState: () => writers.writeState(),
-                        writeTurn: () => writers.writeTurn(),
-                        stopVisibleWorkSignal: () => writers.stopVisibleWorkSignal(),
-                        clearStreaming: () => writers.clearStreaming(),
-                        getFinalTurnTrail: () => writers.getFinalTurnTrail(),
-                        replaceStreamingSnapshot: (text, status) => writers.streamingOutput.replaceSnapshot(text, status),
-                    },
-                    resetCompletedTurnState: (deliverySession) => {
-                        deliverySession.running = false;
-                        deliverySession.state.state = 'idle';
-                        deliverySession.turnState = 'idle';
-                        deliverySession.currentTurnId = null;
-                        deliverySession.currentTurnOpenedAt = null;
-                        deliverySession.currentTurnUpdatedAt = null;
-                        deliverySession.currentTurnCanUseCodexAppTools = false;
-                        deliverySession.lastAcceptedIntent = null;
-                        deliverySession.resetRequested = false;
-                        deliverySession.activeInput = null;
-                        deliverySession.pendingFinalText = null;
-                        deliverySession.pendingFinalDelivery = null;
-                    },
-                    shouldDeliverFinal: (turn, deliverySession) => Boolean(turn)
-                        && !deliverySession.finalizedTurnKeys.has(turn.turnKey)
-                        && !deliverySession.interruptedTurnKeys.has(turn.turnKey),
-                    buildFinalMessageId: (turnKey) => `codex-final-${turnKey}`,
-                    drainPendingInput: () => turnQueue.drainPendingInput(),
-                    // Oversized finals chunk BRIDGE-side (its sendMessage runs core's
-                    // retry+chunking) — the host-side chunked sender is deleted.
-                });
-                session = {
+                const adapter = useAppServer
+                    ? new CodexAppServerAdapter({
+                        cwd: sessionCwd,
+                        threadId: storedThreadId,
+                        codexBin,
+                        model: policy.model ?? null,
+                        reasoningEffort: initialEffort,
+                        sandbox: policy.sandbox,
+                        approvalPolicy: policy.approvalPolicy,
+                        addDirs: args['add-dir'] ?? [],
+                        configOverrides: args.config ?? [],
+                        fullAuto: policy.fullAuto,
+                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                        dynamicTools: CODEX_APP_DYNAMIC_TOOLS,
+                    })
+                    : new CodexConversationAdapter({
+                        cwd: sessionCwd,
+                        threadId: storedThreadId,
+                        codexBin,
+                        model: policy.model ?? null,
+                        reasoningEffort: initialEffort,
+                        sandbox: policy.sandbox,
+                        approvalPolicy: policy.approvalPolicy,
+                        codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
+                        addDirs: args['add-dir'] ?? [],
+                        configOverrides: args.config ?? [],
+                        fullAuto: policy.fullAuto,
+                        bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
+                    });
+                const session = {
                     conversationId,
                     cwd: sessionCwd,
                     environment,
                     adapter,
-                    pendingInputs: [],
-                    activeInput: null,
+                    queue: [],
                     running: false,
                     state: buildCodexInitialSessionState({
                         model: policy.model,
@@ -858,377 +1012,19 @@ export async function main() {
                     currentTurnCanUseCodexAppTools: false,
                     activeSelfContextId: null,
                     lastAcceptedIntent: null,
-                    interruptedTurnKeys: new Set(),
-                    finalizedTurnKeys: new Set(),
-                    pendingFinalText: null,
-                    pendingFinalDelivery: null,
                     resetRequested: false,
                     lastActivity: Date.now(),
                     typingKeepaliveTimer: null,
-                    idleResetTimer: null,
-                    finalDeliveryTimer: null,
                     closed: false,
-                    streamingText: '',
-                    availableModels: [],
-                    runtimeControlErrors: {},
-                    pendingReply: null,
+                    turnLiveText: '',
+                    turnBlocks: [],
                     turnCommandBlocks: createCommandBlockTracker(),
-                    writeState: () => writers.writeState(),
-                    writeTurn: () => writers.writeTurn(),
-                    clearStreaming: () => writers.clearStreaming(),
-                    startVisibleWork: () => writers.startVisibleWorkSignal(),
-                    stopVisibleWork: () => writers.stopVisibleWorkSignal(),
-                    stageTurnBlock: (block) => { writers.streamingOutput.stageBlock(block); },
-                    setStreamingStatus: (status) => { writers.streamingOutput.setStatus(status).catch(() => { }); },
-                    waitForRuntimeInputResponse: (input) => hitlWaiters.waitForRuntimeInputResponse(input),
-                    enqueueInbound: (input) => turnQueue.enqueueCanonInput(input),
                 };
-                const handoffFinal = () => handoffFinalMessage({
-                    conversationId,
-                    clearStreaming: () => writers.clearStreaming(),
-                    typingSignals,
-                });
-                /** Drive the Codex runtime for one queued Canon turn (the adapter's input transport). */
-                async function executeTurn(turn) {
-                    if (session.closed)
-                        return;
-                    if (session.activeInput) {
-                        // Reentrancy guard: a concurrent start raced the in-flight turn —
-                        // requeue at the front; the post-turn drain picks it up.
-                        session.pendingInputs.unshift(turn);
-                        return;
-                    }
-                    // A turn starting during the final-handoff window owns the session
-                    // again — cancel the pending reset and drop any stale streamed state
-                    // from the previous turn (claude's 'running' transition parity).
-                    finalDelivery.clearIdleResetTimer();
-                    session.pendingFinalText = null;
-                    if (writers.streamingOutput.getBlocks().length > 0 || writers.streamingOutput.getText()) {
-                        writers.clearStreaming().catch(() => { });
-                    }
-                    session.activeInput = turn;
-                    session.running = true;
-                    session.state.lastError = undefined;
-                    session.state.state = 'running';
-                    session.currentTurnId = turn.turnKey;
-                    session.turnCommandBlocks = createCommandBlockTracker();
-                    session.currentTurnOpenedAt = Date.now();
-                    session.currentTurnUpdatedAt = session.currentTurnOpenedAt;
-                    session.currentTurnCanUseCodexAppTools = turn.canUseCodexAppTools;
-                    session.lastAcceptedIntent = turn.intent;
-                    session.turnState = 'thinking';
-                    session.lastActivity = Date.now();
-                    writers.writeState();
-                    writers.writeTurn();
-                    writers.startVisibleWorkSignal();
-                    // Status-only seed: 'thinking' renders as a working filament row on the
-                    // clients; text here would be bubbled as speech (v4 register rule).
-                    writers.streamingOutput.startThinking('').catch(() => { });
-                    let artifactBaseline = null;
-                    let artifactsRouted = false;
-                    const routeArtifactsOnce = async () => {
-                        if (artifactsRouted)
-                            return;
-                        artifactsRouted = true;
-                        if (turn.artifactRoutingMode === 'workspace-generated') {
-                            await routeWorkspaceGeneratedArtifacts(session, artifactBaseline);
-                        }
-                    };
-                    // True once the final-delivery machine owns the turn reset (handoff
-                    // timer or bounded retry) — the finally block must not clobber it.
-                    let turnSettledByFinalDelivery = false;
-                    try {
-                        const turnPrompt = turn.prompt;
-                        if (turn.artifactRoutingMode === 'workspace-generated') {
-                            artifactBaseline = await captureTurnArtifactSnapshot({ cwd: session.cwd }).catch((error) => {
-                                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Artifact snapshot failed:`, error instanceof Error ? error.message : error);
-                                return null;
-                            });
-                        }
-                        const modelGuardForTurn = buildCodexModelGuardMessage(session.state.model, codexCliStatus);
-                        if (modelGuardForTurn) {
-                            throw new ExecutionEnvironmentError(modelGuardForTurn, modelGuardForTurn);
-                        }
-                        const turnImagePaths = turn.imagePaths;
-                        const turnMediaAddDirs = turn.mediaAddDirs;
-                        const handleCodexEvent = (event) => {
-                            session.lastActivity = Date.now();
-                            if (event.type === 'thread.started') {
-                                if (session.resetRequested) {
-                                    return;
-                                }
-                                saveStoredThreadId(runtimeId, agentId, conversationId, session.environment.baseCwd, event.threadId, session.environment.mode, session.policyFingerprint);
-                                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Thread ${event.threadId}`);
-                                return;
-                            }
-                            if (event.type === 'skills.changed') {
-                                void refreshCodexSkillInventory(true).then(() => publishRuntimeHeartbeat());
-                                return;
-                            }
-                            if (event.type === 'message') {
-                                session.turnState = 'streaming';
-                                writers.writeTurn();
-                                writers.stopVisibleWorkSignal();
-                                applyCodexMessageToStreamingOutput(writers.streamingOutput, {
-                                    turnId: session.currentTurnId,
-                                    itemId: event.itemId,
-                                    text: event.text,
-                                    delta: event.delta,
-                                });
-                                return;
-                            }
-                            if (event.type === 'plan.updated') {
-                                session.turnState = 'streaming';
-                                writers.writeTurn();
-                                writers.stopVisibleWorkSignal();
-                                writers.streamingOutput.stageBlock({
-                                    id: `plan:${session.currentTurnId}`,
-                                    kind: 'plan',
-                                    status: 'running',
-                                    title: 'Plan',
-                                    text: event.text,
-                                });
-                                if (hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
-                                    // Speech is already flowing: publish the staged plan block
-                                    // only. Replacing the whole snapshot with plan text would be
-                                    // undone by the next agentMessage snapshot and make the
-                                    // smoothed bubble snap back and forth.
-                                    writers.streamingOutput.flush().catch(() => { });
-                                }
-                                else {
-                                    writers.streamingOutput.replaceSnapshot(event.text, 'streaming').catch(() => { });
-                                }
-                                return;
-                            }
-                            if (event.type === 'waiting') {
-                                session.turnState = 'waiting_input';
-                                writers.writeTurn();
-                                writers.stopVisibleWorkSignal();
-                                writers.streamingOutput.waitingInput().catch(() => { });
-                                return;
-                            }
-                            if (event.type === 'command.started') {
-                                const blockId = beginCommandBlock(session.turnCommandBlocks, {
-                                    turnId: session.currentTurnId,
-                                    command: event.command,
-                                    itemId: event.itemId,
-                                });
-                                writers.streamingOutput.stageBlock({
-                                    id: blockId,
-                                    kind: 'tool',
-                                    status: 'running',
-                                    title: summarizeCommand(event.command),
-                                    summary: 'Command running',
-                                });
-                                if (hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
-                                    // Speech is already flowing: the staged tool block narrates
-                                    // the command in the margin. Publish it without flapping the
-                                    // bubble status away from 'streaming'.
-                                    writers.streamingOutput.flush().catch(() => { });
-                                    return;
-                                }
-                                session.turnState = 'tool';
-                                writers.writeTurn();
-                                writers.startVisibleWorkSignal();
-                                writers.streamingOutput.setStatus('tool').catch(() => { });
-                                return;
-                            }
-                            if (event.type === 'command.completed') {
-                                const blockId = claimCommandBlock(session.turnCommandBlocks, {
-                                    turnId: session.currentTurnId,
-                                    command: event.command,
-                                    itemId: event.itemId,
-                                });
-                                const existing = writers.streamingOutput.getBlocks().find((block) => block.id === blockId);
-                                if (existing) {
-                                    writers.streamingOutput.stageBlock({
-                                        id: blockId,
-                                        kind: existing.kind,
-                                        status: 'completed',
-                                        summary: 'Command completed',
-                                    });
-                                }
-                                if (session.turnState === 'tool'
-                                    && !hasSpeechSegmentText(writers.streamingOutput.getBlocks())) {
-                                    session.turnState = 'thinking';
-                                    writers.writeTurn();
-                                    writers.startVisibleWorkSignal();
-                                    writers.streamingOutput.setStatus('thinking').catch(() => { });
-                                }
-                                else {
-                                    // Speech is flowing (or the turn never left streaming):
-                                    // publish the staged completion without a status flap.
-                                    writers.streamingOutput.flush().catch(() => { });
-                                }
-                                return;
-                            }
-                            if (event.type === 'turn.completed') {
-                                // Codex reports per-turn token usage but no context window, so the
-                                // meter publishes tokens only (input + cached covers the full
-                                // prompt context of the completed turn).
-                                const totalTokens = (event.usage?.input_tokens ?? 0)
-                                    + (event.usage?.cached_input_tokens ?? 0)
-                                    + (event.usage?.output_tokens ?? 0);
-                                if (totalTokens > 0) {
-                                    session.state.contextUsage = { totalTokens };
-                                }
-                                writers.writeState();
-                            }
-                        };
-                        const logCodexLine = (line) => {
-                            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${line}`);
-                        };
-                        const clearStoredThread = () => {
-                            clearStoredThreadId(runtimeId, agentId, conversationId, session.environment.baseCwd, session.environment.mode);
-                            session.adapter.clearThreadId();
-                        };
-                        const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
-                            planMode: turn.planMode,
-                            onServerRequest: (request) => handleCodexServerRequest(session, request),
-                        });
-                        let result = await runTurnOnce();
-                        if (!result.interrupted
-                            && !result.finalMessage
-                            && result.exitCode
-                            && result.exitCode !== 0
-                            && isRecoverableCodexThreadError(result.errorText)) {
-                            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Stored thread was not found; clearing and retrying once`);
-                            clearStoredThread();
-                            result = await runTurnOnce();
-                        }
-                        if (result.threadId && !session.resetRequested) {
-                            saveStoredThreadId(runtimeId, agentId, conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
-                        }
-                        if (!result.interrupted && result.finalMessage && turn.planMode) {
-                            await routeArtifactsOnce();
-                            const planApproval = buildPlanApprovalRequest(session.currentTurnId ?? randomUUID(), 'Plan ready for review.', {
-                                responseUserId: ownerId ?? undefined,
-                                title: 'Codex Plan',
-                                body: result.finalMessage,
-                            });
-                            await port.sendMessage({
-                                conversationId,
-                                text: planApproval.text,
-                                messageId: buildCodexMessageId(session, 'plan'),
-                                metadata: {
-                                    ...planApproval.metadata,
-                                    turnId: session.currentTurnId,
-                                    turnSemantics: 'control',
-                                    replyBehavior: 'suppress_auto_reply',
-                                },
-                            });
-                            await handoffFinal();
-                            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Sent plan approval card`);
-                        }
-                        else if (!result.interrupted && result.finalMessage) {
-                            if (isRecoverableCodexThreadError(result.errorText)) {
-                                clearStoredThread();
-                            }
-                            await routeArtifactsOnce();
-                            // Claude's final-delivery machine (deliberate behavior parity):
-                            // failed sends are re-marked pending and retried on a bounded
-                            // timer instead of throwing into the generic failure path.
-                            const delivered = await finalDelivery.deliverFinalReply(result.finalMessage, turn);
-                            if (delivered) {
-                                session.activeInput = null;
-                                session.running = false;
-                                finalDelivery.scheduleFinalHandoffReset();
-                            }
-                            else {
-                                finalDelivery.scheduleFinalDeliveryRetry();
-                            }
-                            turnSettledByFinalDelivery = true;
-                        }
-                        else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
-                            await routeArtifactsOnce();
-                            const userVisibleError = formatCodexTurnFailure(result.errorText);
-                            session.state.lastError = userVisibleError;
-                            writers.writeState();
-                            if (result.errorText) {
-                                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
-                            }
-                            const turnTrail = writers.getFinalTurnTrail();
-                            await port.sendMessage({
-                                conversationId,
-                                text: userVisibleError,
-                                messageId: buildCodexMessageId(session, 'error'),
-                                ...(session.activeSelfContextId
-                                    ? { selfContextId: session.activeSelfContextId }
-                                    : {}),
-                                metadata: {
-                                    turnId: session.currentTurnId,
-                                    turnSemantics: 'turn_complete',
-                                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                                    ...(turnTrail.length > 0 ? { turnTrail } : {}),
-                                },
-                            });
-                            await handoffFinal();
-                        }
-                        else if (!result.interrupted) {
-                            await routeArtifactsOnce();
-                            await handoffFinal();
-                        }
-                        else if (result.interrupted) {
-                            session.turnState = 'interrupted';
-                            writers.writeTurn();
-                            writers.stopVisibleWorkSignal();
-                            writers.clearStreaming().catch(() => { });
-                            typingSignals.clear(conversationId).catch(() => { });
-                            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Turn interrupted`);
-                        }
-                    }
-                    catch (error) {
-                        const message = error instanceof ExecutionEnvironmentError
-                            ? error.userMessage
-                            : isBridgeDeliveryError(error)
-                                ? `The Codex host completed the turn, but Canon could not deliver the reply: ${error.message}`
-                                : `The Codex host failed during the turn: ${error instanceof Error ? error.message : String(error)}`;
-                        session.state.lastError = message;
-                        writers.writeState();
-                        await routeArtifactsOnce();
-                        await port.sendMessage({
-                            conversationId,
-                            text: message,
-                            messageId: buildCodexMessageId(session, 'failure'),
-                            ...(session.activeSelfContextId
-                                ? { selfContextId: session.activeSelfContextId }
-                                : {}),
-                            metadata: {
-                                turnId: session.currentTurnId,
-                                turnSemantics: 'turn_complete',
-                                deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                            },
-                        }).catch(() => { });
-                        await handoffFinal();
-                        if (error instanceof Error && isRecoverableCodexThreadError(error.message)) {
-                            clearStoredThreadId(runtimeId, agentId, conversationId, session.environment.baseCwd, session.environment.mode);
-                        }
-                        console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Turn failed:`, error);
-                    }
-                    finally {
-                        session.lastActivity = Date.now();
-                        if (!turnSettledByFinalDelivery) {
-                            writers.stopVisibleWorkSignal();
-                            session.running = false;
-                            session.state.state = 'idle';
-                            session.turnState = 'idle';
-                            session.currentTurnId = null;
-                            session.currentTurnOpenedAt = null;
-                            session.currentTurnUpdatedAt = null;
-                            session.currentTurnCanUseCodexAppTools = false;
-                            session.lastAcceptedIntent = null;
-                            session.resetRequested = false;
-                            session.activeInput = null;
-                            writers.writeState();
-                            writers.writeTurn();
-                            turnQueue.drainPendingInput();
-                        }
-                    }
-                }
                 sessions.set(conversationId, session);
+                await controlPoller.baseline([conversationId]);
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
-                session.writeState();
-                session.writeTurn();
+                writeState(session);
+                writeTurn(session);
                 return session;
             }
             catch (error) {
@@ -1236,58 +1032,41 @@ export async function main() {
                 throw error;
             }
         })();
+        pendingSessionCreations.set(conversationId, creation);
+        try {
+            return await creation;
+        }
+        finally {
+            pendingSessionCreations.delete(conversationId);
+        }
+    }
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false, imagePaths = [], mediaAddDirs = [], planMode = false, artifactRoutingMode = 'disabled', canUseCodexAppTools = false) {
+        const nextPrompt = {
+            prompt,
+            intent,
+            sourceMessageId,
+            markAccepted,
+            imagePaths,
+            mediaAddDirs,
+            planMode,
+            artifactRoutingMode,
+            canUseCodexAppTools,
+        };
+        if (toFront) {
+            session.queue.unshift(nextPrompt);
+        }
+        else {
+            session.queue.push(nextPrompt);
+        }
+        session.lastActivity = Date.now();
+        writeTurn(session);
+        void runNextTurn(session);
     }
     function resolveArtifactRoutingMode(participantContext) {
         return participantContext.conversationType === 'direct' && participantContext.isOwner
             ? 'workspace-generated'
             : 'disabled';
     }
-    /**
-     * Approval answers read the bridge's DURABLE record (the bridge owns the
-     * single destructive consume loop + the approval_reply fast path); same 1s
-     * cadence as the legacy consume poll.
-     */
-    async function waitForRuntimeApprovalResponse(input) {
-        const read = async () => port.getHitlState({ requestId: input.approvalId }).catch(() => null);
-        while (Date.now() < input.expiresAt) {
-            const state = await read();
-            if (state?.status === 'submitted') {
-                const answer = (state.answer ?? {});
-                return answer.decision === 'deny'
-                    ? { decision: 'deny' }
-                    : { decision: 'allow', sessionRule: answer.sessionRule };
-            }
-            if (state?.status === 'cancelled' || state?.status === 'timeout') {
-                return { decision: 'deny' };
-            }
-            await sleep(1_000);
-        }
-        return { decision: 'deny' };
-    }
-    async function waitForRuntimeCardResponse(input) {
-        const read = async () => port.getHitlState({ requestId: input.cardId }).catch(() => null);
-        const map = (state) => {
-            if (state?.status === 'submitted') {
-                const answer = (state.answer ?? {});
-                return {
-                    status: 'submitted',
-                    ...(answer.actionId ? { actionId: answer.actionId } : {}),
-                    ...(answer.values ? { values: answer.values } : {}),
-                };
-            }
-            if (state?.status === 'cancelled' || state?.status === 'timeout') {
-                return { status: state.status };
-            }
-            return null;
-        };
-        while (Date.now() < input.expiresAt) {
-            const mapped = map(await read());
-            if (mapped)
-                return mapped;
-            await sleep(1_000);
-        }
-        return map(await read()) ?? { status: 'timeout' };
-    }
     function runtimeCardRequestPayload(method, params) {
         if (method !== 'item/runtimeCard/request'
             && method !== 'runtimeCard/request') {
@@ -1302,6 +1081,9 @@ export async function main() {
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
         if (request.method === 'item/tool/call' && isCodexAppToolCall(params)) {
+            if (!(session.adapter instanceof CodexAppServerAdapter)) {
+                return deniedCodexAppToolResult('codex_app tools require the Codex app-server transport.');
+            }
             if (!session.currentTurnCanUseCodexAppTools) {
                 return deniedCodexAppToolResult('Only the Canon owner can use codex_app tools.');
             }
@@ -1327,15 +1109,12 @@ export async function main() {
             let requestCreated = false;
             let requestResolved = false;
             try {
-                await port.requestCard({
-                    conversationId: session.conversationId,
-                    cardId,
-                    card: { ...card, cardId },
-                    expiresAt: new Date(expiresAt).toISOString(),
-                    // responseUserId: null → the backend targets a reachable member
-                    // (the owner if present, else the sole other member) — the owner is
-                    // often not a member of agent-to-user DMs.
-                    responseUserId: null,
+                // Built-in card descriptor owns create+poll; codex passes native/turnId
+                // via payload, post-create turn side effects via onCreated. responseUserId
+                // is omitted (default `infer` policy) so the backend targets a reachable
+                // member (owner is often not a member of agent-to-user DMs).
+                const cardResult = await runtimeRequests.request('card', session.conversationId, {
+                    card,
                     native: {
                         runtime: 'codex',
                         method: request.method,
@@ -1346,30 +1125,36 @@ export async function main() {
                             threadId: readString(params, 'threadId') ?? '',
                         },
                     },
-                    ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
-                });
-                requestCreated = true;
-                session.turnState = 'waiting_input';
-                session.stageTurnBlock({
-                    id: `card:${cardId}`,
-                    kind: 'input',
-                    status: 'pending',
-                    title: card.title,
-                    summary: card.template ?? 'runtime card',
-                });
-                session.writeTurn();
-                session.stopVisibleWork();
-                session.setStreamingStatus('waiting_input');
-                const response = await waitForRuntimeCardResponse({
-                    conversationId: session.conversationId,
-                    cardId,
+                    turnId: session.currentTurnId ?? undefined,
+                }, {
+                    requestId: cardId,
                     expiresAt,
+                    onCreated: () => {
+                        requestCreated = true;
+                        session.turnState = 'waiting_input';
+                        markTurnProgress(session);
+                        upsertTurnBlock(session, {
+                            id: `card:${cardId}`,
+                            kind: 'input',
+                            status: 'pending',
+                            title: card.title,
+                            summary: card.template ?? 'runtime card',
+                        });
+                        writeTurn(session);
+                        stopVisibleWorkSignal(session);
+                        writeCodexStreaming(session, null, 'waiting_input');
+                    },
                 });
+                const response = cardResult.status === 'submitted'
+                    ? {
+                        status: 'submitted',
+                        ...(cardResult.actionId ? { actionId: cardResult.actionId } : {}),
+                        ...(cardResult.values ? { values: cardResult.values } : {}),
+                    }
+                    : { status: cardResult.status };
                 requestResolved = true;
                 const outcome = buildRuntimeCardOutcome(cardId, response.status, { reason: response.status });
-                await port.sendMessage({
-                    conversationId: session.conversationId,
-                    text: outcome.text,
+                await sendMessageWithRetry(client, session.conversationId, outcome.text, {
                     messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, response.status),
                     metadata: {
                         ...outcome.metadata,
@@ -1378,27 +1163,25 @@ export async function main() {
                         replyBehavior: 'suppress_auto_reply',
                     },
                 });
-                session.stageTurnBlock({
-                    id: `card:${cardId}`,
-                    kind: 'input',
-                    status: 'completed',
-                    summary: `Card ${response.status}`,
-                });
+                completeTurnBlock(session, `card:${cardId}`, `Card ${response.status}`);
                 if (session.turnState === 'waiting_input') {
                     session.turnState = 'thinking';
-                    session.writeTurn();
-                    session.startVisibleWork();
-                    session.setStreamingStatus('thinking');
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    startVisibleWorkSignal(session);
+                    writeCodexStreaming(session, null, 'thinking');
                 }
                 return response;
             }
             catch (error) {
                 if (requestCreated && !requestResolved) {
-                    await port.cancelHitl({ requestId: cardId }).catch(() => null);
-                    const outcome = buildRuntimeCardOutcome(cardId, 'cancelled', { reason: 'interrupted' });
-                    await port.sendMessage({
+                    await client.consumeRuntimeCardResponse({
                         conversationId: session.conversationId,
-                        text: outcome.text,
+                        cardId,
+                        cancel: true,
+                    }).catch(() => null);
+                    const outcome = buildRuntimeCardOutcome(cardId, 'cancelled', { reason: 'interrupted' });
+                    await sendMessageWithRetry(client, session.conversationId, outcome.text, {
                         messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, 'cancelled'),
                         metadata: {
                             ...outcome.metadata,
@@ -1416,19 +1199,15 @@ export async function main() {
             const paramsArguments = isRecord(params.arguments) ? params.arguments : null;
             const questions = mapCodexQuestions(params.questions ?? paramsInput?.questions ?? paramsArguments?.questions);
             const inputId = readString(params, 'itemId') ?? requestId;
-            await port.requestInput({
-                conversationId: session.conversationId,
-                inputId,
+            // Built-in input descriptor owns create+poll; default `owner` responder
+            // policy resolves to ctx.ownerId (matching the former responseUserId).
+            const response = await runtimeRequests.request('input', session.conversationId, {
                 kind: 'clarify',
-                expiresAt: new Date(expiresAt).toISOString(),
-                ...(ownerId ? { responseUserId: ownerId } : {}),
                 title: 'Codex needs input',
                 prompt: questions?.length
                     ? 'Codex needs your input to continue.'
                     : 'Codex needs input.',
-                ...(questions
-                    ? { questions: questions }
-                    : { questions: [] }),
+                ...(questions ? { questions } : {}),
                 sensitive: Boolean(questions?.some((question) => question.isSecret)),
                 native: {
                     runtime: 'codex',
@@ -1440,9 +1219,8 @@ export async function main() {
                         threadId: readString(params, 'threadId') ?? '',
                     },
                 },
-                ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
-            });
-            const response = await session.waitForRuntimeInputResponse({ inputId, expiresAt });
+                turnId: session.currentTurnId ?? undefined,
+            }, { requestId: inputId, expiresAt });
             return { answers: response.status === 'submitted' ? response.answers ?? {} : {} };
         }
         const mappedApproval = mapCodexAppServerApprovalRequest({
@@ -1451,35 +1229,12 @@ export async function main() {
         });
         if (mappedApproval) {
             const approvalId = readString(params, 'approvalId') ?? readString(params, 'itemId') ?? requestId;
-            await port.requestApproval({
-                conversationId: session.conversationId,
-                approvalId,
-                toolName: mappedApproval.toolName,
-                detail: mappedApproval.toolSummary,
-                category: mappedApproval.category,
-                risk: mappedApproval.risk ?? 'normal',
-                ...(mappedApproval.riskLevel ? { riskLevel: mappedApproval.riskLevel } : {}),
-                native: {
-                    ...mappedApproval.native,
-                    requestId,
-                    method: request.method,
-                },
-                ...(mappedApproval.details
-                    ? { details: mappedApproval.details }
-                    : {}),
-                ...(mappedApproval.diff
-                    ? { diff: mappedApproval.diff }
-                    : {}),
-                ...(ownerId ? { responseUserId: ownerId } : {}),
-                allowSessionRule: true,
-                expiresAt: new Date(expiresAt).toISOString(),
-                ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
-            });
-            const response = await waitForRuntimeApprovalResponse({
-                conversationId: session.conversationId,
-                approvalId,
-                expiresAt,
-            });
+            // Approval descriptor's create authors the server request (responder = ctx.ownerId).
+            const response = await runtimeRequests.request('approval', session.conversationId, {
+                ...mappedApproval,
+                native: { ...mappedApproval.native, requestId, method: request.method },
+                turnId: session.currentTurnId ?? undefined,
+            }, { requestId: approvalId, expiresAt });
             if (request.method === 'item/permissions/requestApproval') {
                 return response.decision === 'allow'
                     ? { permissions: isRecord(params.permissions) ? params.permissions : {}, scope: response.sessionRule ? 'session' : 'turn' }
@@ -1509,12 +1264,7 @@ export async function main() {
                 : decision === 'reject'
                     ? `The plan was declined — keep planning and wait for guidance before implementing.${feedback ? `\n\nNotes:\n${feedback}` : ''}`
                     : `Please revise the plan.${feedback ? `\n\nRevision feedback:\n${feedback}` : ''}`;
-            session.enqueueInbound(buildCodexQueuedInput({
-                prompt,
-                sourceMessageId: input.message.id,
-                planMode: decision !== 'approve',
-                canUseCodexAppTools: input.isOwner,
-            }));
+            enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve', 'disabled', input.isOwner);
             return;
         }
         let materialized = [];
@@ -1532,9 +1282,11 @@ export async function main() {
         const renderedContent = renderInboundContent(input.message, materialized);
         const turnMetadata = normalizeTurnMetadata(input.message.metadata);
         const requestedPlanMode = turnMetadata?.requestedTurnMode === 'plan';
-        const planCommand = requestedPlanMode
-            ? { planMode: true, content: renderedContent }
-            : parsePlanCommand(renderedContent);
+        const planCommand = useAppServer
+            ? requestedPlanMode
+                ? { planMode: true, content: renderedContent }
+                : parsePlanCommand(renderedContent)
+            : { planMode: false, content: renderedContent };
         const content = planCommand.content;
         const hydrated = await loadHydratedInboundContext({
             conversationId: input.conversationId,
@@ -1585,9 +1337,7 @@ export async function main() {
             const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
             await markQueuedMessageAccepted(input.conversationId, input.message.id, shouldMarkAccepted);
-            await port.sendMessage({
-                conversationId: input.conversationId,
-                text: `I couldn't start a coding session for this workspace: ${userMessage}`,
+            await sendMessageWithRetryChunked(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
                 messageId: `codex-start-failed-${input.message.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
@@ -1610,36 +1360,19 @@ export async function main() {
             message: input.message,
         });
         if (session.running && deliveryIntent === 'interrupt') {
+            const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode, participantContext.isOwner);
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
+            await session.adapter.interrupt().catch(() => { });
+            clearStreaming(input.conversationId);
+            typingSignals.clear(input.conversationId).catch(() => { });
+            return;
         }
         const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
-        // The shared turn queue handles queue/interrupt/start semantics.
-        session.enqueueInbound(buildCodexQueuedInput({
-            prompt,
-            intent: deliveryIntent,
-            sourceMessageId: input.message.id,
-            markAccepted: shouldMarkAccepted,
-            imagePaths,
-            mediaAddDirs,
-            planMode: planCommand.planMode,
-            artifactRoutingMode,
-            canUseCodexAppTools: participantContext.isOwner,
-        }));
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, artifactRoutingMode, participantContext.isOwner);
     }
-    async function sendTurnArtifactFile(session, file) {
-        // Byte transfer is bridge-owned (§B8): hand the bridge a path, it streams
-        // the upload; then send the permanent message with the attachment ref.
-        const uploaded = await port.uploadMedia({
-            path: file.path,
-            mime: inferUploadMimeType(file.path),
-            fileName: file.fileName,
-            conversationId: session.conversationId,
-        });
-        return port.sendMessage({
-            conversationId: session.conversationId,
-            text: '',
-            contentType: uploaded.attachment.kind,
-            attachments: [uploaded.attachment],
+    function sendTurnArtifactFile(session, file) {
+        return sendMediaFileMessage(client, session.conversationId, file.path, '', {
             ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
             metadata: {
                 ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
@@ -1679,6 +1412,296 @@ export async function main() {
             console.error(`${logPrefix} Artifact routing failed:`, error instanceof Error ? error.message : error);
         }
     }
+    async function runNextTurn(session) {
+        if (session.running || session.closed)
+            return;
+        const nextTurn = session.queue.shift();
+        if (!nextTurn)
+            return;
+        session.running = true;
+        session.state.lastError = undefined;
+        session.state.state = 'running';
+        session.currentTurnId = randomUUID();
+        session.turnLiveText = '';
+        session.turnBlocks = [];
+        session.turnCommandBlocks = createCommandBlockTracker();
+        session.currentTurnOpenedAt = Date.now();
+        session.currentTurnUpdatedAt = session.currentTurnOpenedAt;
+        session.currentTurnCanUseCodexAppTools = nextTurn.canUseCodexAppTools === true;
+        session.lastAcceptedIntent = nextTurn.intent;
+        session.turnState = 'thinking';
+        session.lastActivity = Date.now();
+        await markQueuedMessageAccepted(session.conversationId, nextTurn.sourceMessageId, nextTurn.markAccepted);
+        writeState(session);
+        writeTurn(session);
+        startVisibleWorkSignal(session);
+        // Status-only seed: 'thinking' renders as a working filament row on the
+        // clients; text here would be bubbled as speech (v4 register rule).
+        writeCodexStreaming(session, '', 'thinking');
+        let artifactBaseline = null;
+        let artifactsRouted = false;
+        const routeArtifactsOnce = async () => {
+            if (artifactsRouted)
+                return;
+            artifactsRouted = true;
+            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
+                await routeWorkspaceGeneratedArtifacts(session, artifactBaseline);
+            }
+        };
+        try {
+            const turnId = session.currentTurnId ?? randomUUID();
+            session.currentTurnId = turnId;
+            let turnPrompt = nextTurn.prompt;
+            if (nextTurn.artifactRoutingMode === 'workspace-generated') {
+                artifactBaseline = await captureTurnArtifactSnapshot({ cwd: session.cwd }).catch((error) => {
+                    console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Artifact snapshot failed:`, error instanceof Error ? error.message : error);
+                    return null;
+                });
+            }
+            const modelGuard = buildCodexModelGuardMessage(session.state.model, codexCliStatus);
+            if (modelGuard) {
+                throw new ExecutionEnvironmentError(modelGuard, modelGuard);
+            }
+            const turnImagePaths = nextTurn.imagePaths ?? [];
+            const turnMediaAddDirs = nextTurn.mediaAddDirs ?? [];
+            const handleCodexEvent = (event) => {
+                session.lastActivity = Date.now();
+                if (event.type === 'thread.started') {
+                    if (session.resetRequested) {
+                        return;
+                    }
+                    saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, event.threadId, session.environment.mode, session.policyFingerprint);
+                    console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Thread ${event.threadId}`);
+                    return;
+                }
+                if (event.type === 'skills.changed') {
+                    void refreshCodexSkillInventory(true).then(() => publishRuntimeHeartbeat());
+                    return;
+                }
+                if (event.type === 'message') {
+                    session.turnState = 'streaming';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    upsertCodexTextSegment(session, event);
+                    writeCodexStreaming(session, null, 'streaming');
+                    return;
+                }
+                if (event.type === 'plan.updated') {
+                    session.turnState = 'streaming';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    upsertTurnBlock(session, {
+                        id: `plan:${session.currentTurnId}`,
+                        kind: 'plan',
+                        status: 'running',
+                        title: 'Plan',
+                        text: event.text,
+                    });
+                    writeCodexStreaming(session, event.text, 'streaming');
+                    return;
+                }
+                if (event.type === 'waiting') {
+                    session.turnState = 'waiting_input';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    stopVisibleWorkSignal(session);
+                    writeCodexStreaming(session, null, 'waiting_input');
+                    return;
+                }
+                if (event.type === 'command.started') {
+                    session.turnState = 'tool';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    startVisibleWorkSignal(session);
+                    const blockId = beginCommandBlock(session.turnCommandBlocks, {
+                        turnId: session.currentTurnId,
+                        command: event.command,
+                        itemId: event.itemId,
+                    });
+                    upsertTurnBlock(session, {
+                        id: blockId,
+                        kind: 'tool',
+                        status: 'running',
+                        title: summarizeCommand(event.command),
+                        summary: 'Command running',
+                    });
+                    writeCodexStreaming(session, null, 'tool');
+                    return;
+                }
+                if (event.type === 'command.completed') {
+                    const blockId = claimCommandBlock(session.turnCommandBlocks, {
+                        turnId: session.currentTurnId,
+                        command: event.command,
+                        itemId: event.itemId,
+                    });
+                    completeTurnBlock(session, blockId, 'Command completed');
+                    if (session.turnState === 'tool') {
+                        session.turnState = 'thinking';
+                        markTurnProgress(session);
+                        writeTurn(session);
+                        startVisibleWorkSignal(session);
+                        writeCodexStreaming(session, null, 'thinking');
+                    }
+                    return;
+                }
+                if (event.type === 'turn.completed') {
+                    // Codex reports per-turn token usage but no context window, so the
+                    // meter publishes tokens only (input + cached covers the full
+                    // prompt context of the completed turn).
+                    const totalTokens = (event.usage?.input_tokens ?? 0)
+                        + (event.usage?.cached_input_tokens ?? 0)
+                        + (event.usage?.output_tokens ?? 0);
+                    if (totalTokens > 0) {
+                        session.state.contextUsage = { totalTokens };
+                    }
+                    writeState(session);
+                }
+            };
+            const logCodexLine = (line) => {
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] ${line}`);
+            };
+            const clearStoredThread = () => {
+                clearStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, session.environment.mode);
+                session.adapter.clearThreadId();
+            };
+            const runTurnOnce = () => session.adapter.runTurn(turnPrompt, handleCodexEvent, logCodexLine, turnImagePaths, turnMediaAddDirs, {
+                planMode: nextTurn.planMode,
+                onServerRequest: (request) => handleCodexServerRequest(session, request),
+            });
+            let result = await runTurnOnce();
+            if (!result.interrupted
+                && !result.finalMessage
+                && result.exitCode
+                && result.exitCode !== 0
+                && isRecoverableCodexThreadError(result.errorText)) {
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Stored thread was not found; clearing and retrying once`);
+                clearStoredThread();
+                result = await runTurnOnce();
+            }
+            if (result.threadId && !session.resetRequested) {
+                saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
+            }
+            if (!result.interrupted && result.finalMessage && nextTurn.planMode) {
+                await routeArtifactsOnce();
+                // Route plan-CREATE through the unified spine (`/runtime-plan/request`):
+                // seeds the server-owned pending node/attention/state and authors the
+                // `plan_approval` card. Resolution is UNCHANGED — Codex still re-queues a
+                // fresh turn off the server-authored `plan_approval_reply`.
+                await client.createRuntimePlanRequest({
+                    conversationId: session.conversationId,
+                    planId: session.currentTurnId ?? randomUUID(),
+                    title: 'Codex Plan',
+                    body: result.finalMessage,
+                    ...(ownerId ? { responseUserId: ownerId } : {}),
+                    ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                });
+                await handoffFinalMessage(session.conversationId);
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent plan approval card`);
+            }
+            else if (!result.interrupted && result.finalMessage) {
+                if (isRecoverableCodexThreadError(result.errorText)) {
+                    clearStoredThread();
+                }
+                await routeArtifactsOnce();
+                const turnTrail = buildFinalTurnTrail(session);
+                await sendMessageWithRetryChunked(client, session.conversationId, result.finalMessage, {
+                    messageId: buildCodexMessageId(session, 'final'),
+                    ...(session.activeSelfContextId
+                        ? { selfContextId: session.activeSelfContextId }
+                        : {}),
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
+                    },
+                });
+                await handoffFinalMessage(session.conversationId);
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
+            }
+            else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+                await routeArtifactsOnce();
+                const userVisibleError = formatCodexTurnFailure(result.errorText);
+                session.state.lastError = userVisibleError;
+                writeState(session);
+                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.activeSelfContextId
+                        ? { selfContextId: session.activeSelfContextId }
+                        : {}),
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                        ...(turnTrail.length > 0 ? { turnTrail } : {}),
+                    },
+                });
+                await handoffFinalMessage(session.conversationId);
+            }
+            else if (!result.interrupted) {
+                await routeArtifactsOnce();
+                await handoffFinalMessage(session.conversationId);
+            }
+            else if (result.interrupted) {
+                session.turnState = 'interrupted';
+                writeTurn(session);
+                stopVisibleWorkSignal(session);
+                clearStreaming(session.conversationId);
+                typingSignals.clear(session.conversationId).catch(() => { });
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
+            }
+        }
+        catch (error) {
+            const message = error instanceof ExecutionEnvironmentError
+                ? error.userMessage
+                : error instanceof CanonApiError
+                    ? `The Codex host completed the turn, but Canon could not deliver the reply: ${error.message}`
+                    : `The Codex host failed during the turn: ${error instanceof Error ? error.message : String(error)}`;
+            session.state.lastError = message;
+            writeState(session);
+            await routeArtifactsOnce();
+            await sendMessageWithRetryChunked(client, session.conversationId, message, {
+                messageId: buildCodexMessageId(session, 'failure'),
+                ...(session.activeSelfContextId
+                    ? { selfContextId: session.activeSelfContextId }
+                    : {}),
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            }).catch(() => { });
+            await handoffFinalMessage(session.conversationId);
+            if (error instanceof Error && isRecoverableCodexThreadError(error.message)) {
+                clearStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, session.environment.mode);
+            }
+            console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
+        }
+        finally {
+            stopVisibleWorkSignal(session);
+            session.running = false;
+            session.state.state = 'idle';
+            session.turnState = 'idle';
+            session.currentTurnId = null;
+            session.currentTurnOpenedAt = null;
+            session.currentTurnUpdatedAt = null;
+            session.currentTurnCanUseCodexAppTools = false;
+            session.lastAcceptedIntent = null;
+            session.resetRequested = false;
+            session.lastActivity = Date.now();
+            writeState(session);
+            writeTurn(session);
+            if (session.queue.length > 0) {
+                void runNextTurn(session);
+            }
+        }
+    }
     let streamConnected = false;
     const hostAvailableExecutionModes = [
         ...EXECUTION_ENVIRONMENT_MODES,
@@ -1709,14 +1732,16 @@ export async function main() {
             permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
-            supportsPlanMode: true,
-            supportsCompact: true,
-            supportsRichCards: true,
+            supportsPlanMode: useAppServer,
+            supportsCompact: useAppServer,
+            supportsRichCards: useAppServer,
             skills: codexSkills,
         }),
     });
     let runtimeDescriptor = buildCurrentRuntimeDescriptor();
     async function refreshCodexSkillInventory(forceReload = false) {
+        if (!useAppServer)
+            return;
         const probe = new CodexAppServerAdapter({
             cwd: workingDir,
             codexBin,
@@ -1745,7 +1770,7 @@ export async function main() {
             if (modelGuard) {
                 session.state.lastError = modelGuard;
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${modelGuard}`);
-                session.writeState();
+                writeState(session);
                 // The poller consumes the node; skip effort handling for this pass,
                 // matching the legacy loop.
                 return;
@@ -1753,42 +1778,58 @@ export async function main() {
             session.adapter.setModel(control.model);
             session.state.model = control.model;
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Model set for next turn -> ${control.model}`);
-            session.writeState();
+            writeState(session);
         }
         if (control.permissionMode) {
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] approval mode is session-creation-only; ignoring mid-session change request (${control.permissionMode})`);
             // Convergence contract: a consumed session control must always be
             // answered. Re-publish the currently applied state so clients settle on
             // the authoritative value instead of holding the composer until timeout.
-            session.writeState();
+            writeState(session);
         }
         if (control.effort) {
             if (CODEX_EFFORT_VALUES.has(control.effort)) {
                 session.adapter.setReasoningEffort(control.effort);
                 session.state.effort = control.effort;
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Reasoning effort set for next turn -> ${control.effort}`);
-                session.writeState();
+                writeState(session);
             }
             else {
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring unknown effort level (${control.effort})`);
                 // Same contract: ignored values still get an authoritative re-publish.
-                session.writeState();
+                writeState(session);
             }
         }
     }
-    // Interrupt/stop-clear signal handling (generic shell from @canonmsg/agent-host).
-    const handleControlSignal = createRuntimeSignalHandler({
-        agentId,
-        logPrefix: '[canon-codex]',
-        capabilities: CODEX_RUNTIME_CAPABILITIES,
-    }, {
-        sessions,
-        port,
-        isSessionRunning: (session) => session.running,
-        interruptRuntime: (session) => session.adapter.interrupt(),
-        resetSession: (session) => resetRuntimeSession(session),
-        markSessionPendingInputsRejected,
-    });
+    async function handleControlSignal(event) {
+        const { conversationId, type } = event;
+        const session = sessions.get(conversationId);
+        // No live session: dedupe already advanced, but the node stays in place,
+        // matching the legacy loop.
+        if (!session || session.closed)
+            return { consume: false };
+        if (type === 'new_session') {
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] new_session signal`);
+            await resetRuntimeSession(session);
+            return;
+        }
+        if (!session.running && (type !== 'stop_and_drop' || session.queue.length === 0)) {
+            // Nothing to interrupt or drop — just consume the signal.
+            return;
+        }
+        console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${type} signal`);
+        if (type === 'stop_and_drop') {
+            const droppedPrompts = session.queue.splice(0);
+            await markQueuedPromptsRejected(conversationId, droppedPrompts);
+        }
+        if (session.running) {
+            await session.adapter.interrupt();
+        }
+        session.turnState = 'interrupted';
+        writeTurn(session);
+        clearStreaming(conversationId);
+        typingSignals.clear(conversationId).catch(() => { });
+    }
     async function handleControlPrimitive(event) {
         const { conversationId, value } = event;
         const primitiveId = typeof value.id === 'string' ? value.id : '';
@@ -1801,30 +1842,39 @@ export async function main() {
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: no live Codex session`);
             return;
         }
+        if (!(session.adapter instanceof CodexAppServerAdapter)) {
+            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Cannot compact context: compact is only available for Codex app-server sessions`);
+            return;
+        }
         try {
             await session.adapter.compactThread();
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Compact requested`);
-            session.writeState();
+            writeState(session);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             session.state.lastError = `Could not compact Codex context: ${message}`;
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${session.state.lastError}`);
-            session.writeState();
+            writeState(session);
         }
     }
-    // Control events arrive as bridge notifications — the bridge owns the ONE
-    // authoritative /control consumer for this identity (plan §2); the host's
-    // adaptive poller (cadence, jitter, baselines) is deleted with it.
-    const detachControlNotifications = attachCodexControlNotifications({
-        source: notifications.source,
+    const controlPoller = createCodexControlPoller({
+        rtdb,
+        agentId,
+        conversationIds: () => sessions.keys(),
+        hasActiveWork: () => [...sessions.values()].some((session) => !session.closed
+            && (session.running || session.queue.length > 0 || session.turnState === 'waiting_input')),
         onSessionControl: ({ conversationId, control }) => {
             applySessionControl(conversationId, control);
         },
         onSignal: handleControlSignal,
         onPrimitive: handleControlPrimitive,
-        onError: (error, kind, conversationId) => {
-            console.error(`[canon-codex] [${(conversationId ?? 'unknown').slice(0, 8)}] Control ${kind} handler failed:`, error instanceof Error ? error.message : error);
+        onError: (error) => {
+            // The legacy loop ignored transient RTDB failures; keep read/consume
+            // errors quiet but surface handler failures.
+            if (error.scope !== 'handler')
+                return;
+            console.error(`[canon-codex] [${(error.conversationId ?? 'unknown').slice(0, 8)}] Control ${error.key ?? 'poll'} handler failed:`, error.error instanceof Error ? error.error.message : error.error);
         },
     });
     let publishRuntimeDetailsInFlight = false;
@@ -1837,7 +1887,7 @@ export async function main() {
         });
         if (!streamConnected)
             return;
-        await publishAgentRuntime(port, runtimeDescriptor).catch((error) => {
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
             console.error('[canon-codex] Failed to publish agent runtime:', error);
         });
         if (publishRuntimeDetailsInFlight)
@@ -1847,14 +1897,15 @@ export async function main() {
             await refreshKnownConversationIds().catch((error) => {
                 console.error('[canon-codex] Failed to refresh known conversations:', error);
             });
-            await port.publishHostSessionSnapshots({
+            await publishHostSessionSnapshots({
                 conversationIds: Array.from(knownConversationIds),
+                agentId,
                 clientType: 'codex',
                 runtime: runtimeDescriptor,
-                workspaceOptions: workspaceOptions.map(({ id, cwd }) => ({ id, cwd })),
+                workspaceOptions,
                 defaultCwd: workingDir,
-                extraSessionConfigFields: [...CODEX_SESSION_CONFIG_FIELDS],
-                liveSessionConfigByConversation: Object.fromEntries(Array.from(sessions.values()).map((session) => {
+                extraSessionConfigFields: CODEX_SESSION_CONFIG_FIELDS,
+                liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
                     const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
                     return [
                         session.conversationId,
@@ -1883,16 +1934,24 @@ export async function main() {
                 const payload = {
                     descriptor,
                     surfaceMode: 'host',
+                    // The exec --json transport cannot block on approvals — without a
+                    // strip-level warning a user can believe they have an approval
+                    // gate they do not have.
+                    ...(useAppServer
+                        ? {}
+                        : { warning: "Approvals can't block on this Codex CLI — update Codex to enable the app-server transport and approval gates." }),
                     statusItems: [
                         {
                             id: 'transport',
                             label: 'Transport',
-                            value: 'app-server',
+                            value: useAppServer ? 'app-server' : 'exec --json',
                         },
                         {
                             id: 'streaming',
                             label: 'Live output',
-                            value: 'Plans, questions, approvals, tools, and message deltas',
+                            value: useAppServer
+                                ? 'Plans, questions, approvals, tools, and message deltas'
+                                : 'Thinking, tools, and completed-message previews',
                         },
                         {
                             id: 'codex-cli',
@@ -1903,7 +1962,8 @@ export async function main() {
                         {
                             id: 'nativeActions',
                             label: 'Native actions',
-                            value: 'Enabled',
+                            value: useAppServer ? 'Enabled' : 'Limited until app-server transport',
+                            ...(useAppServer ? {} : { tone: 'warning' }),
                         },
                         {
                             id: 'mediaOut',
@@ -1922,13 +1982,12 @@ export async function main() {
                         fallbackReason: resolveExecutionFallbackReason(session?.environment),
                     },
                     notes: [
-                        'This Codex host uses the app-server transport, so Canon can route native plan mode, runtime questions, approvals, and live turn updates.',
+                        useAppServer
+                            ? 'This Codex host uses the app-server transport, so Canon can route native plan mode, runtime questions, approvals, and live turn updates.'
+                            : 'This Codex host uses the current exec --json transport, so Canon can show thinking, tool activity, and completed assistant-message previews, but not native plan questions or structured approvals.',
                     ],
                 };
-                await port.publishRuntimeStatus({
-                    conversationId,
-                    presentation: payload,
-                });
+                await runtimeState.writeRuntimeInfo(conversationId, payload);
             })).catch((error) => {
                 console.error('[canon-codex] Failed to publish runtime info:', error);
             });
@@ -1937,157 +1996,122 @@ export async function main() {
             publishRuntimeDetailsInFlight = false;
         }
     };
-    // ── Inbound Canon events (bridge notifications) ──
-    // The bridge owns SSE reconnect/heartbeat/replay + dedup + self-filtering.
-    // HITL control-reply messages (approval_reply / plan_approval_reply) are
-    // STRIPPED from onMessage bridge-side; plan replies arrive as
-    // onControlReply and re-enter the plan flow below.
-    const handleBridgeMessage = (payload) => {
-        const message = payload.message;
-        if (message.senderId === agentId)
-            return;
-        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}`);
-            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,
-        });
-        if (message.id) {
-            saveRuntimeSessionState(runtimeId, {
-                conversationId: payload.conversationId,
-                baseCwd: workingDir,
-                lastInboundMessageId: message.id,
-            });
-        }
-    };
-    const attachInboundNotifications = () => notifications.attach({
-        onMessage: (params) => {
-            handleBridgeMessage(params);
-        },
-        onMessageDeleted: (params) => {
-            const payload = params;
-            removeQueuedInput(payload.conversationId, payload.messageId);
-        },
-        onConversationUpdated: (params) => {
-            handleConversationUpdated(params);
-        },
-        onControlReply: (params) => {
-            const payload = params;
-            const message = payload.message;
-            // Only the plan flow consumes stripped control replies host-side —
-            // approval/card replies resolve against the bridge's HITL records.
-            if (!isRecord(message.metadata) || message.metadata.type !== 'plan_approval_reply') {
-                return;
-            }
-            void enqueueInboundMessage({
-                conversationId: payload.conversationId,
-                message,
-                senderName: message.senderName || message.senderId,
-                isOwner: message.isOwner ?? (ownerId != null && message.senderId === ownerId),
-            });
-        },
-        ready: () => {
-            streamConnected = true;
-            void publishRuntimeHeartbeat();
-            console.error('[canon-codex] Bridge ready');
-        },
-        connectionState: (params) => {
-            const { upstream } = params;
-            if (upstream === 'connected') {
+    const stream = new CanonStream({
+        apiKey,
+        agentId,
+        handler: {
+            onMessage: (payload) => {
+                const message = payload.message;
+                if (message.senderId === agentId)
+                    return;
+                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}`);
+                    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,
+                });
+                if (message.id) {
+                    saveRuntimeSessionState(runtimeId, {
+                        conversationId: payload.conversationId,
+                        baseCwd: workingDir,
+                        lastInboundMessageId: message.id,
+                    });
+                }
+            },
+            onMessageDeleted: (payload) => {
+                removeQueuedPrompt(payload.conversationId, payload.messageId);
+            },
+            onConversationUpdated: (payload) => {
+                handleConversationUpdated(payload);
+            },
+            onConnected: () => {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
-                console.error('[canon-codex] Canon upstream connected');
-            }
-            else {
+                console.error('[canon-codex] SSE connected');
+            },
+            onDisconnected: () => {
                 streamConnected = false;
-                port.clearAgentRuntime().catch(() => { });
-                console.error(`[canon-codex] Canon upstream ${upstream}`);
-            }
+                runtimeState.clearAgentRuntime().catch(() => { });
+                console.error('[canon-codex] SSE disconnected');
+            },
+            onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
         },
     });
     await refreshCodexSkillInventory();
     try {
-        const conversations = await directory.listConversations();
-        directory.primeFromStartup(conversations);
-        for (const conversation of conversations) {
-            port.clearStreaming({ conversationId: conversation.id }).catch(() => { });
-            port.clearSessionState({ conversationId: conversation.id }).catch(() => { });
-            port.clearTurnState({ conversationId: conversation.id }).catch(() => { });
-        }
+        const conversations = await client.getConversations();
+        lastKnownConversationRefreshAt = Date.now();
         for (const conversation of conversations) {
-            const cursor = loadRuntimeSessionState(runtimeId, {
-                conversationId: conversation.id,
-                baseCwd: workingDir,
-            })?.lastInboundMessageId;
-            const recovery = await collectMissedInboundMessages({
-                fetchPage: (before) => port.getMessages({
-                    conversationId: conversation.id,
-                    limit: STARTUP_RECOVERY_PAGE_SIZE,
-                    ...(before ? { before } : {}),
-                    includeBehavior: true,
-                }),
-                cursor,
-                agentId,
-            });
-            const latestPage = recovery.newestPage;
-            if (recovery.mode === 'truncated-window') {
-                console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Startup recovery cursor not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; recovering truncated window`);
-            }
-            if (recovery.messages.length > 1) {
-                console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Recovered ${recovery.messages.length} missed messages in ${conversation.id}`);
-            }
-            for (const latestMessage of recovery.messages) {
-                const triggerDecision = shouldTriggerAgentTurn({
-                    senderType: latestMessage.senderType ?? 'human',
-                    metadata: latestMessage.metadata,
-                });
-                if (!triggerDecision.allow) {
-                    console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Skipping startup recovery for suppressed message (${triggerDecision.reason})`);
-                    continue;
-                }
-                console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Recovering inbound message on startup`);
-                await enqueueInboundMessage({
-                    conversationId: conversation.id,
-                    message: latestMessage,
-                    senderName: latestMessage.senderName || latestMessage.senderId,
-                    isOwner: ownerId != null && latestMessage.senderId === ownerId,
-                    behavior: latestPage.behavior,
-                    selfContexts: latestPage.selfContexts,
-                    hydratedPage: latestPage,
-                });
-                if (latestMessage.id) {
-                    saveRuntimeSessionState(runtimeId, {
-                        conversationId: conversation.id,
-                        baseCwd: workingDir,
-                        lastInboundMessageId: latestMessage.id,
-                    });
-                }
-            }
+            knownConversationIds.add(conversation.id);
+            conversationCache.set(conversation.id, conversation);
+            clearStreaming(conversation.id);
+            runtimeState.clearSessionState(conversation.id).catch(() => { });
+            runtimeState.clearTurnState(conversation.id).catch(() => { });
         }
     }
     catch (error) {
         console.error('[canon-codex] Failed to load startup conversations:', error);
     }
-    attachInboundNotifications();
-    // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──
-    lifecycle.startTimers();
-    lifecycle.installSignalHandlers();
+    startCodexStreamInBackground(stream, (error) => {
+        console.error('[canon-codex] SSE start error:', error instanceof Error ? error.message : error);
+    });
+    controlPoller.start();
+    const heartbeat = setInterval(() => {
+        for (const session of sessions.values()) {
+            writeState(session);
+            if (!session.running) {
+                writeTurn(session);
+            }
+        }
+        void publishRuntimeHeartbeat();
+    }, HEARTBEAT_MS);
+    const idleCheck = setInterval(() => {
+        const now = Date.now();
+        for (const conversationId of [...sessions.keys()]) {
+            const session = sessions.get(conversationId);
+            if (!session || session.running)
+                continue;
+            if (now - session.lastActivity > IDLE_TIMEOUT_MS) {
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Idle timeout`);
+                closeSession(conversationId);
+            }
+        }
+    }, IDLE_CHECK_MS);
+    const shutdown = async () => {
+        console.error('[canon-codex] Shutting down...');
+        controlPoller.stop();
+        clearInterval(heartbeat);
+        clearInterval(idleCheck);
+        runtimeRequests.dispose();
+        stream.stop();
+        await runtimeState.clearAgentRuntime().catch(() => { });
+        for (const session of [...sessions.values()]) {
+            await session.adapter.interrupt().catch(() => { });
+            closeSession(session.conversationId);
+        }
+        markLocalRuntimeStopped(runtimeId);
+        (lockHandle ?? getActiveProfileLock())?.release();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    process.on('SIGHUP', shutdown);
     console.error('[canon-codex] Ready — sessions created on demand');
     await new Promise(() => { });
 }
 runCli(import.meta.url, main, (error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(`[canon-codex] ${message}`);
-    activeLockHandle?.release();
+    getActiveProfileLock()?.release();
     process.exit(1);
 }, {
     name: 'canon-codex',