@canonmsg/claude-code-plugin 0.21.0 → 0.21.2

package/dist/host.js

@@ -36,8 +36,8 @@ import { ApprovalManager, readHostSessionConfig, resolveHostWorkspaceCwd, } from
 import { runCli } from './cli-entry.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
-import { claudeThinkingToFlagValue, claudeThinkingToConfig, parseClaudeSessionDefaults, parseClaudeThinkingMode, parseClaudeUltracodeMode, resolveEffectiveSessionSettings, } from './session-defaults.js';
+import { applyClaudeSessionControl, buildClaudeFinalMessageId, buildClaudeInitialSessionState, claudeModelInfoToOption, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, normalizeClaudeEffortLevel, parseClaudePermissionMode, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { claudeThinkingToConfig, parseClaudeSessionDefaults, resolveEffectiveSessionSettings, } from './session-defaults.js';
 import { mapClaudeSubagentActivity } from './subagent-activity.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
@@ -295,26 +295,6 @@ function buildClaudeRuntimeDescriptor(input) {
         commands,
     });
 }
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_OPTIONS.map((option) => option.value));
-function parseClaudePermissionMode(value) {
-    if (value === 'acceptEdits'
-        || value === 'auto'
-        || value === 'bypassPermissions'
-        || value === 'default'
-        || value === 'dontAsk'
-        || value === 'plan') {
-        return value;
-    }
-    return null;
-}
-function normalizeClaudeEffortLevel(value) {
-    return typeof value === 'string' && CLAUDE_EFFORT_VALUES.has(value)
-        ? value
-        : undefined;
-}
-async function applyClaudeEffortLevel(q, effort) {
-    await q.applyFlagSettings({ effortLevel: effort });
-}
 let cachedClaudeCliPath;
 // The SDK bundles a Bun-compiled `claude` Mach-O binary next to
 // claude-agent-sdk-darwin-arm64. On some macOS setups that exact binary gets
@@ -351,11 +331,20 @@ function resolveClaudeCliPath() {
     console.error('[canon-host] claude CLI not on PATH; using SDK-bundled binary');
     return undefined;
 }
+const CLAUDE_SUPPLEMENTAL_MODEL_PROBES = ['opus'];
+function mergeModelOptions(...groups) {
+    const byValue = new Map();
+    for (const group of groups) {
+        for (const option of group) {
+            if (!byValue.has(option.value)) {
+                byValue.set(option.value, option);
+            }
+        }
+    }
+    return [...byValue.values()];
+}
 function toModelOptions(models) {
-    return models.map((model) => ({
-        value: model.value,
-        label: model.displayName,
-    }));
+    return models.map(claudeModelInfoToOption);
 }
 async function publishAgentRuntime(port, runtime) {
     await port.publishHostAgentRuntime({
@@ -395,6 +384,21 @@ function resolveExecutionFallbackReason(environment) {
         : environment.reason;
 }
 async function detectRuntimeModels(cwd) {
+    const discovered = await detectRuntimeModelsForSelection(cwd, 'default');
+    const supplemental = await Promise.all(CLAUDE_SUPPLEMENTAL_MODEL_PROBES.map(async (model) => {
+        try {
+            const options = await detectRuntimeModelsForSelection(cwd, model);
+            const option = options.find((entry) => entry.value === model);
+            return option && !isClaudeCustomModelOption(option) ? [option] : [];
+        }
+        catch (error) {
+            console.error(`[canon-host] Supplemental Claude model probe failed for ${model}:`, error);
+            return [];
+        }
+    }));
+    return mergeModelOptions(discovered, ...supplemental);
+}
+async function detectRuntimeModelsForSelection(cwd, model) {
     const emptyPrompt = {
         async *[Symbol.asyncIterator]() { },
     };
@@ -404,6 +408,7 @@ async function detectRuntimeModels(cwd) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
+            model,
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -431,6 +436,7 @@ async function inspectClaudeRuntimeMetadata(cwd, activeQuery) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
+            model: 'default',
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -871,6 +877,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
     const queryOptions = {
         systemPrompt: { type: 'preset', preset: 'claude_code' },
         tools: { type: 'preset', preset: 'claude_code' },
+        model: config.model ?? 'default',
         permissionMode: parseClaudePermissionMode(config.permissionMode) ?? 'default',
         allowDangerouslySkipPermissions: true,
         cwd,
@@ -1092,16 +1099,16 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         cwd,
         environment,
         query: q,
+        controlApplySeq: new Map(),
         sendInput,
         enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, artifactRoutingMode),
-        state: {
-            model: undefined,
+        state: buildClaudeInitialSessionState({
+            model: config.model,
             permissionMode: config.permissionMode,
-            effort: undefined,
+            effort: config.effort,
             fallbackModel: config.sessionSettings.fallbackModel,
             runtimeControlValues: config.sessionSettings.runtimeControlValues,
-            state: 'idle',
-        },
+        }),
         availableModels: config.availableModels,
         streamingText: '',
         streamingTimer: null,
@@ -1140,12 +1147,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         capabilities: CLAUDE_RUNTIME_CAPABILITIES,
         fallbackTurnId: `claude-${conversationId}`,
         streamingThrottleMs: STREAMING_THROTTLE_MS,
-        requestedControls: {
-            model: config.model,
-            permissionMode: config.permissionMode,
-            effort: config.effort,
-            runtimeControlValues: config.sessionSettings.runtimeControlValues,
-        },
+        requestedControls: {},
     }, {
         session: () => session,
         port,
@@ -1161,6 +1163,9 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         formatControlError: formatClaudeControlError,
     });
     const { streamingOutput, flushStreaming, onStreamDelta, clearStreaming, getFinalTurnTrail, writeState, writeTurn, setRuntimeControlError, clearRuntimeControlError, refreshVisibleWorkSignal, startVisibleWorkSignal, stopVisibleWorkSignal, } = writers;
+    // Initial values come from persisted session config and are effective for
+    // this query. Publish immediately so controls do not linger as requested.
+    writeState();
     function isActiveTurnInterrupted() {
         const turnKey = session.activeInput?.turnKey;
         return Boolean(turnKey && session.interruptedTurnKeys.has(turnKey));
@@ -1485,24 +1490,6 @@ function createSession(conversationId, environment, agentId, port, typingSignals
     const init = async () => {
         processMessages().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] processMessages crashed:`, err));
         await q.initializationResult();
-        if (config.model) {
-            try {
-                await q.setModel(config.model);
-                session.state.model = config.model;
-            }
-            catch (err) {
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial model:`, err);
-            }
-        }
-        if (config.effort) {
-            try {
-                await applyClaudeEffortLevel(q, config.effort);
-                session.state.effort = config.effort;
-            }
-            catch (err) {
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial effort:`, err);
-            }
-        }
         if (!resumeSessionId) {
             // New session — send seed message to activate streaming input mode
             sendInput(createClaudeInputEnvelope({
@@ -1517,16 +1504,22 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                 },
             }));
         }
-        // Refresh the canonical runtime descriptor after Claude reports supported models.
+        // Refresh the canonical runtime descriptor from a neutral probe. The live
+        // session may be initialized with a selected model, which can narrow the
+        // SDK's cached model list.
         try {
-            const models = await q.supportedModels();
-            const modelList = mergeClaudeModelOptions({
-                previous: runtimeModels,
-                next: toModelOptions(models),
+            const discoveredModels = await detectRuntimeModels(cwd).catch((error) => {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Model discovery failed:`, error);
+                return runtimeModels;
+            });
+            if (discoveredModels.length > 0) {
+                runtimeModels = discoveredModels;
+            }
+            const modelList = resolveClaudeModelOptions({
+                discovered: runtimeModels,
                 selectedModel: session.state.model,
             });
             session.availableModels = modelList;
-            runtimeModels = modelList;
             onRuntimeDescriptorUpdate({
                 defaultWorkspaceId: workspaceOptions[0]?.id,
                 defaultModel: config.sessionSettings.model ?? modelList[0]?.value,
@@ -1544,7 +1537,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                 }),
             });
             writeState();
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Models: ${models.map((m) => m.displayName).join(', ')}`);
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Models: ${modelList.map((m) => m.label).join(', ')}`);
         }
         catch {
             writeState();
@@ -1702,31 +1695,12 @@ export async function main() {
         refreshFloorMs: HEARTBEAT_MS,
     }, { port });
     const { conversationCache, knownConversationIds, getConversationMeta, refreshKnownConversationIds, handleConversationUpdated, markGroupContextModeUsed, loadHydratedInboundContext, } = directory;
-    const publishRuntimeHeartbeat = async () => {
-        heartbeatLocalRuntimeEntry(runtimeId, {
-            agentId,
-            agentName: profileAgentName,
-            cwd: workingDir,
-            baseCwd: workingDir,
-        });
-        if (!streamConnected)
+    const publishSessionSnapshotsForConversations = async (conversationIds) => {
+        const ids = Array.from(new Set(conversationIds));
+        if (!streamConnected || ids.length === 0)
             return;
-        await refreshKnownConversationIds().catch((error) => {
-            console.error('[canon-host] Failed to refresh known conversations:', error);
-        });
-        const activeSessionQuery = sessions.values().next().value?.query ?? null;
-        const metadata = await refreshClaudeRuntimeMetadata({
-            cwd: workingDir,
-            activeQuery: activeSessionQuery,
-        }).catch((error) => {
-            console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
-            return runtimeMetadata;
-        });
-        await publishAgentRuntime(port, runtimeDescriptor).catch((error) => {
-            console.error('[canon-host] Failed to publish agent runtime:', error);
-        });
         await port.publishHostSessionSnapshots({
-            conversationIds: Array.from(knownConversationIds),
+            conversationIds: ids,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
             workspaceOptions: workspaceOptions.map(({ id, cwd }) => ({ id, cwd })),
@@ -1752,6 +1726,31 @@ export async function main() {
         }).catch((error) => {
             console.error('[canon-host] Failed to publish session snapshots:', error);
         });
+    };
+    const publishRuntimeHeartbeat = async () => {
+        heartbeatLocalRuntimeEntry(runtimeId, {
+            agentId,
+            agentName: profileAgentName,
+            cwd: workingDir,
+            baseCwd: workingDir,
+        });
+        if (!streamConnected)
+            return;
+        await refreshKnownConversationIds().catch((error) => {
+            console.error('[canon-host] Failed to refresh known conversations:', error);
+        });
+        const activeSessionQuery = sessions.values().next().value?.query ?? null;
+        const metadata = await refreshClaudeRuntimeMetadata({
+            cwd: workingDir,
+            activeQuery: activeSessionQuery,
+        }).catch((error) => {
+            console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
+            return runtimeMetadata;
+        });
+        await publishAgentRuntime(port, runtimeDescriptor).catch((error) => {
+            console.error('[canon-host] Failed to publish agent runtime:', error);
+        });
+        await publishSessionSnapshotsForConversations(knownConversationIds);
         // Rebuild so the descriptor picks up native slash commands from the
         // metadata refresh above — the initial descriptor is built before the
         // command inventory has loaded.
@@ -2373,105 +2372,19 @@ export async function main() {
         },
     });
     // ── Control signal watcher ──
-    // Session control signals (model, mode, effort). A missing/closed session
-    // leaves the node in place; lastSeen still advances, so a stale control is
-    // never replayed once a session exists.
+    // Session control signals (model, mode, effort). The bridge has already
+    // consumed the control notification, so every path must publish an answer.
     async function applyRuntimeSessionControl(event) {
         const convoId = event.conversationId;
         const session = sessions.get(convoId);
-        if (!session || session.closed)
-            return { consume: false };
+        if (!session || session.closed) {
+            console.error(`[canon-host] [${convoId.slice(0, 8)}] Control received without live session; publishing persisted snapshot`);
+            void publishSessionSnapshotsForConversations([convoId]);
+            return;
+        }
         const ctrl = event.control;
         console.error(`[canon-host] [${convoId.slice(0, 8)}] Control:`, ctrl);
-        if (ctrl.model && ctrl.model !== session.state.model) {
-            try {
-                await session.query.setModel(ctrl.model);
-                session.state.model = ctrl.model;
-                session.clearRuntimeControlError('model');
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Model → ${ctrl.model}`);
-            }
-            catch (err) {
-                session.setRuntimeControlError('model', ctrl.model, err);
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set model:`, err);
-            }
-        }
-        const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
-        if (ctrl.permissionMode && !nextPermissionMode) {
-            session.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
-            console.error(`[canon-host] [${convoId.slice(0, 8)}] Unsupported mode: ${ctrl.permissionMode}`);
-        }
-        else if (nextPermissionMode && nextPermissionMode !== session.state.permissionMode) {
-            try {
-                await session.query.setPermissionMode(nextPermissionMode);
-                session.state.permissionMode = nextPermissionMode;
-                session.clearRuntimeControlError('permissionMode');
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Mode → ${nextPermissionMode}`);
-            }
-            catch (err) {
-                session.setRuntimeControlError('permissionMode', nextPermissionMode, err);
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set mode:`, err);
-            }
-        }
-        const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
-        if (nextEffort && nextEffort !== session.state.effort) {
-            try {
-                await applyClaudeEffortLevel(session.query, nextEffort);
-                session.state.effort = nextEffort;
-                session.clearRuntimeControlError('effort');
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Effort → ${nextEffort}`);
-            }
-            catch (err) {
-                session.setRuntimeControlError('effort', nextEffort, err);
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set effort:`, err);
-            }
-        }
-        else if (ctrl.effort && !nextEffort) {
-            session.setRuntimeControlError('effort', String(ctrl.effort), new Error('Unsupported Claude thinking level.'));
-        }
-        const runtimeControlValues = ctrl.runtimeControlValues ?? {};
-        if ('thinking' in runtimeControlValues) {
-            const nextThinking = parseClaudeThinkingMode(runtimeControlValues.thinking);
-            if (!nextThinking) {
-                session.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
-            }
-            else if (nextThinking !== session.state.runtimeControlValues?.thinking) {
-                try {
-                    await session.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) });
-                    session.state.runtimeControlValues = {
-                        ...(session.state.runtimeControlValues ?? {}),
-                        thinking: nextThinking,
-                    };
-                    session.clearRuntimeControlError('thinking');
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Thinking → ${nextThinking}`);
-                }
-                catch (err) {
-                    session.setRuntimeControlError('thinking', nextThinking, err);
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set thinking:`, err);
-                }
-            }
-        }
-        if ('ultracode' in runtimeControlValues) {
-            const nextUltracode = parseClaudeUltracodeMode(runtimeControlValues.ultracode);
-            if (!nextUltracode) {
-                session.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
-            }
-            else if (nextUltracode !== session.state.runtimeControlValues?.ultracode) {
-                try {
-                    await session.query.applyFlagSettings({ ultracode: nextUltracode === 'on' });
-                    session.state.runtimeControlValues = {
-                        ...(session.state.runtimeControlValues ?? {}),
-                        ultracode: nextUltracode,
-                    };
-                    session.clearRuntimeControlError('ultracode');
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Ultracode → ${nextUltracode}`);
-                }
-                catch (err) {
-                    session.setRuntimeControlError('ultracode', nextUltracode, err);
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set ultracode:`, err);
-                }
-            }
-        }
-        session.writeState();
+        applyClaudeSessionControl(session, ctrl);
     }
     // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──
     lifecycle.startTimers();

package/dist/session-defaults.d.ts

@@ -18,6 +18,7 @@ export interface ClaudeSessionControlValues {
 export interface ClaudeEffectiveSessionSettings extends ClaudeSessionDefaults {
     runtimeControlValues: Record<string, string>;
 }
+export declare const CLAUDE_EFFORT_LEVELS: readonly ClaudeEffortLevel[];
 export declare function parseClaudeThinkingMode(value: unknown): ClaudeThinkingMode | undefined;
 export declare function parseClaudeUltracodeMode(value: unknown): ClaudeUltracodeMode | undefined;
 export declare function parseClaudeSessionDefaults(raw: unknown): ClaudeSessionDefaults;

package/dist/session-defaults.js

@@ -1,4 +1,5 @@
-const CLAUDE_EFFORT_VALUES = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
 function optionalString(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/session-state.d.ts

@@ -1,6 +1,8 @@
-import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { Query, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core/contract';
 import type { TurnArtifactSnapshot } from '@canonmsg/agent-host';
+import { type ClaudeEffortLevel } from './session-defaults.js';
+export type { ClaudeEffortLevel } from './session-defaults.js';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
@@ -19,6 +21,47 @@ export interface ClaudeRuntimeControlError {
     message: string;
     updatedAt: number;
 }
+export type ClaudePermissionMode = Parameters<Query['setPermissionMode']>[0];
+export interface ClaudeSessionControl {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    runtimeControlValues?: Record<string, string>;
+    updatedAt?: number;
+    updatedBy?: string;
+}
+export interface ClaudeHostSessionState {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    fallbackModel?: string;
+    runtimeControlValues?: Record<string, string>;
+    state?: 'idle' | 'running' | 'requires_action';
+    contextUsage?: {
+        percentage: number;
+        totalTokens: number;
+        maxTokens: number;
+    };
+}
+export declare function parseClaudePermissionMode(value: unknown): ClaudePermissionMode | null;
+export declare function normalizeClaudeEffortLevel(value: unknown): ClaudeEffortLevel | undefined;
+export declare function buildClaudeInitialSessionState(input: {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    fallbackModel?: string;
+    runtimeControlValues?: Record<string, string>;
+}): ClaudeHostSessionState;
+export interface ClaudeSessionControlTarget {
+    state: ClaudeHostSessionState;
+    controlApplySeq: Map<string, number>;
+    closed: boolean;
+    query: Pick<Query, 'setModel' | 'setPermissionMode' | 'applyFlagSettings'>;
+    writeState: () => void;
+    setRuntimeControlError: (controlId: string, value: string, error: unknown) => void;
+    clearRuntimeControlError: (controlId: string) => void;
+}
+export declare function applyClaudeSessionControl(target: ClaudeSessionControlTarget, ctrl: ClaudeSessionControl): void;
 export interface ClaudePendingFinalDelivery {
     turnKey: string;
     text: string;
@@ -60,9 +103,15 @@ export declare function shouldDeliverClaudeFinal(input: {
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
-export declare function mergeClaudeModelOptions(input: {
-    previous: ReadonlyArray<ModelOption>;
-    next: ReadonlyArray<ModelOption>;
+export interface ClaudeModelInfoLike {
+    value: string;
+    displayName: string;
+    description?: string;
+}
+export declare function claudeModelInfoToOption(model: ClaudeModelInfoLike): ModelOption;
+export declare function isClaudeCustomModelOption(option: ModelOption | null | undefined): boolean;
+export declare function resolveClaudeModelOptions(input: {
+    discovered: ReadonlyArray<ModelOption>;
     selectedModel?: string | null;
 }): ModelOption[];
 export declare function formatClaudeControlError(error: unknown): string;

package/dist/session-state.js

@@ -1,4 +1,173 @@
 import { createHash, randomUUID } from 'node:crypto';
+import { CLAUDE_EFFORT_LEVELS, claudeThinkingToFlagValue, parseClaudeThinkingMode, parseClaudeUltracodeMode, } from './session-defaults.js';
+const CLAUDE_PERMISSION_MODE_VALUES = new Set([
+    'acceptEdits',
+    'auto',
+    'bypassPermissions',
+    'default',
+    'dontAsk',
+    'plan',
+]);
+const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
+export function parseClaudePermissionMode(value) {
+    return typeof value === 'string' && CLAUDE_PERMISSION_MODE_VALUES.has(value)
+        ? value
+        : null;
+}
+export function normalizeClaudeEffortLevel(value) {
+    return typeof value === 'string' && CLAUDE_EFFORT_VALUES.has(value)
+        ? value
+        : undefined;
+}
+export function buildClaudeInitialSessionState(input) {
+    return {
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
+        ...(input.effort ? { effort: input.effort } : {}),
+        ...(input.fallbackModel ? { fallbackModel: input.fallbackModel } : {}),
+        ...(input.runtimeControlValues ? { runtimeControlValues: input.runtimeControlValues } : {}),
+        state: 'idle',
+    };
+}
+function nextControlApplySeq(target, controlId) {
+    const nextSeq = (target.controlApplySeq.get(controlId) ?? 0) + 1;
+    target.controlApplySeq.set(controlId, nextSeq);
+    return nextSeq;
+}
+function applyOptimisticControl(input) {
+    const seq = nextControlApplySeq(input.target, input.controlId);
+    const applyPromise = (async () => input.apply())();
+    void applyPromise
+        .catch((error) => {
+        if (input.target.closed || input.target.controlApplySeq.get(input.controlId) !== seq) {
+            return;
+        }
+        input.revert();
+        input.target.setRuntimeControlError(input.controlId, input.value, error);
+    });
+}
+function setRuntimeControlValue(state, controlId, value) {
+    state.runtimeControlValues = {
+        ...(state.runtimeControlValues ?? {}),
+        [controlId]: value,
+    };
+}
+export function applyClaudeSessionControl(target, ctrl) {
+    const nextModel = typeof ctrl.model === 'string' && ctrl.model.trim() ? ctrl.model.trim() : null;
+    if (ctrl.model !== undefined && !nextModel) {
+        target.setRuntimeControlError('model', String(ctrl.model), new Error('Unsupported Claude model.'));
+    }
+    else if (nextModel && nextModel !== target.state.model) {
+        const previous = target.state.model;
+        target.state.model = nextModel;
+        target.clearRuntimeControlError('model');
+        applyOptimisticControl({
+            target,
+            controlId: 'model',
+            value: nextModel,
+            apply: () => target.query.setModel(nextModel),
+            revert: () => {
+                if (previous === undefined)
+                    delete target.state.model;
+                else
+                    target.state.model = previous;
+            },
+        });
+    }
+    const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
+    if (ctrl.permissionMode !== undefined && !nextPermissionMode) {
+        target.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
+    }
+    else if (nextPermissionMode && nextPermissionMode !== target.state.permissionMode) {
+        // Claude Code applies permission-mode changes asynchronously. We publish
+        // the requested value immediately so Canon does not show a stale "requested"
+        // state while the SDK catches up, then revert if the current apply fails.
+        const previous = target.state.permissionMode;
+        target.state.permissionMode = nextPermissionMode;
+        target.clearRuntimeControlError('permissionMode');
+        applyOptimisticControl({
+            target,
+            controlId: 'permissionMode',
+            value: nextPermissionMode,
+            apply: () => target.query.setPermissionMode(nextPermissionMode),
+            revert: () => {
+                if (previous === undefined)
+                    delete target.state.permissionMode;
+                else
+                    target.state.permissionMode = previous;
+            },
+        });
+    }
+    const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
+    if (nextEffort && nextEffort !== target.state.effort) {
+        const previous = target.state.effort;
+        target.state.effort = nextEffort;
+        target.clearRuntimeControlError('effort');
+        applyOptimisticControl({
+            target,
+            controlId: 'effort',
+            value: nextEffort,
+            apply: () => target.query.applyFlagSettings({ effortLevel: nextEffort }),
+            revert: () => {
+                if (previous === undefined)
+                    delete target.state.effort;
+                else
+                    target.state.effort = previous;
+            },
+        });
+    }
+    else if (ctrl.effort !== undefined && !nextEffort) {
+        target.setRuntimeControlError('effort', String(ctrl.effort), new Error('Unsupported Claude thinking level.'));
+    }
+    const runtimeControlValues = ctrl.runtimeControlValues ?? {};
+    if ('thinking' in runtimeControlValues) {
+        const nextThinking = parseClaudeThinkingMode(runtimeControlValues.thinking);
+        if (!nextThinking) {
+            target.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
+        }
+        else if (nextThinking !== target.state.runtimeControlValues?.thinking) {
+            const previous = target.state.runtimeControlValues?.thinking;
+            setRuntimeControlValue(target.state, 'thinking', nextThinking);
+            target.clearRuntimeControlError('thinking');
+            applyOptimisticControl({
+                target,
+                controlId: 'thinking',
+                value: nextThinking,
+                apply: () => target.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) }),
+                revert: () => {
+                    if (previous === undefined)
+                        delete target.state.runtimeControlValues?.thinking;
+                    else
+                        setRuntimeControlValue(target.state, 'thinking', previous);
+                },
+            });
+        }
+    }
+    if ('ultracode' in runtimeControlValues) {
+        const nextUltracode = parseClaudeUltracodeMode(runtimeControlValues.ultracode);
+        if (!nextUltracode) {
+            target.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
+        }
+        else if (nextUltracode !== target.state.runtimeControlValues?.ultracode) {
+            const previous = target.state.runtimeControlValues?.ultracode;
+            setRuntimeControlValue(target.state, 'ultracode', nextUltracode);
+            target.clearRuntimeControlError('ultracode');
+            applyOptimisticControl({
+                target,
+                controlId: 'ultracode',
+                value: nextUltracode,
+                apply: () => target.query.applyFlagSettings({ ultracode: nextUltracode === 'on' }),
+                revert: () => {
+                    if (previous === undefined)
+                        delete target.state.runtimeControlValues?.ultracode;
+                    else
+                        setRuntimeControlValue(target.state, 'ultracode', previous);
+                },
+            });
+        }
+    }
+    target.writeState();
+}
 export function createClaudeInputEnvelope(input) {
     const sourceMessageId = input.sourceMessageId ?? null;
     const fallbackId = randomUUID();
@@ -46,32 +215,45 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
-export function mergeClaudeModelOptions(input) {
+function normalizeModelDescription(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function displayLabelWithClaudeVersion(input) {
+    const label = input.displayName.trim() || input.value;
+    const description = normalizeModelDescription(input.description);
+    if (!description || label.includes('(') || /\d/.test(label))
+        return label;
+    const [summary] = description.split('·');
+    const versionedLabel = summary?.trim();
+    return versionedLabel
+        && versionedLabel.toLowerCase().startsWith(label.toLowerCase())
+        && /\d/.test(versionedLabel)
+        ? versionedLabel
+        : label;
+}
+export function claudeModelInfoToOption(model) {
+    return {
+        value: model.value,
+        label: displayLabelWithClaudeVersion(model),
+        ...(normalizeModelDescription(model.description) ? { description: normalizeModelDescription(model.description) } : {}),
+    };
+}
+export function isClaudeCustomModelOption(option) {
+    return option?.description?.trim().toLowerCase() === 'custom model';
+}
+export function resolveClaudeModelOptions(input) {
     const byValue = new Map();
-    for (const option of input.previous) {
-        byValue.set(option.value, { ...option });
-    }
-    for (const option of input.next) {
+    for (const option of input.discovered) {
         byValue.set(option.value, { ...option });
     }
     if (input.selectedModel && !byValue.has(input.selectedModel)) {
         byValue.set(input.selectedModel, {
             value: input.selectedModel,
             label: input.selectedModel,
-            description: 'Selected for this Canon session but not returned by the latest Claude model probe.',
+            description: 'Selected for this Canon session but not returned by Claude model discovery.',
         });
     }
-    const nextValues = new Set(input.next.map((option) => option.value));
-    return [...byValue.values()].map((option) => {
-        if (nextValues.has(option.value))
-            return option;
-        return {
-            ...option,
-            description: option.description
-                ? `${option.description} Previously advertised; not returned by the latest Claude model probe.`
-                : 'Previously advertised; not returned by the latest Claude model probe.',
-        };
-    });
+    return [...byValue.values()];
 }
 export function formatClaudeControlError(error) {
     if (error instanceof Error && error.message.trim()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -33,8 +33,8 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.200",
     "@canonmsg/agent-host": "^0.4.0",
     "@canonmsg/agent-sdk": "^3.4.4",
-    "@canonmsg/bridge": "^0.2.0",
-    "@canonmsg/core": "^3.2.0",
+    "@canonmsg/bridge": "^0.2.3",
+    "@canonmsg/core": "^3.2.1",
     "@canonmsg/framework": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },