@canonmsg/codex-plugin 0.32.2 → 0.32.3

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

@@ -36,6 +36,8 @@ interface Session {
         planMode?: boolean;
         intent: DeliveryIntent;
         sourceMessageId?: string | null;
+        /** A recovery gate rejected this input before any native execution. */
+        recoveryDeferred?: boolean;
         markAccepted?: boolean;
         imagePaths?: string[];
         mediaAddDirs?: string[];

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,10 @@ export async function main() {
         }
     }
     async function markQueuedPromptsRejected(conversationId, prompts) {
-        await Promise.all(prompts.map((prompt) => {
+        await Promise.all(prompts.map(async (prompt) => {
+            if (prompt.recoveryDeferred && prompt.sourceMessageId) {
+                await endpoint.setInboundState(`message:${conversationId}:${prompt.sourceMessageId}`, 'settled', 'canceled-before-execution');
+            }
             if (!prompt.markAccepted || !prompt.sourceMessageId)
                 return Promise.resolve();
             return client.updateMessageDisposition(conversationId, prompt.sourceMessageId, 'rejected').catch(() => { });
@@ -1260,6 +1267,13 @@ export async function main() {
         if (!session)
             return;
         session.closed = true;
+        // The local queue is going away, but never-started deferred input still
+        // belongs to the durable inbox. Release only that queue's dedupe ownership
+        // so an eligible reoffer can reconstruct it after eviction or removal.
+        for (const prompt of session.queue) {
+            if (prompt.recoveryDeferred && prompt.sourceMessageId)
+                acceptedInboundMessageIds.delete(prompt.sourceMessageId);
+        }
         session.currentTurnAbortController?.abort(new Error('Codex session closed'));
         session.currentTurnAbortController = null;
         stopVisibleWorkSignal(session);
@@ -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,
@@ -1571,6 +1589,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 +1655,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 +1670,7 @@ export async function main() {
                             writeCodexStreaming(session, null, 'waiting_input');
                         },
                     });
+                    requestSignal.throwIfAborted();
                     resumeTurnFromWaiting(session);
                     return successfulCodexAppToolResult(response);
                 }
@@ -1663,7 +1690,7 @@ export async function main() {
                         card: { ...card, cardId },
                         cardId,
                         expiresAt,
-                        turnId: session.currentTurnId ?? undefined,
+                        turnId: requestTurnId ?? undefined,
                     });
                     return successfulCodexAppToolResult({
                         status: 'sent',
@@ -1678,15 +1705,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 +1730,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 +1778,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 +1810,7 @@ export async function main() {
                         writeCodexStreaming(session, null, 'waiting_input');
                     },
                 });
+                requestSignal.throwIfAborted();
                 const response = cardResult.status === 'submitted'
                     ? {
                         status: 'submitted',
@@ -1797,11 +1830,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 +1852,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 +1887,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 +1913,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 +1921,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,7 +1935,7 @@ 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);
@@ -2058,7 +2094,7 @@ export async function main() {
                 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'));
+            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(() => { });
@@ -2116,6 +2152,8 @@ export async function main() {
         }
         const inboundId = nextTurn.sourceMessageId ? `message:${session.conversationId}:${nextTurn.sourceMessageId}` : null;
         let journaledInput = false;
+        let inputDeferred = false;
+        let preserveUnclaimedInput = false;
         let completedOutput;
         let nativeCompleted = false;
         session.state.lastError = undefined;
@@ -2217,6 +2255,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;
@@ -2509,6 +2551,33 @@ export async function main() {
                 await deliverCompletedOutput(completedOutput);
         }
         catch (error) {
+            if (!journaledInput && inboundId && error instanceof Error
+                && 'code' in error && error.code === 'SYNC_NOT_READY') {
+                // Recovery can be invalidated after the inbox offers an input. No
+                // native work has started: keep this same queued turn for the host
+                // heartbeat instead of publishing a failure or suppressing its retry
+                // through the accepted-message dedupe cache.
+                if (session.resetRequested || session.currentTurnAbortController?.signal.reason instanceof CodexTurnCanceledError) {
+                    await endpoint.setInboundState(inboundId, 'settled', 'canceled-before-execution');
+                }
+                else {
+                    preserveUnclaimedInput = true;
+                    if (!session.closed && !session.currentTurnAbortController?.signal.aborted) {
+                        nextTurn.recoveryDeferred = true;
+                        session.queue.unshift(nextTurn);
+                        inputDeferred = true;
+                    }
+                    else {
+                        // A closed/shutting-down session cannot retain the local queue.
+                        // Leave its durable offer available to the next live session.
+                        acceptedInboundMessageIds.delete(nextTurn.sourceMessageId);
+                    }
+                }
+                // The attempt may already have published its empty thinking row.
+                // With no native output there is nothing to hand off or salvage.
+                clearStreaming(session.conversationId);
+                return;
+            }
             if (nativeCompleted) {
                 session.state.lastError = completedOutput
                     ? 'Native work completed; its saved Canon output awaits delivery reconciliation.'
@@ -2559,7 +2628,8 @@ export async function main() {
                 activeCompletedOutputs.delete(completedOutput.turnId);
             session.currentTurnAbortController?.abort(new Error('Codex turn ended'));
             session.currentTurnAbortController = null;
-            recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
+            if (!preserveUnclaimedInput)
+                recoveryCheckpointsFor(session.conversationId).settle(nextTurn.sourceMessageId);
             stopVisibleWorkSignal(session);
             session.running = false;
             session.state.state = 'idle';
@@ -2575,7 +2645,7 @@ 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);
             }
         }
@@ -2658,43 +2728,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 +2803,15 @@ export async function main() {
             return;
         }
         console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${type} signal`);
+        if (session.running) {
+            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 +2872,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 +2897,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;

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.3",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,8 @@
     "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",

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 });
+}