@canonmsg/codex-plugin 0.32.2 → 0.32.5

package/README.md

@@ -2,6 +2,10 @@
 
 Connect the local Codex CLI to [Canon](https://canonmail.com/agents) so a Canon user can message your coding agent from the app.
 
+The audited stable app-server baseline is **Codex CLI 0.155.1**. Install it with `npm install -g @openai/codex@0.155.1`. Canon keeps using the native CLI installed on the host; it does not replace your CLI automatically. Release checks run `npm run smoke:protocol --workspace @canonmsg/codex-plugin` against this version using a temporary, unauthenticated home without starting a model turn.
+
+Managed app-server sessions withdraw Canon questions and approvals when Codex resolves them or their turn ends. Model choices include reported input modalities. Runtime details show observed provider authentication, usage-limit availability and tool reconnect needs without exposing account identifiers, tool credentials or raw provider errors.
+
 The plugin uses the local user's existing Codex authentication by default. That means Canon follows whatever plan or login mode the user has configured in Codex itself, instead of asking for a separate Canon-side OpenAI credential.
 
 ## Quick start

package/dist/adapter.d.ts

@@ -38,11 +38,15 @@ export type CodexEvent = {
     effort: string | null;
 } | {
     type: 'skills.changed';
+} | {
+    type: 'request.resolved';
 };
 export interface CodexServerRequest {
     id: string | number;
     method: string;
     params: Record<string, unknown>;
+    /** Aborted when the native request is resolved or its owning turn ends. */
+    signal?: AbortSignal;
 }
 export interface CodexRunTurnOptions {
     /** Original human text, before Canon adds conversation/reply context. */

package/dist/app-server-adapter.d.ts

@@ -18,6 +18,7 @@ export interface CodexModelMetadata {
     displayName: string;
     description?: string;
     supportedReasoningEfforts: CodexReasoningEffortMetadata[];
+    inputModalities?: string[];
     defaultReasoningEffort?: string;
     isDefault: boolean;
 }
@@ -32,6 +33,7 @@ export declare class CodexAppServerAdapter {
     private readonly fullAuto;
     private readonly bypassApprovalsAndSandbox;
     private readonly dynamicTools;
+    private readonly onCapabilitiesChanged?;
     private child;
     private threadId;
     private loadedThreadId;
@@ -41,6 +43,7 @@ export declare class CodexAppServerAdapter {
     private currentTurnId;
     private requestSeq;
     private pending;
+    private serverRequests;
     private currentOnEvent;
     private currentOnLog;
     private currentRequestHandler;
@@ -51,6 +54,7 @@ export declare class CodexAppServerAdapter {
     private interrupted;
     private initialized;
     private skillsCache;
+    private readonly runtimeStatus;
     private messageTextByItem;
     private planText;
     constructor(opts: {
@@ -65,6 +69,7 @@ export declare class CodexAppServerAdapter {
         fullAuto?: boolean;
         bypassApprovalsAndSandbox?: boolean;
         dynamicTools?: readonly JsonRecord[];
+        onCapabilitiesChanged?: () => void;
     });
     getThreadId(): string | null;
     getResolvedModel(): string | null;
@@ -72,6 +77,8 @@ export declare class CodexAppServerAdapter {
         model?: string;
         effort?: string;
     }>;
+    getRuntimeFacts(): import("@canonmsg/core").CanonRuntimeFact[];
+    refreshRuntimeFacts(): Promise<void>;
     getResolvedReasoningEffort(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;

package/dist/app-server-adapter.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { normalizePlanStepStatus, renderPlanSteps } from '@canonmsg/coding-agent-host';
+import { CodexRuntimeStatus } from './runtime-status.js';
 const DEFAULT_DISCOVERY_REQUEST_TIMEOUT_MS = 5_000;
 export class CodexAppServerAdapter {
     cwd;
@@ -13,6 +14,7 @@ export class CodexAppServerAdapter {
     fullAuto;
     bypassApprovalsAndSandbox;
     dynamicTools;
+    onCapabilitiesChanged;
     child = null;
     threadId;
     loadedThreadId = null;
@@ -23,6 +25,7 @@ export class CodexAppServerAdapter {
     currentTurnId = null;
     requestSeq = 1;
     pending = new Map();
+    serverRequests = new Map();
     currentOnEvent = null;
     currentOnLog = null;
     currentRequestHandler = null;
@@ -33,6 +36,7 @@ export class CodexAppServerAdapter {
     interrupted = false;
     initialized = false;
     skillsCache = null;
+    runtimeStatus = new CodexRuntimeStatus();
     messageTextByItem = new Map();
     planText = '';
     constructor(opts) {
@@ -48,6 +52,7 @@ export class CodexAppServerAdapter {
         this.fullAuto = opts.fullAuto ?? false;
         this.bypassApprovalsAndSandbox = opts.bypassApprovalsAndSandbox ?? false;
         this.dynamicTools = opts.dynamicTools ?? [];
+        this.onCapabilitiesChanged = opts.onCapabilitiesChanged;
     }
     getThreadId() {
         return this.threadId;
@@ -58,10 +63,27 @@ export class CodexAppServerAdapter {
     getObservedSettings() {
         return { ...this.observedSettings };
     }
+    getRuntimeFacts() {
+        return this.runtimeStatus.facts();
+    }
+    async refreshRuntimeFacts() {
+        if (!this.child || !this.initialized || !this.runtimeStatus.hasQuota())
+            return;
+        const revision = this.runtimeStatus.revision;
+        try {
+            const snapshot = await this.sendRequest('account/rateLimits/read', {}, 2_000);
+            if (revision === this.runtimeStatus.revision && isRecord(snapshot))
+                this.runtimeStatus.replaceQuota(snapshot);
+        }
+        catch {
+            // Unavailable snapshots do not mean zero usage. Retain reported facts.
+        }
+    }
     getResolvedReasoningEffort() {
         return this.resolvedReasoningEffort ?? this.reasoningEffort;
     }
     clearThreadId() {
+        this.runtimeStatus.reset();
         this.observedSettings = {};
         this.threadId = null;
         this.loadedThreadId = null;
@@ -119,6 +141,7 @@ export class CodexAppServerAdapter {
     }
     close() {
         this.observedSettings = {};
+        this.runtimeStatus.reset();
         this.child?.kill('SIGTERM');
         this.child = null;
         this.initialized = false;
@@ -352,6 +375,7 @@ export class CodexAppServerAdapter {
             this.observedSettings = {};
             const message = `Codex app-server exited${code === null ? '' : ` with code ${code}`}`;
             this.initialized = false;
+            this.runtimeStatus.reset();
             this.child = null;
             for (const pending of this.pending.values()) {
                 pending.reject(new Error(message));
@@ -369,6 +393,7 @@ export class CodexAppServerAdapter {
             clientInfo: { name: 'canon-codex', version: '0.0.0' },
             capabilities: { experimentalApi: true, supportsServerRequests: true },
         });
+        this.write({ method: 'initialized' });
         this.initialized = true;
     }
     handleLine(line) {
@@ -398,6 +423,7 @@ export class CodexAppServerAdapter {
         }
     }
     async handleServerRequest(request) {
+        const controller = new AbortController();
         try {
             const params = isRecord(request.params) ? request.params : {};
             // Detached child threads may use the ordinary coding-thread bridge, but
@@ -414,16 +440,24 @@ export class CodexAppServerAdapter {
                 });
                 return;
             }
+            this.serverRequests.set(request.id, {
+                controller,
+                threadId: readString(params, 'threadId') ?? this.threadId,
+            });
             const result = this.currentRequestHandler
                 ? await this.currentRequestHandler({
                     id: request.id,
                     method: request.method,
                     params,
+                    signal: controller.signal,
                 })
                 : defaultServerRequestResult(request.method);
-            this.write({ id: request.id, result });
+            if (!controller.signal.aborted)
+                this.write({ id: request.id, result });
         }
         catch (error) {
+            if (controller.signal.aborted)
+                return;
             this.write({
                 id: request.id,
                 error: {
@@ -432,11 +466,42 @@ export class CodexAppServerAdapter {
                 },
             });
         }
+        finally {
+            if (this.serverRequests.get(request.id)?.controller === controller) {
+                this.serverRequests.delete(request.id);
+            }
+        }
     }
     handleNotification(method, params) {
+        if (method === 'account/updated') {
+            this.observedSettings = {};
+            this.skillsCache = null;
+            this.onCapabilitiesChanged?.();
+        }
+        // Account events are process-wide. Tool readiness can be scoped to a thread.
+        if (this.isCurrentThreadNotification(params) && this.runtimeStatus.observe(method, params))
+            return;
+        if (method === 'serverRequest/resolved') {
+            const id = params.requestId;
+            if (typeof id !== 'number' && typeof id !== 'string')
+                return;
+            const request = this.serverRequests.get(id);
+            const threadId = readString(params, 'threadId');
+            if (request && (!threadId || threadId === request.threadId)) {
+                this.serverRequests.delete(id);
+                request.controller.abort(new Error('Codex resolved the native request'));
+                if (this.serverRequests.size === 0 && this.isRunning() && this.isCurrentThreadNotification(params)) {
+                    this.currentOnEvent?.({ type: 'request.resolved' });
+                }
+            }
+            return;
+        }
         if (method === 'skills/changed') {
             this.skillsCache = null;
-            this.currentOnEvent?.({ type: 'skills.changed' });
+            if (this.onCapabilitiesChanged)
+                this.onCapabilitiesChanged();
+            else
+                this.currentOnEvent?.({ type: 'skills.changed' });
             return;
         }
         if (!this.isCurrentThreadNotification(params))
@@ -596,6 +661,10 @@ export class CodexAppServerAdapter {
         this.clearActiveTurn();
     }
     clearActiveTurn() {
+        for (const { controller } of this.serverRequests.values()) {
+            controller.abort(new Error('Codex turn ended'));
+        }
+        this.serverRequests.clear();
         this.currentTurnId = null;
         this.currentOnEvent = null;
         this.currentOnLog = null;
@@ -768,9 +837,13 @@ function parseModelListResponse(result) {
             })
             : [];
         const defaultReasoningEffort = readString(entry, 'defaultReasoningEffort');
+        const inputModalities = Array.isArray(entry.inputModalities)
+            ? [...new Set(entry.inputModalities.filter((value) => typeof value === 'string' && /^[a-z][a-z_-]{0,31}$/.test(value)))]
+            : [];
         models.push({
             id,
             model,
+            ...(inputModalities.length ? { inputModalities } : {}),
             displayName,
             ...(description ? { description } : {}),
             supportedReasoningEfforts: efforts,
@@ -839,9 +912,11 @@ function renderPlan(params) {
     })), { explanation });
 }
 function defaultServerRequestResult(method) {
+    if (method === 'item/permissions/requestApproval')
+        return { permissions: {}, scope: 'turn' };
     if (method.includes('requestApproval'))
         return { decision: 'decline' };
     if (method === 'item/tool/requestUserInput')
         return { answers: {} };
-    return {};
+    throw new Error(`Unsupported Codex server request: ${method}`);
 }

package/dist/host.d.ts

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

package/dist/host.js

@@ -84,6 +84,7 @@ export function buildCodexSessionFacts(session) {
             id: 'runtime', label: 'Runtime', value: appServer ? 'Codex app-server' : 'Codex CLI', group: 'runtime',
         }];
     if (appServer) {
+        facts.push(...adapter.getRuntimeFacts());
         const observed = adapter.getObservedSettings();
         if (observed.model)
             facts.push({ id: 'model', label: 'Model', value: observed.model, group: 'model' });
@@ -105,6 +106,9 @@ const CODEX_UNDELIVERABLE_FINAL_WORDING = {
     lead: 'The Codex host completed the turn, but Canon could not deliver the reply',
 };
 const IDLE_CHECK_MS = 60_000;
+/** Explicit user controls cancel work; lifecycle shutdown must preserve it. */
+class CodexTurnCanceledError extends Error {
+}
 const PLAN_REVIEW_TIMEOUT_MS = 10 * 60_000;
 const CODEX_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
@@ -1067,7 +1071,8 @@ export async function main() {
         }
     }
     async function markQueuedPromptsRejected(conversationId, prompts) {
-        await Promise.all(prompts.map((prompt) => {
+        await Promise.all(prompts.map(async (prompt) => {
+            await prompt.inboundHandoff?.cancel('canceled-before-execution');
             if (!prompt.markAccepted || !prompt.sourceMessageId)
                 return Promise.resolve();
             return client.updateMessageDisposition(conversationId, prompt.sourceMessageId, 'rejected').catch(() => { });
@@ -1075,10 +1080,12 @@ export async function main() {
     }
     function settleRejectedPromptCheckpoints(conversationId, prompts) {
         const checkpoints = recoveryCheckpointsFor(conversationId);
-        for (const prompt of prompts)
-            checkpoints.settle(prompt.sourceMessageId);
+        for (const prompt of prompts) {
+            if (!prompt.inboundHandoff || prompt.inboundHandoff.phase === 'settled')
+                checkpoints.settle(prompt.sourceMessageId);
+        }
     }
-    function removeQueuedPrompt(conversationId, sourceMessageId) {
+    async function removeQueuedPrompt(conversationId, sourceMessageId) {
         const session = sessions.get(conversationId);
         if (!session || session.queue.length === 0)
             return;
@@ -1086,6 +1093,7 @@ export async function main() {
         if (removed.length === 0)
             return;
         session.queue = session.queue.filter((prompt) => prompt.sourceMessageId !== sourceMessageId);
+        await Promise.all(removed.map((prompt) => prompt.inboundHandoff?.cancel('message-deleted')));
         settleRejectedPromptCheckpoints(conversationId, removed);
         writeTurn(session);
     }
@@ -1260,6 +1268,11 @@ export async function main() {
         if (!session)
             return;
         session.closed = true;
+        // Closing a native session relinquishes only unsubmitted Canon work.
+        for (const prompt of session.queue) {
+            void prompt.inboundHandoff?.release('session-closed').catch(console.error);
+        }
+        void session.currentInboundHandoff?.release('session-closed').catch(console.error);
         session.currentTurnAbortController?.abort(new Error('Codex session closed'));
         session.currentTurnAbortController = null;
         stopVisibleWorkSignal(session);
@@ -1277,6 +1290,7 @@ export async function main() {
     async function resetRuntimeSession(session) {
         const conversationId = session.conversationId;
         session.resetRequested = true;
+        void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
         const droppedPrompts = session.queue.splice(0);
         await markQueuedPromptsRejected(conversationId, droppedPrompts);
         settleRejectedPromptCheckpoints(conversationId, droppedPrompts);
@@ -1285,7 +1299,7 @@ export async function main() {
         session.activeSelfContextId = null;
         session.state.lastError = undefined;
         if (session.running) {
-            session.currentTurnAbortController?.abort(new Error('Codex session reset'));
+            session.currentTurnAbortController?.abort(new CodexTurnCanceledError('Codex session reset'));
             await session.adapter.interrupt();
             session.turnState = 'interrupted';
         }
@@ -1416,6 +1430,10 @@ export async function main() {
                             fullAuto: policy.fullAuto,
                             bypassApprovalsAndSandbox: policy.bypassApprovalsAndSandbox,
                             dynamicTools: codexDynamicTools,
+                            onCapabilitiesChanged: () => {
+                                invalidateCodexCatalog();
+                                runtimeHeartbeat.refresh();
+                            },
                         })
                         : new CodexConversationAdapter({
                             cwd: sessionCwd,
@@ -1498,6 +1516,7 @@ export async function main() {
         const nextPrompt = {
             prompt,
             skillInvocationText: turn.skillInvocationText,
+            inboundHandoff: turn.inboundHandoff,
             intent,
             sourceMessageId,
             markAccepted,
@@ -1571,6 +1590,12 @@ export async function main() {
         return params.card ?? params.cardDocument ?? input?.card ?? args?.card ?? null;
     }
     async function handleCodexServerRequest(session, request, requestingUserId, sourceMessageId) {
+        const requestSignal = AbortSignal.any([
+            ...(request.signal ? [request.signal] : []),
+            ...(session.currentTurnAbortController ? [session.currentTurnAbortController.signal] : []),
+        ]);
+        requestSignal.throwIfAborted();
+        const requestTurnId = session.currentTurnId;
         const requestId = String(request.id);
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
@@ -1631,12 +1656,14 @@ export async function main() {
                         ...(responseRouting.responseUserId
                             ? { responseUserId: responseRouting.responseUserId }
                             : {}),
-                        turnId: session.currentTurnId ?? undefined,
+                        turnId: requestTurnId ?? undefined,
                     }, {
                         requestId: inputId,
                         expiresAt,
-                        signal: session.currentTurnAbortController?.signal,
+                        signal: requestSignal,
                         onCreated: () => {
+                            if (requestSignal.aborted)
+                                return;
                             session.turnState = 'waiting_input';
                             markTurnProgress(session);
                             stopVisibleWorkSignal(session);
@@ -1644,6 +1671,7 @@ export async function main() {
                             writeCodexStreaming(session, null, 'waiting_input');
                         },
                     });
+                    requestSignal.throwIfAborted();
                     resumeTurnFromWaiting(session);
                     return successfulCodexAppToolResult(response);
                 }
@@ -1663,7 +1691,7 @@ export async function main() {
                         card: { ...card, cardId },
                         cardId,
                         expiresAt,
-                        turnId: session.currentTurnId ?? undefined,
+                        turnId: requestTurnId ?? undefined,
                     });
                     return successfulCodexAppToolResult({
                         status: 'sent',
@@ -1678,15 +1706,17 @@ export async function main() {
                 const responseRouting = buildCodexTurnResponseRouting({ requestingUserId, ownerId });
                 const response = await runtimeRequests.request('card', session.conversationId, {
                     card,
-                    turnId: session.currentTurnId ?? undefined,
+                    turnId: requestTurnId ?? undefined,
                     ...(responseRouting.responseUserId
                         ? { responseUserId: responseRouting.responseUserId }
                         : {}),
                 }, {
                     requestId: cardId,
                     expiresAt,
-                    signal: session.currentTurnAbortController?.signal,
+                    signal: requestSignal,
                     onCreated: () => {
+                        if (requestSignal.aborted)
+                            return;
                         session.turnState = 'waiting_input';
                         markTurnProgress(session);
                         upsertTurnBlock(session, {
@@ -1701,6 +1731,7 @@ export async function main() {
                         writeCodexStreaming(session, null, 'waiting_input');
                     },
                 });
+                requestSignal.throwIfAborted();
                 completeTurnBlock(session, `card:${cardId}`, `Card ${response.status}`);
                 resumeTurnFromWaiting(session);
                 return successfulCodexAppToolResult(response);
@@ -1748,21 +1779,23 @@ export async function main() {
                         runtime: 'codex',
                         method: request.method,
                         requestId,
-                        turnId: readString(params, 'turnId') ?? session.currentTurnId ?? undefined,
+                        turnId: readString(params, 'turnId') ?? requestTurnId ?? undefined,
                         handles: {
                             itemId: readString(params, 'itemId') ?? '',
                             threadId: readString(params, 'threadId') ?? '',
                         },
                     },
-                    turnId: session.currentTurnId ?? undefined,
+                    turnId: requestTurnId ?? undefined,
                     ...(responseRouting.responseUserId
                         ? { responseUserId: responseRouting.responseUserId }
                         : {}),
                 }, {
                     requestId: cardId,
                     expiresAt,
-                    signal: session.currentTurnAbortController?.signal,
+                    signal: requestSignal,
                     onCreated: () => {
+                        if (requestSignal.aborted)
+                            return;
                         requestCreated = true;
                         session.turnState = 'waiting_input';
                         markTurnProgress(session);
@@ -1778,6 +1811,7 @@ export async function main() {
                         writeCodexStreaming(session, null, 'waiting_input');
                     },
                 });
+                requestSignal.throwIfAborted();
                 const response = cardResult.status === 'submitted'
                     ? {
                         status: 'submitted',
@@ -1797,11 +1831,12 @@ export async function main() {
                     messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, response.status),
                     metadata: {
                         ...outcome.metadata,
-                        turnId: session.currentTurnId ?? undefined,
+                        turnId: requestTurnId ?? undefined,
                         turnSemantics: 'control',
                         replyBehavior: 'suppress_auto_reply',
                     },
                 });
+                requestSignal.throwIfAborted();
                 completeTurnBlock(session, `card:${cardId}`, `Card ${response.status}`);
                 resumeTurnFromWaiting(session);
                 return response;
@@ -1818,7 +1853,7 @@ export async function main() {
                         messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, 'cancelled'),
                         metadata: {
                             ...outcome.metadata,
-                            turnId: session.currentTurnId ?? undefined,
+                            turnId: requestTurnId ?? undefined,
                             turnSemantics: 'control',
                             replyBehavior: 'suppress_auto_reply',
                         },
@@ -1853,18 +1888,19 @@ export async function main() {
                     runtime: 'codex',
                     method: request.method,
                     requestId,
-                    turnId: readString(params, 'turnId') ?? session.currentTurnId ?? undefined,
+                    turnId: readString(params, 'turnId') ?? requestTurnId ?? undefined,
                     handles: {
                         itemId: readString(params, 'itemId') ?? '',
                         threadId: readString(params, 'threadId') ?? '',
                     },
                 },
-                turnId: session.currentTurnId ?? undefined,
+                turnId: requestTurnId ?? undefined,
             }, {
                 requestId: inputId,
                 expiresAt,
-                signal: session.currentTurnAbortController?.signal,
+                signal: requestSignal,
             });
+            requestSignal.throwIfAborted();
             resumeTurnFromWaiting(session);
             return { answers: response.status === 'submitted' ? response.answers ?? {} : {} };
         }
@@ -1878,7 +1914,7 @@ export async function main() {
             const response = await runtimeRequests.request('approval', session.conversationId, {
                 ...mappedApproval,
                 native: { ...mappedApproval.native, requestId, method: request.method },
-                turnId: session.currentTurnId ?? undefined,
+                turnId: requestTurnId ?? undefined,
                 ...(responseRouting.responseUserId
                     ? { responseUserId: responseRouting.responseUserId }
                     : {}),
@@ -1886,8 +1922,9 @@ export async function main() {
             }, {
                 requestId: approvalId,
                 expiresAt,
-                signal: session.currentTurnAbortController?.signal,
+                signal: requestSignal,
             });
+            requestSignal.throwIfAborted();
             resumeTurnFromWaiting(session);
             if (request.method === 'item/permissions/requestApproval') {
                 return response.decision === 'allow'
@@ -1899,14 +1936,15 @@ export async function main() {
                 ...(response.sessionRule ? { sessionRule: response.sessionRule } : {}),
             });
         }
-        return {};
+        throw new Error(`Unsupported Codex server request: ${request.method}`);
     }
     async function enqueueInboundMessage(input) {
         knownConversationIds.add(input.conversationId);
         if (input.turnDispatch && input.turnDispatch.kind !== 'run_turn') {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed server-dispatched turn: ${input.turnDispatch.reason}`);
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         if (input.message.metadata?.type === 'plan_approval_reply') {
@@ -1914,8 +1952,9 @@ export async function main() {
                 // A service agent never advertises or enters plan mode. Consume stale
                 // replies left by an older coding descriptor instead of turning them
                 // into hidden plan/implementation prompts after an upgrade or restart.
-                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-                await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+                if (await input.inboundHandoff.settle('not-dispatched')) {
+                    recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+                }
                 return;
             }
             const planId = readString(input.message.metadata, 'planId');
@@ -1923,8 +1962,9 @@ export async function main() {
                 senderId: input.message.senderId,
                 metadata: input.message.metadata,
             })) {
-                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-                await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+                if (await input.inboundHandoff.settle('not-dispatched')) {
+                    recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+                }
                 return;
             }
             const session = await getOrCreateSession(input.conversationId);
@@ -1938,6 +1978,7 @@ export async function main() {
             enqueuePrompt(session, prompt, 'queue', false, input.message.id, false, [], [], decision !== 'approve', {
                 canUseCodexAppTools: input.isOwner || serviceAgentMode,
                 requestingUserId: getCodexRequestingUserId(input.message),
+                inboundHandoff: input.inboundHandoff,
             });
             return;
         }
@@ -1998,8 +2039,9 @@ export async function main() {
             : decideAutoReply(participantContext, behavior);
         if (!autoReply.allow) {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}" (${autoReply.reason})`);
@@ -2034,8 +2076,9 @@ export async function main() {
                 },
                 ...(input.replyAuthority ? { replyAuthority: input.replyAuthority } : {}),
             }).catch(() => { });
-            recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
-            await endpoint.setInboundState(`message:${input.conversationId}:${input.message.id}`, 'settled', 'not-dispatched');
+            if (await input.inboundHandoff.settle('not-dispatched')) {
+                recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
+            }
             return;
         }
         session.activeSelfContextId = activeSelfContextId;
@@ -2054,11 +2097,13 @@ export async function main() {
         if (session.running && deliveryIntent === 'interrupt') {
             enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
                 ...resolveCodexTurnModes(participantContext, input.message),
+                inboundHandoff: input.inboundHandoff,
                 skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
                 replyAuthority: input.replyAuthority ?? null,
             });
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
-            session.currentTurnAbortController?.abort(new Error('Codex turn interrupted by a newer message'));
+            void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
+            session.currentTurnAbortController?.abort(new CodexTurnCanceledError('Codex turn interrupted by a newer message'));
             await session.adapter.interrupt().catch(() => { });
             clearStreaming(input.conversationId);
             typingSignals.clear(input.conversationId).catch(() => { });
@@ -2066,6 +2111,7 @@ export async function main() {
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
             ...resolveCodexTurnModes(participantContext, input.message),
+            inboundHandoff: input.inboundHandoff,
             skillInvocationText: input.message.senderType === 'human' ? input.message.text ?? undefined : undefined,
             replyAuthority: input.replyAuthority ?? null,
         });
@@ -2115,7 +2161,9 @@ export async function main() {
             return;
         }
         const inboundId = nextTurn.sourceMessageId ? `message:${session.conversationId}:${nextTurn.sourceMessageId}` : null;
-        let journaledInput = false;
+        session.currentInboundHandoff = nextTurn.inboundHandoff;
+        let inputDeferred = false;
+        let preserveUnclaimedInput = false;
         let completedOutput;
         let nativeCompleted = false;
         session.state.lastError = undefined;
@@ -2217,6 +2265,10 @@ export async function main() {
                     void refreshCodexSkillInventory(true).then(() => runtimeHeartbeat.refresh());
                     return;
                 }
+                if (event.type === 'request.resolved') {
+                    resumeTurnFromWaiting(session);
+                    return;
+                }
                 if (event.type === 'settings.updated') {
                     if (event.model)
                         session.state.model = event.model;
@@ -2338,10 +2390,33 @@ export async function main() {
             // Canon-origin queues must retain a durable execution owner, including
             // legacy queues restored before endpoint migration. Native continuations
             // without a Canon source message remain a separate operator path.
-            if (inboundId && !await endpoint.claimInbound(inboundId))
+            const handoff = nextTurn.inboundHandoff ?? (inboundId ? await endpoint.acquireInbound(inboundId) : undefined);
+            session.currentInboundHandoff = handoff ?? undefined;
+            if (inboundId && !handoff) {
+                preserveUnclaimedInput = true;
                 return;
-            journaledInput = !!inboundId;
-            let result = await runTurnOnce();
+            }
+            if (handoff && (session.resetRequested || session.currentTurnAbortController?.signal.reason instanceof CodexTurnCanceledError)) {
+                await handoff.cancel('canceled-before-execution');
+            }
+            else if (handoff && (session.closed || session.currentTurnAbortController?.signal.aborted)) {
+                await handoff.release('session-closed');
+            }
+            const started = handoff
+                ? await endpoint.startInbound(handoff, runTurnOnce)
+                : { status: 'submitted', value: await runTurnOnce() };
+            if (started.status !== 'submitted') {
+                if (started.status === 'deferred' && !session.closed && !session.resetRequested
+                    && !session.currentTurnAbortController?.signal.aborted) {
+                    nextTurn.inboundHandoff = handoff ?? undefined;
+                    session.queue.unshift(nextTurn);
+                    inputDeferred = true;
+                }
+                preserveUnclaimedInput = inputDeferred || handoff?.phase === 'released';
+                clearStreaming(session.conversationId);
+                return;
+            }
+            let result = started.value;
             if (!result.interrupted
                 && !result.finalMessage
                 && result.exitCode
@@ -2385,7 +2460,7 @@ export async function main() {
                     : { kind: 'none', reason: result.interrupted ? 'interrupted' : session.currentTurnSilenced ? 'silent' : 'empty' };
             const record = {
                 version: 1, turnId: session.currentTurnId, conversationId: session.conversationId,
-                sourceMessageId: journaledInput ? nextTurn.sourceMessageId : null,
+                sourceMessageId: inboundId ? nextTurn.sourceMessageId : null,
                 nativeThreadId: result.threadId, createdAt: new Date().toISOString(), output,
                 audience: conversationCache.has(session.conversationId) ? {
                     memberIds: [...conversationCache.get(session.conversationId).memberIds].sort(),
@@ -2509,6 +2584,14 @@ export async function main() {
                 await deliverCompletedOutput(completedOutput);
         }
         catch (error) {
+            if (!nativeCompleted && inboundId && session.currentInboundHandoff?.phase !== 'submitted') {
+                // A store/preflight failure proves no native callback ran. The shared
+                // inbox can reoffer it; a generic failure reply is not completion proof.
+                preserveUnclaimedInput = session.currentInboundHandoff?.phase !== 'settled';
+                clearStreaming(session.conversationId);
+                console.error('[canon-codex] Native input awaits handoff recovery:', error);
+                return;
+            }
             if (nativeCompleted) {
                 session.state.lastError = completedOutput
                     ? 'Native work completed; its saved Canon output awaits delivery reconciliation.'
@@ -2557,9 +2640,28 @@ export async function main() {
         finally {
             if (completedOutput)
                 activeCompletedOutputs.delete(completedOutput.turnId);
+            const handoff = session.currentInboundHandoff;
+            if (!inputDeferred && handoff && handoff.phase !== 'submitted' && handoff.phase !== 'settled') {
+                preserveUnclaimedInput = true;
+                try {
+                    await handoff.release('native-preflight');
+                }
+                catch (error) {
+                    // Keep the existing queue/heartbeat as the local retry owner if the
+                    // durable release itself fails. Never silently discard the handle.
+                    if (!session.closed && !session.currentTurnAbortController?.signal.aborted) {
+                        nextTurn.inboundHandoff = handoff;
+                        session.queue.unshift(nextTurn);
+                        inputDeferred = true;
+                    }
+                    console.error('[canon-codex] Failed to release unsubmitted input:', error);
+                }
+            }
             session.currentTurnAbortController?.abort(new Error('Codex turn ended'));
             session.currentTurnAbortController = null;
-            recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
+            session.currentInboundHandoff = undefined;
+            if (!preserveUnclaimedInput)
+                recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
             stopVisibleWorkSignal(session);
             session.running = false;
             session.state.state = 'idle';
@@ -2575,35 +2677,11 @@ export async function main() {
             session.lastActivity = Date.now();
             writeState(session);
             writeTurn(session);
-            if (session.queue.length > 0) {
+            if (!inputDeferred && session.queue.length > 0) {
                 void runNextTurn(session);
             }
         }
     }
-    const acceptedInboundMessageIds = new Set();
-    const inFlightInboundMessageIds = new Set();
-    function claimInboundMessageId(messageId) {
-        if (!messageId)
-            return true;
-        if (acceptedInboundMessageIds.has(messageId) || inFlightInboundMessageIds.has(messageId))
-            return false;
-        inFlightInboundMessageIds.add(messageId);
-        return true;
-    }
-    function settleInboundMessageId(messageId, accepted) {
-        if (!messageId)
-            return;
-        inFlightInboundMessageIds.delete(messageId);
-        if (!accepted)
-            return;
-        acceptedInboundMessageIds.add(messageId);
-        while (acceptedInboundMessageIds.size > 2_048) {
-            const oldest = acceptedInboundMessageIds.values().next().value;
-            if (!oldest)
-                break;
-            acceptedInboundMessageIds.delete(oldest);
-        }
-    }
     const hostAvailableExecutionModes = serviceAgentMode
         ? ['locked']
         : [...EXECUTION_ENVIRONMENT_MODES];
@@ -2658,43 +2736,63 @@ export async function main() {
         }),
     });
     let runtimeDescriptor = buildCurrentRuntimeDescriptor();
+    let codexCatalogRevision = 0;
+    let refreshedCodexCatalogRevision = -1;
+    function invalidateCodexCatalog() {
+        codexCatalogRevision += 1;
+        codexModels = [];
+        codexSkills = [];
+        codexModelOptions = buildCodexModelOptions([], args.model);
+        codexEffortOptions = [];
+        codexDefaultModel = resolveCodexDefaultModel([], args.model);
+        codexDefaultEffort = null;
+        runtimeDescriptor = buildCurrentRuntimeDescriptor();
+    }
     async function refreshCodexSkillInventory(forceReload = false) {
         if (!useAppServer)
-            return;
+            return true;
+        const revision = codexCatalogRevision;
         const probe = new CodexAppServerAdapter({
             cwd: workingDir,
             codexBin,
             model: typeof args.model === 'string' ? args.model : null,
             configOverrides: args.config ?? [],
         });
+        let succeeded = true;
+        let models = [];
+        let skills = [];
         try {
-            const discoveredModels = await probe.listModels();
-            if (discoveredModels.length > 0) {
-                codexModels = discoveredModels;
-                codexModelOptions = buildCodexModelOptions(codexModels, args.model);
-                codexEffortOptions = buildCodexEffortOptions(codexModels);
-                codexDefaultModel = resolveCodexDefaultModel(codexModels, args.model);
-                codexDefaultEffort = resolveCodexEffortForModel({
-                    models: codexModels,
-                    model: codexDefaultModel,
-                    requestedEffort: configuredCodexEffort,
-                }).value;
-            }
+            models = await probe.listModels();
         }
         catch (error) {
+            succeeded = false;
             console.error('[canon-codex] Failed to load Codex models:', error instanceof Error ? error.message : error);
         }
         try {
-            codexSkills = await probe.listSkills({ forceReload });
+            skills = await probe.listSkills({ forceReload });
         }
         catch (error) {
-            codexSkills = [];
+            succeeded = false;
             console.error('[canon-codex] Failed to load Codex skills:', error instanceof Error ? error.message : error);
         }
         finally {
-            runtimeDescriptor = buildCurrentRuntimeDescriptor();
             probe.close();
         }
+        // An account change during discovery invalidates that probe's observations.
+        if (revision !== codexCatalogRevision)
+            return false;
+        codexModels = models;
+        codexSkills = skills;
+        codexModelOptions = buildCodexModelOptions(models, args.model);
+        codexEffortOptions = models.length ? buildCodexEffortOptions(models) : [];
+        codexDefaultModel = resolveCodexDefaultModel(models, args.model);
+        codexDefaultEffort = models.length ? resolveCodexEffortForModel({
+            models, model: codexDefaultModel, requestedEffort: configuredCodexEffort,
+        }).value : null;
+        runtimeDescriptor = buildCurrentRuntimeDescriptor();
+        if (succeeded)
+            refreshedCodexCatalogRevision = revision;
+        return succeeded;
     }
     async function handleControlSignal(event) {
         const { conversationId, type } = event;
@@ -2713,13 +2811,16 @@ export async function main() {
             return;
         }
         console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${type} signal`);
+        if (session.running) {
+            void session.currentInboundHandoff?.cancel('canceled-before-execution').catch(console.error);
+            session.currentTurnAbortController?.abort(new CodexTurnCanceledError(`Codex turn interrupted by ${type}`));
+        }
         if (type === 'stop_and_drop') {
             const droppedPrompts = session.queue.splice(0);
             await markQueuedPromptsRejected(conversationId, droppedPrompts);
             settleRejectedPromptCheckpoints(conversationId, droppedPrompts);
         }
         if (session.running) {
-            session.currentTurnAbortController?.abort(new Error(`Codex turn interrupted by ${type}`));
             await session.adapter.interrupt();
         }
         session.turnState = 'interrupted';
@@ -2780,6 +2881,15 @@ export async function main() {
         });
     };
     const refreshRuntimeDetails = async (signal) => {
+        // Reuse the heartbeat's serialized detail lane; no second polling loop.
+        if (refreshedCodexCatalogRevision !== codexCatalogRevision) {
+            const refreshed = await refreshCodexSkillInventory(true);
+            if (signal.aborted)
+                return;
+            // Failures retry on the existing heartbeat, not an immediate refresh loop.
+            if (refreshed)
+                runtimeHeartbeat.refresh();
+        }
         await refreshKnownConversationIds().catch((error) => {
             console.error('[canon-codex] Failed to refresh known conversations:', error);
         });
@@ -2796,6 +2906,11 @@ export async function main() {
         if (signal.aborted)
             return;
         const results = await Promise.allSettled(Array.from(knownConversationIds).map(async (conversationId) => {
+            const adapter = sessions.get(conversationId)?.adapter;
+            if (adapter instanceof CodexAppServerAdapter)
+                await adapter.refreshRuntimeFacts();
+            if (signal.aborted)
+                return;
             const descriptor = runtimeDescriptor.runtimeDescriptor;
             if (!descriptor)
                 return;
@@ -2839,17 +2954,19 @@ export async function main() {
                 await endpoint.setInboundState(event.id, 'settled', 'own-message');
                 return;
             }
-            if (!claimInboundMessageId(message.id))
+            const handoff = await endpoint.acquireInbound(event.id);
+            if (!handoff)
                 return;
             recoveryCheckpointsFor(payload.conversationId).track(message.id);
             if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
                 console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
-                recoveryCheckpointsFor(payload.conversationId).settle(message.id);
-                settleInboundMessageId(message.id, true);
-                await endpoint.setInboundState(`message:${payload.conversationId}:${message.id}`, 'settled', 'observe-only');
+                if (await handoff.settle('observe-only')) {
+                    recoveryCheckpointsFor(payload.conversationId).settle(message.id);
+                }
                 return;
             }
             await enqueueInboundMessage({
+                inboundHandoff: handoff,
                 conversationId: payload.conversationId,
                 message,
                 senderName: message.senderName || message.senderId,
@@ -2860,8 +2977,8 @@ export async function main() {
                 provenance: payload.provenance,
                 turnDispatch: payload.turnDispatch,
                 replyAuthority: payload.replyAuthority,
-            }).then(() => settleInboundMessageId(message.id, true), (error) => {
-                settleInboundMessageId(message.id, false);
+            }).catch(async (error) => {
+                await handoff.release('queue-failed');
                 console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Failed to queue inbound message:`, error instanceof Error ? error.message : error);
                 throw error;
             });
@@ -2877,7 +2994,7 @@ export async function main() {
                     data: payload });
             },
             onMessageDeleted: (payload) => {
-                removeQueuedPrompt(payload.conversationId, payload.messageId);
+                void removeQueuedPrompt(payload.conversationId, payload.messageId).catch(console.error);
             },
             onConversationUpdated: (payload) => {
                 handleConversationUpdated(payload);
@@ -2957,6 +3074,7 @@ export async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         for (const session of sessions.values()) {
+            void session.currentInboundHandoff?.release('host-shutdown').catch(console.error);
             session.currentTurnAbortController?.abort(new Error('Codex host shutting down'));
         }
         runtimeRequests.dispose();

package/dist/model-catalog.js

@@ -26,11 +26,15 @@ export function buildCodexModelOptions(models, configuredModel) {
         }
         return Number(right.isDefault) - Number(left.isDefault);
     });
-    const options = ordered.map((model) => ({
-        value: model.model,
-        label: model.displayName,
-        ...(model.description ? { description: model.description } : {}),
-    }));
+    const options = ordered.map((model) => {
+        const description = [model.description, model.inputModalities?.length
+                ? `Inputs: ${model.inputModalities.join(', ')}.` : undefined].filter(Boolean).join(' ');
+        return {
+            value: model.model,
+            label: model.displayName,
+            ...(description ? { description } : {}),
+        };
+    });
     if (configured && !options.some((option) => option.value === configured)) {
         options.push({ value: configured, label: configured });
     }

package/dist/runtime-status.d.ts

@@ -0,0 +1,16 @@
+import type { CanonRuntimeFact } from '@canonmsg/core';
+type RecordValue = Record<string, unknown>;
+/** Retain only operational availability, never account details or raw provider errors. */
+export declare class CodexRuntimeStatus {
+    private authenticated;
+    private limits;
+    private tools;
+    revision: number;
+    hasQuota(): boolean;
+    replaceQuota(snapshot: RecordValue): void;
+    private mergeQuota;
+    reset(): void;
+    observe(method: string, params: RecordValue): boolean;
+    facts(): CanonRuntimeFact[];
+}
+export {};

package/dist/runtime-status.js

@@ -0,0 +1,93 @@
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+/** Retain only operational availability, never account details or raw provider errors. */
+export class CodexRuntimeStatus {
+    authenticated = null;
+    limits = new Map();
+    tools = new Map();
+    revision = 0;
+    hasQuota() { return this.limits.size > 0; }
+    replaceQuota(snapshot) {
+        this.limits.clear();
+        const buckets = record(snapshot.rateLimitsByLimitId);
+        for (const limit of buckets ? Object.values(buckets) : [snapshot.rateLimits])
+            this.mergeQuota(limit);
+    }
+    mergeQuota(value) {
+        const limit = record(value);
+        if (!limit)
+            return;
+        const id = typeof limit.limitId === 'string' ? limit.limitId : 'default';
+        const state = { ...this.limits.get(id) };
+        for (const key of ['primary', 'secondary']) {
+            const used = record(limit[key])?.usedPercent;
+            if (typeof used === 'number' && Number.isFinite(used) && used >= 0)
+                state[key] = used;
+        }
+        if (typeof limit.spendControlReached === 'boolean')
+            state.spend = limit.spendControlReached;
+        if (typeof limit.rateLimitReachedType === 'string' && limit.rateLimitReachedType)
+            state.reason = limit.rateLimitReachedType;
+        if (Object.keys(state).length)
+            this.limits.set(id, state);
+    }
+    reset() {
+        this.revision += 1;
+        this.authenticated = null;
+        this.limits.clear();
+        this.tools.clear();
+    }
+    observe(method, params) {
+        if (method === 'account/updated') {
+            this.reset();
+            if (typeof params.authMode === 'string' && params.authMode)
+                this.authenticated = true;
+            else if (params.authMode === null)
+                this.authenticated = false;
+            return true;
+        }
+        if (method === 'account/rateLimits/updated') {
+            this.revision += 1;
+            this.mergeQuota(params.rateLimits);
+            return true;
+        }
+        if (method === 'mcpServer/startupStatus/updated') {
+            if (typeof params.name !== 'string' || !params.name)
+                return false;
+            if (params.status === 'failed') {
+                this.tools.set(params.name, params.failureReason === 'reauthenticationRequired' ? 'auth_needed' : 'failed');
+            }
+            else if (params.status === 'ready' || params.status === 'starting') {
+                this.tools.set(params.name, params.status);
+            }
+            else {
+                this.tools.delete(params.name);
+            }
+            return true;
+        }
+        return false;
+    }
+    facts() {
+        const facts = [];
+        if (this.authenticated !== null)
+            facts.push({
+                id: 'provider-auth', label: 'Provider authentication', group: 'account',
+                value: this.authenticated ? 'Authenticated' : 'No account reported',
+                tone: this.authenticated ? 'good' : 'neutral',
+            });
+        const limited = [...this.limits.values()].some(limit => (limit.primary ?? 0) >= 100 || (limit.secondary ?? 0) >= 100 || limit.spend || Boolean(limit.reason));
+        if (this.limits.size)
+            facts.push({
+                id: 'provider-limits', label: 'Provider limits', group: 'limits',
+                value: limited ? 'Usage limit reached' : 'Within reported usage limits',
+                tone: limited ? 'warning' : 'good',
+            });
+        const states = [...this.tools.values()];
+        if (states.includes('auth_needed') || states.includes('failed'))
+            facts.push({
+                id: 'provider-tools', label: 'Tool connections', group: 'connection',
+                value: states.includes('auth_needed') ? 'A tool connection needs sign-in' : 'A tool connection failed',
+                tone: 'warning',
+            });
+        return facts;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.32.2",
+  "version": "0.32.5",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -28,13 +28,14 @@
     "smoke": "node scripts/smoke-test.mjs",
     "smoke:attach": "node scripts/smoke-attach.mjs",
     "test": "vitest run",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "smoke:protocol": "node scripts/smoke-protocol.mjs"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^11.0.1",
+    "@canonmsg/agent-sdk": "^11.0.2",
     "@canonmsg/agent-tools": "^0.11.0",
-    "@canonmsg/coding-agent-host": "^0.9.0",
-    "@canonmsg/core": "^13.0.4",
+    "@canonmsg/coding-agent-host": "^0.10.0",
+    "@canonmsg/core": "^13.0.5",
     "@canonmsg/rich-cards": "^0.10.6",
     "ws": "^8.21.3"
   },

package/scripts/smoke-protocol.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Uses a temporary native home, no credentials, and never starts a model turn.
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CodexAppServerAdapter } from '../dist/app-server-adapter.js';
+import { detectCodexCliVersion } from '../dist/codex-cli-version.js';
+
+const codexBin = process.env.CODEX_BIN || 'codex';
+const expected = '0.155.1';
+const version = detectCodexCliVersion(codexBin);
+assert.equal(version.version, expected, `This compatibility smoke targets Codex ${expected}`);
+const home = await mkdtemp(join(tmpdir(), 'canon-codex-protocol-'));
+const originalHome = process.env.CODEX_HOME;
+process.env.CODEX_HOME = home;
+const adapter = new CodexAppServerAdapter({ cwd: home, codexBin });
+const timeout = setTimeout(() => { adapter.close(); console.error('Codex protocol smoke timed out'); process.exitCode = 1; }, 20_000);
+try {
+  const models = await adapter.listModels();
+  assert.ok(models.length > 0, 'Native model discovery returned no models');
+  assert.ok(models.every(model => model.model && Array.isArray(model.supportedReasoningEfforts)));
+  await adapter.listSkills();
+  const account = await adapter.requestAppServer('account/read', { refreshToken: false });
+  assert.equal(account.account, null, 'Smoke must use an unauthenticated temporary home');
+  console.log(JSON.stringify({ codex: version.version, protocol: 'app-server', initialization: 'passed', modelDiscovery: 'passed', skillDiscovery: 'passed', authenticated: false, modelTurnsStarted: 0 }));
+} finally {
+  clearTimeout(timeout);
+  adapter.close();
+  if (originalHome === undefined) delete process.env.CODEX_HOME;
+  else process.env.CODEX_HOME = originalHome;
+  await rm(home, { recursive: true, force: true });
+}