@canonmsg/claude-code-plugin 0.20.0 → 0.21.1

package/dist/host.js

@@ -36,7 +36,9 @@ 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 { applyClaudeSessionControl, buildClaudeFinalMessageId, buildClaudeInitialSessionState, createClaudeInputEnvelope, formatClaudeControlError, 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;
 }
@@ -87,6 +89,29 @@ let workspaceRootMetadata = [];
 let runtimeModels = [];
 const CLAUDE_METADATA_TTL_MS = 5 * 60 * 1000;
 const allowedNonOwnerClaudeTools = parseAllowedNonOwnerClaudeTools(process.env.CANON_CLAUDE_NON_OWNER_ALLOWED_TOOLS);
+const CLAUDE_THINKING_CONTROL_OPTIONS = [
+    {
+        value: 'adaptive',
+        label: 'Adaptive',
+        description: 'Let Claude decide when and how much to think.',
+    },
+    {
+        value: 'off',
+        label: 'Off',
+        description: 'Disable extended thinking for this session.',
+    },
+];
+const CLAUDE_ULTRACODE_CONTROL_OPTIONS = [
+    {
+        value: 'off',
+        label: 'Off',
+    },
+    {
+        value: 'on',
+        label: 'On',
+        description: 'Enable Claude Code ultracode mode when the selected model supports it.',
+    },
+];
 let runtimeMetadata = {
     account: null,
     mcpServers: [],
@@ -211,15 +236,40 @@ function buildClaudeRuntimeDescriptor(input) {
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
     commands.push(...buildNativeSlashCommandDescriptors(runtimeMetadata.commands, new Set(commands.flatMap((command) => [command.id, ...(command.aliases ?? [])]))));
+    const extraRuntimeControls = [
+        {
+            id: 'thinking',
+            label: 'Thinking',
+            description: 'Claude SDK thinking mode. Mid-session changes toggle thinking on or off; display/budget stay session-start scoped.',
+            options: CLAUDE_THINKING_CONTROL_OPTIONS,
+            defaultValue: input.defaults?.thinking ?? 'adaptive',
+            availability: 'setup_and_live',
+            liveBehavior: 'immediate',
+            selectionPolicy: 'inherit',
+        },
+        {
+            id: 'ultracode',
+            label: 'Ultracode',
+            description: 'Enable Claude Code ultracode mode when the selected model supports it.',
+            options: CLAUDE_ULTRACODE_CONTROL_OPTIONS,
+            defaultValue: input.defaults?.ultracode ?? 'off',
+            availability: 'setup_and_live',
+            liveBehavior: 'immediate',
+            selectionPolicy: 'inherit',
+        },
+    ];
     return buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'claude-code',
         models: input.models,
+        defaultModel: input.defaults?.model ?? input.models[0]?.value ?? null,
         workspaces: input.workspaces,
         workspaceRoots: input.workspaceRoots,
         executionModes: input.executionModes,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         effortOptions: [...CLAUDE_EFFORT_OPTIONS],
+        defaultEffort: input.defaults?.effort,
+        extraRuntimeControls,
         streamingTextMode: 'delta',
         turnModes: [
             {
@@ -245,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
@@ -354,6 +384,7 @@ async function detectRuntimeModels(cwd) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
+            model: 'default',
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -381,6 +412,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' },
@@ -561,13 +593,22 @@ function buildClaudeRuntimeInfo(input) {
                 tier: 'diagnostic',
             }
             : null,
-        runtimeModels[0]
+        input.fallbackModel
             ? {
                 id: 'fallbackModel',
                 label: 'Fallback model',
-                value: runtimeModels[0].label,
+                value: input.fallbackModel,
                 tier: 'diagnostic',
-                source: 'host-default',
+                source: 'applied',
+            }
+            : null,
+        input.ultracodeEnabled
+            ? {
+                id: 'ultracode',
+                label: 'Ultracode',
+                value: 'Enabled',
+                tier: 'detail',
+                source: 'applied',
             }
             : null,
         {
@@ -808,16 +849,27 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         };
     }
     const claudeCliPath = resolveClaudeCliPath();
+    const initialThinkingConfig = claudeThinkingToConfig(config.sessionSettings.thinking);
     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,
         includePartialMessages: true,
         maxTurns: 200,
         ...(config.effort ? { effort: config.effort } : {}),
-        settings: { forceLoginMethod: 'claudeai' },
+        ...(initialThinkingConfig ? { thinking: initialThinkingConfig } : {}),
+        ...(config.sessionSettings.fallbackModel ? { fallbackModel: config.sessionSettings.fallbackModel } : {}),
+        agentProgressSummaries: config.sessionSettings.agentProgressSummaries ?? true,
+        ...(config.sessionSettings.agents ? { agents: config.sessionSettings.agents } : {}),
+        settings: {
+            forceLoginMethod: 'claudeai',
+            ...(config.sessionSettings.ultracode
+                ? { ultracode: config.sessionSettings.ultracode === 'on' }
+                : {}),
+        },
         settingSources: ['project', 'local'],
         ...(claudeCliPath ? { pathToClaudeCodeExecutable: claudeCliPath } : {}),
         stderr: (data) => {
@@ -1023,14 +1075,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,
-            state: 'idle',
-        },
+            effort: config.effort,
+            fallbackModel: config.sessionSettings.fallbackModel,
+            runtimeControlValues: config.sessionSettings.runtimeControlValues,
+        }),
         availableModels: config.availableModels,
         streamingText: '',
         streamingTimer: null,
@@ -1069,11 +1123,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,
-        },
+        requestedControls: {},
     }, {
         session: () => session,
         port,
@@ -1089,6 +1139,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));
@@ -1213,6 +1266,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
     };
     writeTurn();
     // ── Process SDK output messages ──
+    let assistantStreamOrdinal = 0;
     const processMessages = async () => {
         try {
             for await (const msg of q) {
@@ -1243,7 +1297,10 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                             stopVisibleWorkSignal();
                             break;
                         }
-                        if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                        if (event?.type === 'message_start') {
+                            assistantStreamOrdinal += 1;
+                        }
+                        else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
                             session.toolInProgress = true;
                             session.turnState = 'tool';
                             streamingOutput.addBlock({
@@ -1272,12 +1329,35 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                             stopVisibleWorkSignal();
                             writeTurn();
                             const blockIndex = typeof event.index === 'number' ? event.index : 'latest';
-                            onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${blockIndex}`);
+                            const messageOrdinal = assistantStreamOrdinal || 1;
+                            onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${messageOrdinal}:${blockIndex}`);
                         }
                         break;
                     }
                     case 'system': {
                         const subtype = msg.subtype;
+                        if (subtype === 'task_started'
+                            || subtype === 'task_progress'
+                            || subtype === 'task_updated'
+                            || subtype === 'task_notification') {
+                            const activity = mapClaudeSubagentActivity(msg);
+                            if (activity && !isActiveTurnInterrupted()) {
+                                if (!session.currentTurnId) {
+                                    session.currentTurnId = randomUUID();
+                                    session.currentTurnOpenedAt = Date.now();
+                                }
+                                if (session.state.state === 'running' && session.turnState !== 'streaming') {
+                                    session.turnState = 'thinking';
+                                    startVisibleWorkSignal();
+                                    writeTurn();
+                                }
+                                await streamingOutput.addBlock(activity).catch(() => { });
+                            }
+                        }
+                        if (subtype === 'model_refusal_fallback') {
+                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Model refusal fallback: `
+                                + `${msg.original_model} → ${msg.fallback_model}`);
+                        }
                         if (subtype === 'session_state_changed') {
                             const state = msg.state;
                             session.state.state = state;
@@ -1289,6 +1369,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                                 }
                                 session.state.contextUsage = undefined;
                                 session.pendingFinalText = null;
+                                assistantStreamOrdinal = 0;
                                 session.toolInProgress = false;
                                 session.turnState = 'thinking';
                                 startVisibleWorkSignal();
@@ -1385,24 +1466,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({
@@ -1417,25 +1480,32 @@ 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: modelList[0]?.value,
+                defaultModel: config.sessionSettings.model ?? modelList[0]?.value,
                 defaultPermissionMode: 'default',
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 availableExecutionModes: config.availableExecutionModes,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: modelList,
+                    defaults: config.sessionSettings,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: config.availableExecutionModes,
@@ -1443,7 +1513,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();
@@ -1488,7 +1558,8 @@ export async function main() {
     for (const warning of workspaceDiscovery.warnings) {
         console.error(`[canon-host] ${warning}`);
     }
-    const { agentName: profileAgentName, profile, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
+    const { agentName: profileAgentName, profile, sessionDefaults: rawSessionDefaults, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
+    const profileSessionDefaults = parseClaudeSessionDefaults(rawSessionDefaults);
     activeLockHandle = lockHandle ?? null;
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     // ── Canon via the Bridge (bridge-execution-plan Phase 6) ──
@@ -1578,12 +1649,14 @@ export async function main() {
     });
     let runtimeDescriptor = {
         defaultWorkspaceId: workspaceOptions[0]?.id,
+        defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
         defaultPermissionMode: 'default',
         availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         availableExecutionModes: hostAvailableExecutionModes,
         runtimeDescriptor: buildClaudeRuntimeDescriptor({
             models: runtimeModels,
+            defaults: profileSessionDefaults,
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
@@ -1598,31 +1671,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 })),
@@ -1636,6 +1690,9 @@ 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.runtimeControlValues
+                            ? { runtimeControlValues: session.state.runtimeControlValues }
+                            : {}),
                         ...(workspaceId ? { workspaceId } : {}),
                         executionMode: session.environment.mode,
                         executionBranch: session.environment.branch ?? null,
@@ -1645,14 +1702,41 @@ 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.
         if (runtimeDescriptor.runtimeDescriptor) {
             runtimeDescriptor = {
                 ...runtimeDescriptor,
+                defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: runtimeModels,
+                    defaults: profileSessionDefaults,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: hostAvailableExecutionModes,
@@ -1680,6 +1764,10 @@ export async function main() {
                 executionBranch: session?.environment.branch ?? null,
                 worktreePath: session?.environment.worktreePath ?? null,
                 fallbackReason: resolveExecutionFallbackReason(session?.environment),
+                fallbackModel: session?.state.fallbackModel
+                    ?? profileSessionDefaults.fallbackModel
+                    ?? null,
+                ultracodeEnabled: (session?.state.runtimeControlValues?.ultracode ?? profileSessionDefaults.ultracode) === 'on',
             });
             await port.publishRuntimeStatus({
                 conversationId,
@@ -1694,7 +1782,7 @@ export async function main() {
         runtimeModels = await detectRuntimeModels(workingDir);
         runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
-            defaultModel: runtimeModels[0]?.value,
+            defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableModels: runtimeModels,
@@ -1702,6 +1790,7 @@ export async function main() {
             availableExecutionModes: hostAvailableExecutionModes,
             runtimeDescriptor: buildClaudeRuntimeDescriptor({
                 models: runtimeModels,
+                defaults: profileSessionDefaults,
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
@@ -1712,12 +1801,14 @@ export async function main() {
     catch {
         runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
+            defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
             runtimeDescriptor: buildClaudeRuntimeDescriptor({
                 models: runtimeModels,
+                defaults: profileSessionDefaults,
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
@@ -1847,6 +1938,10 @@ export async function main() {
     function createSessionForConversation(conversationId) {
         return (async () => {
             const config = await loadSessionConfig(port, conversationId);
+            const sessionSettings = resolveEffectiveSessionSettings({
+                profileDefaults: profileSessionDefaults,
+                sessionConfig: config,
+            });
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -1894,9 +1989,10 @@ export async function main() {
                     runtimeDescriptor = descriptor;
                     void publishRuntimeHeartbeat();
                 }, {
-                    model: config?.model ?? runtimeModels[0]?.value,
+                    model: sessionSettings.model ?? runtimeModels[0]?.value,
                     permissionMode: config?.permissionMode ?? 'default',
-                    effort: config?.effort,
+                    effort: sessionSettings.effort,
+                    sessionSettings,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
                     runtimePresentation,
@@ -2252,62 +2348,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.'));
-        }
-        session.writeState();
+        applyClaudeSessionControl(session, ctrl);
     }
     // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──
     lifecycle.startTimers();

package/dist/session-defaults.d.ts

@@ -0,0 +1,35 @@
+import type { AgentDefinition, EffortLevel, ThinkingConfig } from '@anthropic-ai/claude-agent-sdk';
+export type ClaudeThinkingMode = 'adaptive' | 'off';
+export type ClaudeUltracodeMode = 'on' | 'off';
+export type ClaudeEffortLevel = Extract<EffortLevel, 'low' | 'medium' | 'high' | 'xhigh' | 'max'>;
+export interface ClaudeSessionDefaults {
+    model?: string;
+    effort?: ClaudeEffortLevel;
+    thinking?: ClaudeThinkingMode;
+    ultracode?: ClaudeUltracodeMode;
+    fallbackModel?: string;
+    agentProgressSummaries?: boolean;
+    agents?: Record<string, AgentDefinition>;
+}
+export interface ClaudeSessionControlValues {
+    thinking?: ClaudeThinkingMode;
+    ultracode?: ClaudeUltracodeMode;
+}
+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;
+export declare function parseClaudeSessionControlValues(values: Record<string, string> | null | undefined): ClaudeSessionControlValues;
+export declare function claudeThinkingToConfig(mode: ClaudeThinkingMode | undefined): ThinkingConfig | undefined;
+export declare function claudeThinkingToFlagValue(mode: ClaudeThinkingMode): boolean;
+export declare function resolveEffectiveSessionSettings(input: {
+    profileDefaults?: ClaudeSessionDefaults;
+    sessionConfig?: {
+        model?: string;
+        effort?: ClaudeEffortLevel;
+        runtimeControlValues?: Record<string, string>;
+    } | null;
+}): ClaudeEffectiveSessionSettings;

package/dist/session-defaults.js

@@ -0,0 +1,124 @@
+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;
+}
+function optionalBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+export function parseClaudeThinkingMode(value) {
+    if (value === false || value === 'off' || value === 'disabled')
+        return 'off';
+    if (value === true || value === 'on' || value === 'adaptive' || value === 'enabled')
+        return 'adaptive';
+    return undefined;
+}
+export function parseClaudeUltracodeMode(value) {
+    if (value === true || value === 'on' || value === 'enabled')
+        return 'on';
+    if (value === false || value === 'off' || value === 'disabled')
+        return 'off';
+    return undefined;
+}
+function parseEffort(value) {
+    const normalized = optionalString(value);
+    if (!normalized)
+        return undefined;
+    return CLAUDE_EFFORT_VALUES.has(normalized)
+        ? normalized
+        : undefined;
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value
+        .map((entry) => optionalString(entry))
+        .filter((entry) => Boolean(entry));
+    return out.length > 0 ? out : undefined;
+}
+function parseAgentDefinition(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const data = value;
+    const description = optionalString(data.description);
+    const prompt = optionalString(data.prompt);
+    if (!description || !prompt)
+        return null;
+    return {
+        description,
+        prompt,
+        ...(parseStringArray(data.tools) ? { tools: parseStringArray(data.tools) } : {}),
+        ...(parseStringArray(data.disallowedTools) ? { disallowedTools: parseStringArray(data.disallowedTools) } : {}),
+        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
+        ...(parseStringArray(data.skills) ? { skills: parseStringArray(data.skills) } : {}),
+        ...(typeof data.maxTurns === 'number' && Number.isFinite(data.maxTurns) && data.maxTurns > 0
+            ? { maxTurns: Math.floor(data.maxTurns) }
+            : {}),
+        ...(typeof data.background === 'boolean' ? { background: data.background } : {}),
+        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
+    };
+}
+function parseAgents(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [rawName, rawAgent] of Object.entries(value)) {
+        const name = rawName.trim();
+        if (!name)
+            continue;
+        const agent = parseAgentDefinition(rawAgent);
+        if (agent)
+            out[name] = agent;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+export function parseClaudeSessionDefaults(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const data = raw;
+    return {
+        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
+        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
+        ...(parseClaudeThinkingMode(data.thinking) ? { thinking: parseClaudeThinkingMode(data.thinking) } : {}),
+        ...(parseClaudeUltracodeMode(data.ultracode) ? { ultracode: parseClaudeUltracodeMode(data.ultracode) } : {}),
+        ...(optionalString(data.fallbackModel) ? { fallbackModel: optionalString(data.fallbackModel) } : {}),
+        ...(optionalBoolean(data.agentProgressSummaries) !== undefined
+            ? { agentProgressSummaries: optionalBoolean(data.agentProgressSummaries) }
+            : {}),
+        ...(parseAgents(data.agents) ? { agents: parseAgents(data.agents) } : {}),
+    };
+}
+export function parseClaudeSessionControlValues(values) {
+    return {
+        ...(parseClaudeThinkingMode(values?.thinking) ? { thinking: parseClaudeThinkingMode(values?.thinking) } : {}),
+        ...(parseClaudeUltracodeMode(values?.ultracode) ? { ultracode: parseClaudeUltracodeMode(values?.ultracode) } : {}),
+    };
+}
+export function claudeThinkingToConfig(mode) {
+    if (mode === 'adaptive')
+        return { type: 'adaptive' };
+    if (mode === 'off')
+        return { type: 'disabled' };
+    return undefined;
+}
+export function claudeThinkingToFlagValue(mode) {
+    return mode !== 'off';
+}
+export function resolveEffectiveSessionSettings(input) {
+    const controlValues = parseClaudeSessionControlValues(input.sessionConfig?.runtimeControlValues);
+    const runtimeControlValues = {
+        ...(input.profileDefaults?.thinking ? { thinking: input.profileDefaults.thinking } : {}),
+        ...(input.profileDefaults?.ultracode ? { ultracode: input.profileDefaults.ultracode } : {}),
+        ...(input.sessionConfig?.runtimeControlValues ?? {}),
+        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
+        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
+    };
+    return {
+        ...(input.profileDefaults ?? {}),
+        ...(input.sessionConfig?.model ? { model: input.sessionConfig.model } : {}),
+        ...(input.sessionConfig?.effort ? { effort: input.sessionConfig.effort } : {}),
+        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
+        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
+        runtimeControlValues,
+    };
+}

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,8 @@ 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 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,19 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
-export function mergeClaudeModelOptions(input) {
+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/dist/subagent-activity.d.ts

@@ -0,0 +1,11 @@
+import type { SDKTaskNotificationMessage, SDKTaskProgressMessage, SDKTaskStartedMessage, SDKTaskUpdatedMessage } from '@anthropic-ai/claude-agent-sdk';
+type ClaudeTaskMessage = SDKTaskNotificationMessage | SDKTaskProgressMessage | SDKTaskStartedMessage | SDKTaskUpdatedMessage;
+export interface ClaudeSubagentActivityBlock {
+    id: string;
+    kind: 'status';
+    status: 'running' | 'completed' | 'failed';
+    title: string;
+    text?: string;
+}
+export declare function mapClaudeSubagentActivity(message: ClaudeTaskMessage): ClaudeSubagentActivityBlock | null;
+export {};

package/dist/subagent-activity.js

@@ -0,0 +1,51 @@
+function titleForMessage(message) {
+    const subtype = message.subtype;
+    if (subtype === 'task_started') {
+        return message.subagent_type
+            ? `Subagent started: ${message.subagent_type}`
+            : 'Subagent started';
+    }
+    if (subtype === 'task_progress') {
+        return message.subagent_type
+            ? `Subagent progress: ${message.subagent_type}`
+            : 'Subagent progress';
+    }
+    if (subtype === 'task_updated')
+        return 'Subagent updated';
+    return `Subagent ${message.status}`;
+}
+function textForMessage(message) {
+    if (message.subtype === 'task_started')
+        return message.description;
+    if (message.subtype === 'task_progress')
+        return message.summary ?? message.description;
+    if (message.subtype === 'task_updated')
+        return message.patch.description ?? message.patch.error;
+    return message.summary;
+}
+function statusForMessage(message) {
+    if (message.subtype === 'task_notification') {
+        if (message.status === 'completed')
+            return 'completed';
+        return 'failed';
+    }
+    if (message.subtype === 'task_updated') {
+        if (message.patch.status === 'completed')
+            return 'completed';
+        if (message.patch.status === 'failed' || message.patch.status === 'killed')
+            return 'failed';
+    }
+    return 'running';
+}
+export function mapClaudeSubagentActivity(message) {
+    if ('skip_transcript' in message && message.skip_transcript)
+        return null;
+    const text = textForMessage(message);
+    return {
+        id: `task:${message.task_id}`,
+        kind: 'status',
+        status: statusForMessage(message),
+        title: titleForMessage(message),
+        ...(text ? { text } : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,10 +31,10 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-host": "^0.3.0",
-    "@canonmsg/agent-sdk": "^3.4.3",
+    "@canonmsg/agent-host": "^0.4.0",
+    "@canonmsg/agent-sdk": "^3.4.4",
     "@canonmsg/bridge": "^0.2.0",
-    "@canonmsg/core": "^3.1.0",
+    "@canonmsg/core": "^3.2.0",
     "@canonmsg/framework": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },