@canonmsg/claude-code-plugin 0.23.0 → 0.24.0

package/dist/host.js

@@ -33,7 +33,7 @@ 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) {
@@ -988,6 +1028,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 +1099,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             model: undefined,
             permissionMode: config.permissionMode,
             effort: undefined,
+            ultracode: undefined,
             state: 'idle',
         },
         availableModels: config.availableModels,
@@ -1324,10 +1368,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 +1717,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 +1908,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 +1931,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 +1941,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.
@@ -2293,6 +2363,7 @@ 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,
@@ -2300,6 +2371,7 @@ export async function main() {
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
                     ownerId,
+                    publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
                 }, resumeId);
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
@@ -2609,51 +2681,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

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.24.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",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
     "@canonmsg/agent-sdk": "^5.0.0",
     "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^4.0.0",
+    "@canonmsg/core": "^4.1.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {