@canonmsg/codex-plugin 0.22.2 → 0.22.3

package/dist/adapter.d.ts

@@ -32,6 +32,10 @@ export type CodexEvent = {
         cached_input_tokens?: number;
         output_tokens?: number;
     };
+} | {
+    type: 'settings.updated';
+    model: string | null;
+    effort: string | null;
 } | {
     type: 'skills.changed';
 };

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

@@ -8,6 +8,19 @@ export interface CodexSkillMetadata {
     shortDescription?: string;
     displayName?: string;
 }
+export interface CodexReasoningEffortMetadata {
+    value: string;
+    description?: string;
+}
+export interface CodexModelMetadata {
+    id: string;
+    model: string;
+    displayName: string;
+    description?: string;
+    supportedReasoningEfforts: CodexReasoningEffortMetadata[];
+    defaultReasoningEffort?: string;
+    isDefault: boolean;
+}
 export declare class CodexAppServerAdapter {
     private readonly cwd;
     private readonly codexBin;
@@ -24,6 +37,7 @@ export declare class CodexAppServerAdapter {
     private threadId;
     private loadedThreadId;
     private resolvedModel;
+    private resolvedReasoningEffort;
     private currentTurnId;
     private requestSeq;
     private pending;
@@ -54,6 +68,8 @@ export declare class CodexAppServerAdapter {
         dynamicTools?: readonly JsonRecord[];
     });
     getThreadId(): string | null;
+    getResolvedModel(): string | null;
+    getResolvedReasoningEffort(): string | null;
     clearThreadId(): void;
     setModel(model: string | null): void;
     /**
@@ -78,7 +94,11 @@ export declare class CodexAppServerAdapter {
     private buildWritableRoots;
     listSkills(options?: {
         forceReload?: boolean;
+        requestTimeoutMs?: number;
     }): Promise<CodexSkillMetadata[]>;
+    listModels(options?: {
+        requestTimeoutMs?: number;
+    }): Promise<CodexModelMetadata[]>;
     private buildTurnInput;
     private ensureStarted;
     private handleLine;

package/dist/app-server-adapter.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
+const DEFAULT_DISCOVERY_REQUEST_TIMEOUT_MS = 5_000;
 export class CodexAppServerAdapter {
     cwd;
     codexBin;
@@ -16,6 +17,7 @@ export class CodexAppServerAdapter {
     threadId;
     loadedThreadId = null;
     resolvedModel = null;
+    resolvedReasoningEffort;
     currentTurnId = null;
     requestSeq = 1;
     pending = new Map();
@@ -37,6 +39,7 @@ export class CodexAppServerAdapter {
         this.codexBin = opts.codexBin ?? 'codex';
         this.model = opts.model ?? null;
         this.reasoningEffort = opts.reasoningEffort ?? null;
+        this.resolvedReasoningEffort = this.reasoningEffort;
         this.sandbox = opts.sandbox ?? null;
         this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.addDirs = opts.addDirs ?? [];
@@ -48,13 +51,21 @@ export class CodexAppServerAdapter {
     getThreadId() {
         return this.threadId;
     }
+    getResolvedModel() {
+        return this.resolvedModel ?? this.model;
+    }
+    getResolvedReasoningEffort() {
+        return this.resolvedReasoningEffort ?? this.reasoningEffort;
+    }
     clearThreadId() {
         this.threadId = null;
         this.loadedThreadId = null;
         this.resolvedModel = null;
+        this.resolvedReasoningEffort = this.reasoningEffort;
     }
     setModel(model) {
         this.model = model;
+        this.resolvedModel = model;
     }
     /**
      * Sets GPT reasoning effort, applied via model_reasoning_effort. The config
@@ -66,9 +77,10 @@ export class CodexAppServerAdapter {
      */
     setReasoningEffort(effort) {
         const next = effort && effort.trim() ? effort.trim() : null;
-        if (next === this.reasoningEffort)
+        if (next === this.reasoningEffort && next === this.resolvedReasoningEffort)
             return;
         this.reasoningEffort = next;
+        this.resolvedReasoningEffort = next;
         if (this.threadId && this.loadedThreadId === this.threadId) {
             this.loadedThreadId = null;
         }
@@ -200,7 +212,7 @@ export class CodexAppServerAdapter {
                 continue;
             config[key] = parseConfigValue(raw.slice(separator + 1));
         }
-        if (this.reasoningEffort && config.model_reasoning_effort === undefined) {
+        if (this.reasoningEffort) {
             config.model_reasoning_effort = this.reasoningEffort;
         }
         return Object.keys(config).length > 0 ? { config } : {};
@@ -249,11 +261,38 @@ export class CodexAppServerAdapter {
         const result = await this.sendRequest('skills/list', {
             cwds: [this.cwd],
             ...(options.forceReload ? { forceReload: true } : {}),
-        });
+        }, options.requestTimeoutMs ?? DEFAULT_DISCOVERY_REQUEST_TIMEOUT_MS);
         const parsed = parseSkillsListResponse(result);
         this.skillsCache = parsed;
         return parsed;
     }
+    async listModels(options = {}) {
+        await this.ensureStarted();
+        const models = [];
+        const seen = new Set();
+        const seenCursors = new Set();
+        let cursor = null;
+        do {
+            const result = await this.sendRequest('model/list', {
+                limit: 100,
+                includeHidden: false,
+                ...(cursor ? { cursor } : {}),
+            }, options.requestTimeoutMs ?? DEFAULT_DISCOVERY_REQUEST_TIMEOUT_MS);
+            for (const model of parseModelListResponse(result)) {
+                if (seen.has(model.model))
+                    continue;
+                seen.add(model.model);
+                models.push(model);
+            }
+            const nextCursor = readString(result, 'nextCursor') ?? null;
+            if (nextCursor && seenCursors.has(nextCursor))
+                break;
+            if (nextCursor)
+                seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        } while (cursor);
+        return models;
+    }
     async buildTurnInput(prompt, imagePaths) {
         const skillPrompt = parseSkillSlashPrompt(prompt);
         const input = [];
@@ -373,6 +412,25 @@ export class CodexAppServerAdapter {
         }
         if (!this.isCurrentThreadNotification(params))
             return;
+        if (method === 'thread/settings/updated') {
+            const settings = isRecord(params.threadSettings) ? params.threadSettings : {};
+            const model = readString(settings, 'model') ?? null;
+            const effort = readString(settings, 'effort') ?? null;
+            this.resolvedModel = model ?? this.resolvedModel;
+            this.resolvedReasoningEffort = effort;
+            this.currentOnEvent?.({ type: 'settings.updated', model, effort });
+            return;
+        }
+        if (method === 'model/rerouted') {
+            const model = readString(params, 'toModel') ?? null;
+            this.resolvedModel = model ?? this.resolvedModel;
+            this.currentOnEvent?.({
+                type: 'settings.updated',
+                model,
+                effort: this.getResolvedReasoningEffort(),
+            });
+            return;
+        }
         if (method === 'turn/started') {
             this.currentTurnId = readString(params.turn, 'id') ?? this.currentTurnId;
             this.currentOnEvent?.({ type: 'turn.started' });
@@ -518,15 +576,39 @@ export class CodexAppServerAdapter {
         this.messageTextByItem.clear();
         this.planText = '';
     }
-    sendRequest(method, params) {
+    sendRequest(method, params, timeoutMs) {
         const id = this.requestSeq++;
         return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
+            let timer = null;
+            const clearTimer = () => {
+                if (!timer)
+                    return;
+                clearTimeout(timer);
+                timer = null;
+            };
+            this.pending.set(id, {
+                resolve: (value) => {
+                    clearTimer();
+                    resolve(value);
+                },
+                reject: (error) => {
+                    clearTimer();
+                    reject(error);
+                },
+            });
+            if (timeoutMs !== undefined && timeoutMs > 0) {
+                timer = setTimeout(() => {
+                    if (!this.pending.delete(id))
+                        return;
+                    reject(new Error(`Codex app-server ${method} timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+            }
             try {
                 this.write({ id, method, params });
             }
             catch (error) {
                 this.pending.delete(id);
+                clearTimer();
                 reject(error);
             }
         });
@@ -619,6 +701,45 @@ function parseSkillsListResponse(result) {
     }
     return skills;
 }
+function parseModelListResponse(result) {
+    const entries = Array.isArray(result.data) ? result.data : [];
+    const models = [];
+    for (const entry of entries) {
+        if (!isRecord(entry) || entry.hidden === true)
+            continue;
+        const id = readString(entry, 'id');
+        const model = readString(entry, 'model') ?? id;
+        if (!id || !model)
+            continue;
+        const displayName = readString(entry, 'displayName') ?? model;
+        const description = readString(entry, 'description');
+        const efforts = Array.isArray(entry.supportedReasoningEfforts)
+            ? entry.supportedReasoningEfforts.flatMap((rawEffort) => {
+                if (!isRecord(rawEffort))
+                    return [];
+                const value = readString(rawEffort, 'reasoningEffort');
+                if (!value)
+                    return [];
+                const effortDescription = readString(rawEffort, 'description');
+                return [{
+                        value,
+                        ...(effortDescription ? { description: effortDescription } : {}),
+                    }];
+            })
+            : [];
+        const defaultReasoningEffort = readString(entry, 'defaultReasoningEffort');
+        models.push({
+            id,
+            model,
+            displayName,
+            ...(description ? { description } : {}),
+            supportedReasoningEfforts: efforts,
+            ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+            isDefault: entry.isDefault === true,
+        });
+    }
+    return models;
+}
 function stringifyPreview(value) {
     if (typeof value === 'string')
         return value;

package/dist/host.d.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { type CanonRuntimeCommandDescriptor, type CanonRuntimeDescriptor, type CanonRuntimePresentationPolicy, type ExecutionEnvironmentMode, type WorkspaceOption, type CanonWorkspaceRootMetadata } from '@canonmsg/core';
 import { type CodexSkillMetadata } from './app-server-adapter.js';
+import { type CodexControlOption } from './model-catalog.js';
 interface HostSessionState {
     lastError?: string;
     model?: string;
@@ -32,30 +33,14 @@ export declare function buildCodexLiveSessionConfig(input: {
     permissionMode?: string | undefined;
     model?: string | undefined;
 };
-/** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
-export declare const CODEX_EFFORT_OPTIONS: readonly [{
-    readonly value: "minimal";
-    readonly label: "Minimal";
-}, {
-    readonly value: "low";
-    readonly label: "Low";
-}, {
-    readonly value: "medium";
-    readonly label: "Medium";
-}, {
-    readonly value: "high";
-    readonly label: "High";
-}, {
-    readonly value: "xhigh";
-    readonly label: "Extra high";
-}];
+/** Conservative fallback used only when native app-server discovery is unavailable. */
+export declare const CODEX_EFFORT_OPTIONS: readonly CodexControlOption[];
 export declare const CODEX_SESSION_CONFIG_FIELDS: readonly ["permissionMode", "effort"];
 export declare function buildCodexSkillCommands(skills: ReadonlyArray<CodexSkillMetadata>): CanonRuntimeCommandDescriptor[];
 export declare function buildCodexRuntimeDescriptor(input: {
-    models: Array<{
-        value: string;
-        label: string;
-    }>;
+    models: CodexControlOption[];
+    effortOptions?: CodexControlOption[];
+    defaultEffort?: string | null;
     workspaces: WorkspaceOption[];
     workspaceRoots?: CanonWorkspaceRootMetadata[];
     executionModes: ExecutionEnvironmentMode[];

package/dist/host.js

@@ -9,7 +9,7 @@ import { captureTurnArtifactSnapshot, collectTurnArtifacts, } from '@canonmsg/co
 import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
-import { CodexAppServerAdapter } from './app-server-adapter.js';
+import { CodexAppServerAdapter, } from './app-server-adapter.js';
 import { CODEX_APP_DYNAMIC_TOOLS, deniedCodexAppToolResult, handleCodexAppToolCall, isCodexAppToolCall, } from './codex-app-tools.js';
 import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
@@ -21,6 +21,7 @@ import { createCodexControlPoller } from './control-channel.js';
 import { runCli } from './cli-entry.js';
 import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 import { applyTextSegmentBlock, beginCommandBlock, claimCommandBlock, createCommandBlockTracker, } from './turn-activity.js';
+import { FALLBACK_CODEX_EFFORT_OPTIONS, buildCodexEffortOptions, buildCodexModelOptions, readCodexConfiguredEffort, resolveCodexDefaultModel, resolveCodexEffortForModel, } from './model-catalog.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -88,15 +89,8 @@ let workingDir = process.cwd();
 let workspaceOptions = [];
 let workspaceRoots = [];
 let workspaceRootMetadata = [];
-/** GPT reasoning-effort levels, applied next turn via model_reasoning_effort. */
-export const CODEX_EFFORT_OPTIONS = [
-    { value: 'minimal', label: 'Minimal' },
-    { value: 'low', label: 'Low' },
-    { value: 'medium', label: 'Medium' },
-    { value: 'high', label: 'High' },
-    { value: 'xhigh', label: 'Extra high' },
-];
-const CODEX_EFFORT_VALUES = new Set(CODEX_EFFORT_OPTIONS.map((option) => option.value));
+/** Conservative fallback used only when native app-server discovery is unavailable. */
+export const CODEX_EFFORT_OPTIONS = FALLBACK_CODEX_EFFORT_OPTIONS;
 export const CODEX_SESSION_CONFIG_FIELDS = ['permissionMode', 'effort'];
 const MAX_CODEX_SKILL_COMMAND_CHOICES = 50;
 export function buildCodexSkillCommands(skills) {
@@ -176,8 +170,8 @@ export function buildCodexRuntimeDescriptor(input) {
         defaultPermissionMode: input.defaultPermissionMode,
         permissionModeLabel: 'Execution policy',
         modelLiveBehavior: 'next_turn',
-        effortOptions: [...CODEX_EFFORT_OPTIONS],
-        defaultEffort: 'medium',
+        effortOptions: input.effortOptions ?? [...CODEX_EFFORT_OPTIONS],
+        defaultEffort: input.defaultEffort ?? 'medium',
         effortLiveBehavior: 'next_turn',
         presentation: input.presentation,
         streamingTextMode: 'snapshot',
@@ -242,20 +236,6 @@ export function buildCodexTurnResponseRouting(input) {
 export function getCodexRequestingUserId(message) {
     return message.senderType === 'human' ? message.senderId : null;
 }
-function modelOptionLabel(model) {
-    if (/^gpt-5\.5(?:$|[-_:])/i.test(model))
-        return 'GPT-5.5';
-    if (/^gpt-5\.4-mini(?:$|[-_:])/i.test(model))
-        return 'GPT-5.4 Mini';
-    if (/^gpt-5\.4(?:$|[-_:])/i.test(model))
-        return 'GPT-5.4';
-    return model;
-}
-function buildCodexModelOptions(model) {
-    return typeof model === 'string' && model.trim()
-        ? [{ value: model.trim(), label: modelOptionLabel(model.trim()) }]
-        : [];
-}
 async function publishAgentRuntime(agentId, runtime) {
     await publishHostAgentRuntime(agentId, 'codex', runtime);
 }
@@ -1019,9 +999,13 @@ export async function main() {
                     throw new ExecutionEnvironmentError(modelGuard, modelGuard);
                 }
                 const storedThreadId = loadStoredThreadId(runtimeId, agentId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint);
-                const initialEffort = config?.effort && CODEX_EFFORT_VALUES.has(config.effort)
-                    ? config.effort
-                    : null;
+                const effectiveModel = policy.model ?? codexDefaultModel;
+                const initialEffortResolution = resolveCodexEffortForModel({
+                    models: codexModels,
+                    model: effectiveModel,
+                    requestedEffort: config?.effort ?? configuredCodexEffort,
+                });
+                const initialEffort = initialEffortResolution.value;
                 const adapter = useAppServer
                     ? new CodexAppServerAdapter({
                         cwd: sessionCwd,
@@ -1059,7 +1043,7 @@ export async function main() {
                     queue: [],
                     running: false,
                     state: buildCodexInitialSessionState({
-                        model: policy.model,
+                        model: effectiveModel ?? undefined,
                         permissionMode: policy.permissionMode,
                         effort: initialEffort,
                     }),
@@ -1577,6 +1561,13 @@ export async function main() {
                     void refreshCodexSkillInventory(true).then(() => publishRuntimeHeartbeat());
                     return;
                 }
+                if (event.type === 'settings.updated') {
+                    if (event.model)
+                        session.state.model = event.model;
+                    session.state.effort = event.effort ?? undefined;
+                    writeState(session);
+                    return;
+                }
                 if (event.type === 'message') {
                     session.turnState = 'streaming';
                     markTurnProgress(session);
@@ -1679,6 +1670,17 @@ export async function main() {
                 clearStoredThread();
                 result = await runTurnOnce();
             }
+            if (session.adapter instanceof CodexAppServerAdapter) {
+                const resolvedModel = session.adapter.getResolvedModel();
+                const resolvedEffort = session.adapter.getResolvedReasoningEffort();
+                if ((resolvedModel && resolvedModel !== session.state.model)
+                    || resolvedEffort !== (session.state.effort ?? null)) {
+                    if (resolvedModel)
+                        session.state.model = resolvedModel;
+                    session.state.effort = resolvedEffort ?? undefined;
+                    writeState(session);
+                }
+            }
             if (result.threadId && !session.resetRequested) {
                 saveStoredThreadId(runtimeId, agentId, session.conversationId, session.environment.baseCwd, result.threadId, session.environment.mode, session.policyFingerprint);
             }
@@ -1867,7 +1869,16 @@ export async function main() {
         ...EXECUTION_ENVIRONMENT_MODES,
     ];
     const codexPermissionEnvelope = deriveCodexPermissionEnvelope(args);
-    const codexModelOptions = buildCodexModelOptions(args.model);
+    const configuredCodexEffort = readCodexConfiguredEffort(args.config ?? []);
+    let codexModels = [];
+    let codexModelOptions = buildCodexModelOptions(codexModels, args.model);
+    let codexEffortOptions = buildCodexEffortOptions(codexModels);
+    let codexDefaultModel = resolveCodexDefaultModel(codexModels, args.model);
+    let codexDefaultEffort = resolveCodexEffortForModel({
+        models: codexModels,
+        model: codexDefaultModel,
+        requestedEffort: configuredCodexEffort,
+    }).value;
     const runtimePresentation = buildRuntimePresentationPolicy({
         base: DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION,
         preset: parseRuntimeVisibilityPreset(args['runtime-visibility']),
@@ -1877,7 +1888,7 @@ export async function main() {
     let codexSkills = [];
     const buildCurrentRuntimeDescriptor = () => ({
         defaultWorkspaceId: workspaceOptions[0]?.id,
-        ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
+        ...(codexDefaultModel ? { defaultModel: codexDefaultModel } : {}),
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         availableExecutionModes: hostAvailableExecutionModes,
         availablePermissionModes: [...codexPermissionEnvelope.availablePermissionModes],
@@ -1886,6 +1897,8 @@ export async function main() {
             : {}),
         runtimeDescriptor: buildCodexRuntimeDescriptor({
             models: codexModelOptions,
+            effortOptions: codexEffortOptions,
+            defaultEffort: codexDefaultEffort,
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
@@ -1908,16 +1921,32 @@ export async function main() {
             model: typeof args.model === 'string' ? args.model : null,
             configOverrides: args.config ?? [],
         });
+        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;
+            }
+        }
+        catch (error) {
+            console.error('[canon-codex] Failed to load Codex models:', error instanceof Error ? error.message : error);
+        }
         try {
             codexSkills = await probe.listSkills({ forceReload });
-            runtimeDescriptor = buildCurrentRuntimeDescriptor();
         }
         catch (error) {
             codexSkills = [];
-            runtimeDescriptor = buildCurrentRuntimeDescriptor();
             console.error('[canon-codex] Failed to load Codex skills:', error instanceof Error ? error.message : error);
         }
         finally {
+            runtimeDescriptor = buildCurrentRuntimeDescriptor();
             probe.close();
         }
     }
@@ -1925,7 +1954,13 @@ export async function main() {
         const session = sessions.get(conversationId);
         if (!session || session.closed)
             return;
+        let modelChanged = false;
         if (control.model && control.model !== session.state.model) {
+            if (codexModelOptions.length > 0 && !codexModelOptions.some((option) => option.value === control.model)) {
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring model outside the discovered Codex catalog (${control.model})`);
+                writeState(session);
+                return;
+            }
             const modelGuard = buildCodexModelGuardMessage(control.model, codexCliStatus);
             if (modelGuard) {
                 session.state.lastError = modelGuard;
@@ -1937,29 +1972,36 @@ export async function main() {
             }
             session.adapter.setModel(control.model);
             session.state.model = control.model;
+            modelChanged = true;
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Model set for next turn -> ${control.model}`);
-            writeState(session);
         }
         if (control.permissionMode) {
             console.error(`[canon-codex] [${conversationId.slice(0, 8)}] approval mode is session-creation-only; ignoring mid-session change request (${control.permissionMode})`);
             // Convergence contract: a consumed session control must always be
             // answered. Re-publish the currently applied state so clients settle on
             // the authoritative value instead of holding the composer until timeout.
-            writeState(session);
         }
-        if (control.effort) {
-            if (CODEX_EFFORT_VALUES.has(control.effort)) {
-                session.adapter.setReasoningEffort(control.effort);
-                session.state.effort = control.effort;
+        if (control.effort || modelChanged) {
+            const effortResolution = resolveCodexEffortForModel({
+                models: codexModels,
+                model: session.state.model,
+                requestedEffort: control.effort ?? session.state.effort,
+            });
+            if (effortResolution.value !== session.state.effort) {
+                session.adapter.setReasoningEffort(effortResolution.value);
+                session.state.effort = effortResolution.value ?? undefined;
+            }
+            if (control.effort && !effortResolution.accepted) {
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${control.effort} is unsupported by ${session.state.model ?? 'the active model'}; reset to ${effortResolution.value ?? 'the model default'}`);
+            }
+            else if (control.effort) {
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Reasoning effort set for next turn -> ${control.effort}`);
-                writeState(session);
             }
-            else {
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring unknown effort level (${control.effort})`);
-                // Same contract: ignored values still get an authoritative re-publish.
-                writeState(session);
+            else if (modelChanged && effortResolution.value) {
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Reasoning effort for ${session.state.model} -> ${effortResolution.value}`);
             }
         }
+        writeState(session);
     }
     async function handleControlSignal(event) {
         const { conversationId, type } = event;

package/dist/model-catalog.d.ts

@@ -0,0 +1,19 @@
+import type { CodexModelMetadata } from './app-server-adapter.js';
+export interface CodexControlOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export declare const FALLBACK_CODEX_EFFORT_OPTIONS: ReadonlyArray<CodexControlOption>;
+export declare function buildCodexModelOptions(models: ReadonlyArray<CodexModelMetadata>, configuredModel?: unknown): CodexControlOption[];
+export declare function buildCodexEffortOptions(models: ReadonlyArray<CodexModelMetadata>): CodexControlOption[];
+export declare function resolveCodexDefaultModel(models: ReadonlyArray<CodexModelMetadata>, configuredModel?: unknown): string | null;
+export declare function resolveCodexEffortForModel(input: {
+    models: ReadonlyArray<CodexModelMetadata>;
+    model: string | null | undefined;
+    requestedEffort: string | null | undefined;
+}): {
+    value: string | null;
+    accepted: boolean;
+};
+export declare function readCodexConfiguredEffort(configOverrides: ReadonlyArray<string>): string | null;

package/dist/model-catalog.js

@@ -0,0 +1,137 @@
+const EFFORT_LABELS = {
+    minimal: 'Minimal',
+    low: 'Low',
+    medium: 'Medium',
+    high: 'High',
+    xhigh: 'Extra high',
+    max: 'Max',
+    ultra: 'Ultra',
+};
+const EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export const FALLBACK_CODEX_EFFORT_OPTIONS = [
+    { value: 'minimal', label: 'Minimal' },
+    { value: 'low', label: 'Low' },
+    { value: 'medium', label: 'Medium' },
+    { value: 'high', label: 'High' },
+    { value: 'xhigh', label: 'Extra high' },
+];
+export function buildCodexModelOptions(models, configuredModel) {
+    const configured = typeof configuredModel === 'string' ? configuredModel.trim() : '';
+    const ordered = [...models].sort((left, right) => {
+        if (configured) {
+            if (left.model === configured)
+                return -1;
+            if (right.model === configured)
+                return 1;
+        }
+        return Number(right.isDefault) - Number(left.isDefault);
+    });
+    const options = ordered.map((model) => ({
+        value: model.model,
+        label: model.displayName,
+        ...(model.description ? { description: model.description } : {}),
+    }));
+    if (configured && !options.some((option) => option.value === configured)) {
+        options.push({ value: configured, label: configured });
+    }
+    return options;
+}
+export function buildCodexEffortOptions(models) {
+    if (models.length === 0)
+        return [...FALLBACK_CODEX_EFFORT_OPTIONS];
+    const values = new Set();
+    const descriptions = new Map();
+    for (const model of models) {
+        for (const effort of model.supportedReasoningEfforts) {
+            values.add(effort.value);
+            if (effort.description && !descriptions.has(effort.value)) {
+                descriptions.set(effort.value, effort.description);
+            }
+        }
+    }
+    return [...values]
+        .sort((left, right) => {
+        const leftIndex = EFFORT_ORDER.indexOf(left);
+        const rightIndex = EFFORT_ORDER.indexOf(right);
+        if (leftIndex === -1 && rightIndex === -1)
+            return left.localeCompare(right);
+        if (leftIndex === -1)
+            return 1;
+        if (rightIndex === -1)
+            return -1;
+        return leftIndex - rightIndex;
+    })
+        .map((value) => {
+        const description = buildEffortDescription(value, descriptions.get(value), models);
+        return {
+            value,
+            label: EFFORT_LABELS[value] ?? humanizeEffort(value),
+            ...(description ? { description } : {}),
+        };
+    });
+}
+export function resolveCodexDefaultModel(models, configuredModel) {
+    const configured = typeof configuredModel === 'string' ? configuredModel.trim() : '';
+    if (configured)
+        return configured;
+    return models.find((model) => model.isDefault)?.model ?? models[0]?.model ?? null;
+}
+export function resolveCodexEffortForModel(input) {
+    const requested = input.requestedEffort?.trim() || null;
+    const model = input.models.find((candidate) => candidate.model === input.model);
+    if (!model) {
+        const fallbackValues = new Set([
+            ...FALLBACK_CODEX_EFFORT_OPTIONS.map((option) => option.value),
+            ...input.models.flatMap((candidate) => (candidate.supportedReasoningEfforts.map((effort) => effort.value))),
+        ]);
+        if (!requested)
+            return { value: 'medium', accepted: true };
+        return fallbackValues.has(requested)
+            ? { value: requested, accepted: true }
+            : { value: 'medium', accepted: false };
+    }
+    const supported = new Set(model.supportedReasoningEfforts.map((effort) => effort.value));
+    const fallback = supported.has(model.defaultReasoningEffort ?? '')
+        ? model.defaultReasoningEffort ?? null
+        : model.supportedReasoningEfforts[0]?.value ?? null;
+    if (!requested)
+        return { value: fallback, accepted: true };
+    return supported.has(requested)
+        ? { value: requested, accepted: true }
+        : { value: fallback, accepted: false };
+}
+export function readCodexConfiguredEffort(configOverrides) {
+    let configured = null;
+    for (const raw of configOverrides) {
+        const separator = raw.indexOf('=');
+        if (separator <= 0 || raw.slice(0, separator).trim() !== 'model_reasoning_effort')
+            continue;
+        const value = raw.slice(separator + 1).trim();
+        if (!value)
+            continue;
+        configured = unquote(value);
+    }
+    return configured;
+}
+function humanizeEffort(value) {
+    return value
+        .replace(/[_-]+/g, ' ')
+        .replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function buildEffortDescription(effort, nativeDescription, models) {
+    const supportedBy = models.filter((model) => (model.supportedReasoningEfforts.some((candidate) => candidate.value === effort)));
+    const compatibility = supportedBy.length > 0 && supportedBy.length < models.length
+        ? `Supported by ${supportedBy.map((model) => model.displayName).join(', ')}.`
+        : '';
+    return [nativeDescription, compatibility].filter(Boolean).join(' ') || undefined;
+}
+function unquote(value) {
+    if (value.length >= 2) {
+        const first = value[0];
+        const last = value[value.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.22.2",
+  "version": "0.22.3",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",