@canonmsg/claude-code-plugin 0.23.0 → 0.25.0

package/dist/host.js

@@ -28,12 +28,12 @@ import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
 import { captureTurnArtifactSnapshot, collectTurnArtifacts, } from '@canonmsg/coding-agent-host';
-import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPlanApprovalRequest, resolveQuestionAllowOther, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, resolveQuestionAllowOther, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { decideAutoReply, } from './inbound-policy.js';
 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 { applyClaudeSessionControl, buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -195,6 +195,26 @@ function buildClaudeRuntimeDescriptor(input) {
                 controlId: 'effort',
             },
         },
+        {
+            id: 'ultracode-details',
+            label: 'Ultracode',
+            description: 'Toggle Claude ultracode using /ultracode.',
+            aliases: ['ultracode'],
+            category: 'runtime',
+            placements: ['composer_slash', 'command_palette'],
+            availability: ['always'],
+            args: [{
+                    id: 'level',
+                    label: 'Level',
+                    kind: 'enum',
+                    required: true,
+                    choices: [...CLAUDE_ULTRACODE_OPTIONS],
+                }],
+            dispatch: {
+                kind: 'control',
+                controlId: 'ultracode',
+            },
+        },
         {
             ...RUNTIME_NEW_SESSION_ACTION,
             primitive: 'session.new',
@@ -212,6 +232,15 @@ function buildClaudeRuntimeDescriptor(input) {
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         effortOptions: [...CLAUDE_EFFORT_OPTIONS],
+        extraRuntimeControls: [{
+                id: 'ultracode',
+                label: 'Ultracode',
+                options: [...CLAUDE_ULTRACODE_OPTIONS],
+                defaultValue: 'off',
+                availability: 'setup_and_live',
+                liveBehavior: 'immediate',
+                selectionPolicy: 'inherit',
+            }],
         streamingTextMode: 'delta',
         turnModes: [
             {
@@ -257,6 +286,16 @@ function normalizeClaudeEffortLevel(value) {
 async function applyClaudeEffortLevel(q, effort) {
     await q.applyFlagSettings({ effortLevel: effort });
 }
+const CLAUDE_ULTRACODE_OPTIONS = [
+    { value: 'on', label: 'On' },
+    { value: 'off', label: 'Off' },
+];
+function parseClaudeUltracodeMode(value) {
+    return value === 'on' || value === 'off' ? value : undefined;
+}
+async function applyClaudeUltracode(q, enabled) {
+    await q.applyFlagSettings({ ultracode: enabled });
+}
 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
@@ -314,6 +353,7 @@ async function loadSessionConfig(conversationId, agentId) {
             ? parseClaudePermissionMode(config.permissionMode) ?? undefined
             : undefined,
         effort: normalizeClaudeEffortLevel(config?.effort),
+        ultracode: parseClaudeUltracodeMode(config?.runtimeControlValues?.ultracode),
     };
 }
 function resolveSessionExecutionMode(config) {
@@ -729,7 +769,6 @@ async function buildCanonUserContent(input) {
 function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
     const cardResponseUserId = config.ownerId ?? undefined;
-    const cardResponseUser = cardResponseUserId ? { responseUserId: cardResponseUserId } : undefined;
     // Per-session input stream with message queue
     let resolveInput = null;
     let inputDone = false;
@@ -804,30 +843,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             };
         });
     }
-    async function waitForRuntimeInputResponse(input) {
-        session.lastActivity = Date.now();
-        while (Date.now() < input.expiresAt) {
-            const response = await client.consumeRuntimeInputResponse({
-                conversationId,
-                inputId: input.inputId,
-            }).catch(() => null);
-            if (response?.status === 'submitted') {
-                return { status: 'submitted', answers: response.answers, value: response.value };
-            }
-            if (response?.status === 'cancelled' || response?.status === 'timeout') {
-                return { status: response.status };
-            }
-            await sleep(1_000);
-        }
-        const response = await client.consumeRuntimeInputResponse({
-            conversationId,
-            inputId: input.inputId,
-        }).catch(() => null);
-        if (response?.status === 'submitted') {
-            return { status: 'submitted', answers: response.answers, value: response.value };
-        }
-        return { status: 'timeout' };
-    }
     function buildArtifactMediaMetadata() {
         return {
             ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
@@ -863,18 +878,19 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     const questionId = randomUUID();
                     const questions = mapClaudeQuestions(input.questions);
                     const expiresAt = Date.now() + REPLY_TIMEOUT_MS;
-                    await client.createRuntimeInputRequest({
-                        conversationId,
-                        inputId: questionId,
+                    // Create + poll fold onto the shared spine. `responderPolicy: 'infer'`
+                    // keeps the claude host's responder rule byte-identical (explicit
+                    // `cardResponseUserId` wins, else omit — never the manager's ownerId
+                    // fallback), and `native` carries the claude-specific descriptor.
+                    const reply = await config.runtimeInputManager.request('input', conversationId, {
                         kind: 'clarify',
-                        expiresAt,
                         title: 'Claude needs input',
                         prompt: questions?.length
                             ? 'Claude needs your input to continue.'
                             : 'Claude needs input to continue.',
                         ...(questions ? { questions } : {}),
                         sensitive: Boolean(questions?.some((question) => question.isSecret)),
-                        ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
+                        responseUserId: cardResponseUserId,
                         native: {
                             runtime: 'claude-code',
                             method: 'AskUserQuestion',
@@ -882,9 +898,15 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             turnId: session.currentTurnId ?? undefined,
                         },
                         turnId: session.currentTurnId ?? undefined,
+                    }, {
+                        requestId: questionId,
+                        expiresAt,
+                        responderPolicy: 'infer',
+                        onCreated: () => {
+                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
+                            session.lastActivity = Date.now();
+                        },
                     });
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
-                    const reply = await waitForRuntimeInputResponse({ inputId: questionId, expiresAt });
                     if (reply.status !== 'submitted') {
                         return { behavior: 'deny', message: 'No reply received (timed out)' };
                     }
@@ -930,22 +952,19 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     const planBody = typeof input.plan === 'string' && input.plan.trim()
                         ? input.plan.trim()
                         : undefined;
-                    const planApproval = buildPlanApprovalRequest(planId, 'Plan ready for review.', {
+                    // Route plan-CREATE through the unified spine (`/runtime-plan/request`):
+                    // seeds the server-owned pending node/attention/state and authors the
+                    // `plan_approval` card. Resolution is UNCHANGED — the gate still blocks
+                    // on the server-authored `plan_approval_reply` below.
+                    await client.createRuntimePlanRequest({
+                        conversationId,
+                        planId,
+                        title: 'Plan ready for review.',
                         summary: 'Claude has prepared a plan and is asking permission to continue.',
                         ...(planBody ? { body: planBody } : {}),
-                        ...(cardResponseUser ?? {}),
+                        ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
                         ...(allowedPrompts.length > 0 ? { allowedPrompts } : {}),
-                    });
-                    await sendMessageWithRetry(client, conversationId, planApproval.text, {
-                        messageId: `claude-plan-${planId}`,
-                        ...(session.activeSelfContextId
-                            ? { selfContextId: session.activeSelfContextId }
-                            : {}),
-                        metadata: {
-                            ...planApproval.metadata,
-                            turnSemantics: 'control',
-                            replyBehavior: 'suppress_auto_reply',
-                        },
+                        ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
                     const reply = await waitForReply('plan_approval_reply', planId);
@@ -988,6 +1007,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         if (session.state.permissionMode === 'plan') {
                             session.state.permissionMode = 'default';
                             writeState();
+                            // Converge the app immediately on the SDK-driven plan-mode exit
+                            // instead of waiting for the next 30s heartbeat (lag fix).
+                            config.publishSessionSnapshots?.([conversationId]);
                         }
                         return { behavior: 'allow' };
                     }
@@ -1056,6 +1078,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             model: undefined,
             permissionMode: config.permissionMode,
             effort: undefined,
+            ultracode: undefined,
             state: 'idle',
         },
         availableModels: config.availableModels,
@@ -1324,10 +1347,17 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         else if (config.effort !== undefined) {
             controlState.effort = { value: config.effort, source: 'requested' };
         }
+        if (session.state.ultracode !== undefined) {
+            controlState.ultracode = { value: session.state.ultracode, source: 'applied', appliedAt };
+        }
+        else if (config.ultracode !== undefined) {
+            controlState.ultracode = { value: config.ultracode, source: 'requested' };
+        }
         runtimeState.writeSessionState(conversationId, {
             model: session.state.model,
             permissionMode: session.state.permissionMode,
             effort: session.state.effort,
+            ...(session.state.ultracode ? { runtimeControlValues: { ultracode: session.state.ultracode } } : {}),
             controlState,
             runtimeControlErrors,
             contextUsage: session.state.contextUsage,
@@ -1666,6 +1696,15 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial effort:`, err);
             }
         }
+        if (config.ultracode) {
+            try {
+                await applyClaudeUltracode(q, config.ultracode === 'on');
+                session.state.ultracode = config.ultracode;
+            }
+            catch (err) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial ultracode:`, err);
+            }
+        }
         if (!resumeSessionId) {
             // New session — send seed message to activate streaming input mode
             sendInput(createClaudeInputEnvelope({
@@ -1848,31 +1887,15 @@ export async function main() {
     const promptedGroupContextConversationIds = new Set();
     const pendingMembershipChanges = new Map();
     let lastKnownConversationRefreshAt = 0;
-    const publishRuntimeHeartbeat = async () => {
-        heartbeatLocalRuntimeEntry(runtimeId, {
-            agentId,
-            agentName: profileAgentName,
-            cwd: workingDir,
-            baseCwd: workingDir,
-        });
-        if (!streamConnected)
+    // Publish the app-subscribed /agent-session snapshot for the given
+    // conversations. Extracted from the heartbeat so control handlers can converge
+    // the app immediately instead of waiting for the next 30s heartbeat
+    // (session-control lag fix). Hoisted so it is reachable from earlier code.
+    async function publishSessionSnapshots(conversationIds) {
+        if (!streamConnected || conversationIds.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(agentId, runtimeDescriptor).catch((error) => {
-            console.error('[canon-host] Failed to publish agent runtime:', error);
-        });
         await publishHostSessionSnapshots({
-            conversationIds: Array.from(knownConversationIds),
+            conversationIds,
             agentId,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
@@ -1887,6 +1910,7 @@ export async function main() {
                         ...(session.state.model ? { model: session.state.model } : {}),
                         ...(session.state.permissionMode ? { permissionMode: session.state.permissionMode } : {}),
                         ...(session.state.effort ? { effort: session.state.effort } : {}),
+                        ...(session.state.ultracode ? { runtimeControlValues: { ultracode: session.state.ultracode } } : {}),
                         ...(workspaceId ? { workspaceId } : {}),
                         executionMode: session.environment.mode,
                         executionBranch: session.environment.branch ?? null,
@@ -1896,6 +1920,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(agentId, runtimeDescriptor).catch((error) => {
+            console.error('[canon-host] Failed to publish agent runtime:', error);
+        });
+        await publishSessionSnapshots(Array.from(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.
@@ -1992,6 +2041,10 @@ export async function main() {
     // ── Session manager ──
     const sessions = new Map();
     const approvalManager = ownerId ? new ApprovalManager(client, agentId, ownerId) : null;
+    // Interactive runtime input (AskUserQuestion) works with or without an owner,
+    // so its poll engine is always present. Create + poll fold onto the built-in
+    // input descriptor via `request()` (see the AskUserQuestion canUseTool branch).
+    const runtimeInputManager = new RuntimeRequestManager(client, { agentId, ownerId: ownerId ?? '' });
     const pendingSessionCreations = new Map();
     // Shared /control channel poller (claude host profile): session + signal
     // keys, sequential conversations, active/idle cadence + jitter sampled at
@@ -2293,13 +2346,16 @@ export async function main() {
                     model: config?.model ?? runtimeModels[0]?.value,
                     permissionMode: config?.permissionMode ?? 'default',
                     effort: config?.effort,
+                    ultracode: config?.ultracode,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
                     runtimePresentation,
                     approvalManager,
+                    runtimeInputManager,
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
                     ownerId,
+                    publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
                 }, resumeId);
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
@@ -2609,51 +2665,26 @@ export async function main() {
             return { consume: false };
         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.'));
-        }
+        await applyClaudeSessionControl({
+            model: ctrl.model,
+            permissionMode: ctrl.permissionMode,
+            effort: ctrl.effort,
+            ultracode: ctrl.runtimeControlValues?.ultracode,
+        }, {
+            state: session.state,
+            parsePermissionMode: parseClaudePermissionMode,
+            normalizeEffort: normalizeClaudeEffortLevel,
+            parseUltracode: parseClaudeUltracodeMode,
+            setModel: (model) => session.query.setModel(model),
+            setPermissionMode: (mode) => session.query.setPermissionMode(mode),
+            applyEffort: (level) => applyClaudeEffortLevel(session.query, level),
+            applyUltracode: (enabled) => applyClaudeUltracode(session.query, enabled),
+            setRuntimeControlError: (controlId, value, error) => session.setRuntimeControlError(controlId, value, error),
+            clearRuntimeControlError: (controlId) => session.clearRuntimeControlError(controlId),
+            // Publish the app-subscribed snapshot immediately so the control-pending
+            // gate clears now instead of at the next 30s heartbeat (lag fix).
+            publishSnapshot: () => { void publishSessionSnapshots([convoId]); },
+        });
         session.writeState();
     }
     // Interrupt/stop-clear signal. Throwing leaves the node in place
@@ -2731,6 +2762,7 @@ export async function main() {
         clearInterval(idleCheck);
         stream.stop();
         approvalManager?.dispose();
+        runtimeInputManager.dispose();
         await runtimeState.clearAgentRuntime().catch(() => { });
         for (const convoId of [...sessions.keys()]) {
             closeSession(convoId);

package/dist/session-state.d.ts

@@ -1,4 +1,4 @@
-import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { PermissionMode, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core';
 import type { TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
@@ -66,3 +66,44 @@ export declare function mergeClaudeModelOptions(input: {
     selectedModel?: string | null;
 }): ModelOption[];
 export declare function formatClaudeControlError(error: unknown): string;
+/** Requested session-control values from the control plane (raw, pre-validation). */
+export interface ClaudeSessionControlInput {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    ultracode?: string;
+}
+/** Mutable mirror of the live session's control state — mutated in place on success. */
+export interface ClaudeSessionControlState {
+    model?: string;
+    permissionMode?: string;
+    effort?: string;
+    ultracode?: string;
+}
+/**
+ * Injected validators + side effects so the apply logic stays host-agnostic and
+ * unit-testable. The host wires these to the live SDK query and its runtime
+ * control-error bookkeeping; tests inject fakes.
+ */
+export interface ClaudeSessionControlDeps {
+    state: ClaudeSessionControlState;
+    parsePermissionMode: (value: unknown) => PermissionMode | null;
+    normalizeEffort: (value: unknown) => string | undefined;
+    parseUltracode: (value: unknown) => string | undefined;
+    setModel: (model: string) => Promise<void>;
+    setPermissionMode: (mode: PermissionMode) => Promise<void>;
+    applyEffort: (level: string) => Promise<void>;
+    applyUltracode: (enabled: boolean) => Promise<void>;
+    setRuntimeControlError: (controlId: string, value: string, error: unknown) => void;
+    clearRuntimeControlError: (controlId: string) => void;
+    publishSnapshot: () => void;
+}
+/**
+ * Apply a session-control request to the live Claude session. Mirrors the host's
+ * control semantics (validation, only-if-different checks, error recording,
+ * clear-on-success). Whenever a live op is invoked — on success OR caught
+ * failure — publishSnapshot() is called exactly once so the app-subscribed
+ * /agent-session snapshot converges immediately instead of waiting for the next
+ * heartbeat. If nothing changed, publishSnapshot() is not called.
+ */
+export declare function applyClaudeSessionControl(control: ClaudeSessionControlInput, deps: ClaudeSessionControlDeps): Promise<void>;

package/dist/session-state.js

@@ -82,3 +82,74 @@ export function formatClaudeControlError(error) {
     }
     return 'Claude Code did not apply that control.';
 }
+/**
+ * Apply a session-control request to the live Claude session. Mirrors the host's
+ * control semantics (validation, only-if-different checks, error recording,
+ * clear-on-success). Whenever a live op is invoked — on success OR caught
+ * failure — publishSnapshot() is called exactly once so the app-subscribed
+ * /agent-session snapshot converges immediately instead of waiting for the next
+ * heartbeat. If nothing changed, publishSnapshot() is not called.
+ */
+export async function applyClaudeSessionControl(control, deps) {
+    const { state } = deps;
+    let liveOpInvoked = false;
+    if (control.model && control.model !== state.model) {
+        liveOpInvoked = true;
+        try {
+            await deps.setModel(control.model);
+            state.model = control.model;
+            deps.clearRuntimeControlError('model');
+        }
+        catch (err) {
+            deps.setRuntimeControlError('model', control.model, err);
+        }
+    }
+    const nextPermissionMode = deps.parsePermissionMode(control.permissionMode);
+    if (control.permissionMode && !nextPermissionMode) {
+        deps.setRuntimeControlError('permissionMode', control.permissionMode, new Error(`Unsupported Claude permission mode: ${control.permissionMode}`));
+    }
+    else if (nextPermissionMode && nextPermissionMode !== state.permissionMode) {
+        liveOpInvoked = true;
+        try {
+            await deps.setPermissionMode(nextPermissionMode);
+            state.permissionMode = nextPermissionMode;
+            deps.clearRuntimeControlError('permissionMode');
+        }
+        catch (err) {
+            deps.setRuntimeControlError('permissionMode', nextPermissionMode, err);
+        }
+    }
+    const nextEffort = deps.normalizeEffort(control.effort);
+    if (nextEffort && nextEffort !== state.effort) {
+        liveOpInvoked = true;
+        try {
+            await deps.applyEffort(nextEffort);
+            state.effort = nextEffort;
+            deps.clearRuntimeControlError('effort');
+        }
+        catch (err) {
+            deps.setRuntimeControlError('effort', nextEffort, err);
+        }
+    }
+    else if (control.effort && !nextEffort) {
+        deps.setRuntimeControlError('effort', String(control.effort), new Error('Unsupported Claude thinking level.'));
+    }
+    const nextUltracode = deps.parseUltracode(control.ultracode);
+    if (control.ultracode && !nextUltracode) {
+        deps.setRuntimeControlError('ultracode', String(control.ultracode), new Error('Unsupported Claude ultracode mode.'));
+    }
+    else if (nextUltracode && nextUltracode !== state.ultracode) {
+        liveOpInvoked = true;
+        try {
+            await deps.applyUltracode(nextUltracode === 'on');
+            state.ultracode = nextUltracode;
+            deps.clearRuntimeControlError('ultracode');
+        }
+        catch (err) {
+            deps.setRuntimeControlError('ultracode', nextUltracode, err);
+        }
+    }
+    if (liveOpInvoked) {
+        deps.publishSnapshot();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -30,10 +30,10 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
-    "@canonmsg/agent-sdk": "^5.0.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
+    "@canonmsg/agent-sdk": "^5.1.0",
     "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^4.0.0",
+    "@canonmsg/core": "^4.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {