@canonmsg/claude-code-plugin 0.20.0 → 0.21.0

package/dist/host.js

@@ -37,6 +37,8 @@ import { runCli } from './cli-entry.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
 import { buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { claudeThinkingToFlagValue, claudeThinkingToConfig, parseClaudeSessionDefaults, parseClaudeThinkingMode, parseClaudeUltracodeMode, resolveEffectiveSessionSettings, } from './session-defaults.js';
+import { 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: [
             {
@@ -561,13 +611,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,6 +867,7 @@ 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' },
@@ -817,7 +877,16 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         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) => {
@@ -1029,6 +1098,8 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             model: undefined,
             permissionMode: config.permissionMode,
             effort: undefined,
+            fallbackModel: config.sessionSettings.fallbackModel,
+            runtimeControlValues: config.sessionSettings.runtimeControlValues,
             state: 'idle',
         },
         availableModels: config.availableModels,
@@ -1073,6 +1144,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             model: config.model,
             permissionMode: config.permissionMode,
             effort: config.effort,
+            runtimeControlValues: config.sessionSettings.runtimeControlValues,
         },
     }, {
         session: () => session,
@@ -1213,6 +1285,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 +1316,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 +1348,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 +1388,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                                 }
                                 session.state.contextUsage = undefined;
                                 session.pendingFinalText = null;
+                                assistantStreamOrdinal = 0;
                                 session.toolInProgress = false;
                                 session.turnState = 'thinking';
                                 startVisibleWorkSignal();
@@ -1429,13 +1529,14 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             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,
@@ -1488,7 +1589,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 +1680,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,
@@ -1636,6 +1740,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,
@@ -1651,8 +1758,10 @@ export async function main() {
         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 +1789,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 +1807,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 +1815,7 @@ export async function main() {
             availableExecutionModes: hostAvailableExecutionModes,
             runtimeDescriptor: buildClaudeRuntimeDescriptor({
                 models: runtimeModels,
+                defaults: profileSessionDefaults,
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
@@ -1712,12 +1826,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 +1963,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 +2014,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,
@@ -2307,6 +2428,49 @@ export async function main() {
         else if (ctrl.effort && !nextEffort) {
             session.setRuntimeControlError('effort', String(ctrl.effort), new Error('Unsupported Claude thinking level.'));
         }
+        const runtimeControlValues = ctrl.runtimeControlValues ?? {};
+        if ('thinking' in runtimeControlValues) {
+            const nextThinking = parseClaudeThinkingMode(runtimeControlValues.thinking);
+            if (!nextThinking) {
+                session.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
+            }
+            else if (nextThinking !== session.state.runtimeControlValues?.thinking) {
+                try {
+                    await session.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) });
+                    session.state.runtimeControlValues = {
+                        ...(session.state.runtimeControlValues ?? {}),
+                        thinking: nextThinking,
+                    };
+                    session.clearRuntimeControlError('thinking');
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Thinking → ${nextThinking}`);
+                }
+                catch (err) {
+                    session.setRuntimeControlError('thinking', nextThinking, err);
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set thinking:`, err);
+                }
+            }
+        }
+        if ('ultracode' in runtimeControlValues) {
+            const nextUltracode = parseClaudeUltracodeMode(runtimeControlValues.ultracode);
+            if (!nextUltracode) {
+                session.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
+            }
+            else if (nextUltracode !== session.state.runtimeControlValues?.ultracode) {
+                try {
+                    await session.query.applyFlagSettings({ ultracode: nextUltracode === 'on' });
+                    session.state.runtimeControlValues = {
+                        ...(session.state.runtimeControlValues ?? {}),
+                        ultracode: nextUltracode,
+                    };
+                    session.clearRuntimeControlError('ultracode');
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Ultracode → ${nextUltracode}`);
+                }
+                catch (err) {
+                    session.setRuntimeControlError('ultracode', nextUltracode, err);
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set ultracode:`, err);
+                }
+            }
+        }
         session.writeState();
     }
     // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──

package/dist/session-defaults.d.ts

@@ -0,0 +1,34 @@
+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 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,123 @@
+const CLAUDE_EFFORT_VALUES = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
+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/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.0",
   "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"
   },