@canonmsg/claude-code-plugin 0.9.6 → 0.12.0

package/README.md

@@ -20,8 +20,8 @@ Send a message to your agent in the Canon app. Claude Code responds with full ca
 ## Features
 
 - **Two-way messaging** — Messages from Canon flow to Claude Code and back
-- **Session controls** — Switch model (Haiku/Sonnet/Opus) and permission mode from the app
-- **Live streaming** — See Claude's response as it types
+- **Session controls** — Canon renders setup and live controls from the runtime descriptor Claude publishes
+- **Live preview** — See Claude's current live preview/status in the app
 - **Interrupt** — Stop Claude mid-response from the app
 - **Context meter** — See context window usage in the app
 - **Max plan auth** — Uses your Claude subscription, no API key billing
@@ -32,6 +32,23 @@ Send a message to your agent in the Canon app. Claude Code responds with full ca
 canon-claude --cwd /path/to/project
 ```
 
+Advertise multiple project choices to the Canon app:
+
+```bash
+canon-claude --cwd ~/dev --workspace-root ~/dev
+```
+
+`--cwd` is the default workspace. Each `--workspace-root` value is an approved local root; the host discovers immediate child projects with common markers such as `.git`, `package.json`, `pyproject.toml`, `Cargo.toml`, or `go.mod` and publishes them as selectable projects during session creation. Use repeated `--workspace /path/to/project` entries to advertise specific projects outside those roots. Worktree mode creates a per-conversation git worktree under `~/.canon/conversation-worktrees`; shared-project mode runs directly in the selected directory.
+
+Current Canon truth for Claude host mode:
+
+- model is live-editable
+- thinking level / effort is live-editable when the host reports it
+- workspace selection is setup-only
+- execution mode selection is setup-only
+- permission modes are rendered exactly as the Claude runtime reports them; Canon does not flatten them to a smaller hardcoded set
+- if worktree creation is unavailable for the selected project, Canon may fall back to shared-project execution and surface the fallback reason in session details
+
 ## Multiple agents
 
 ```bash

package/dist/host-runtime.d.ts

@@ -98,17 +98,23 @@ export declare function publishHostSessionSnapshots(input: {
     liveSessionConfigByConversation?: ReadonlyMap<string, {
         model?: string;
         permissionMode?: string;
+        effort?: string;
+        runtimeControlValues?: Record<string, string>;
         workspaceId?: string;
         executionMode?: SessionWorkspaceConfig['executionMode'];
         executionBranch?: string | null;
     }>;
 }): Promise<void>;
-export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, string>>) | null;
+export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, string>> & {
+    runtimeControlValues?: Record<string, string>;
+}) | null;
 export declare function loadHostSessionConfig<TExtra extends string = never>(input: {
     conversationId: string;
     agentId: string;
     extraStringFields?: readonly TExtra[];
-}): Promise<(SessionWorkspaceConfig & Partial<Record<TExtra, string>>) | null>;
+}): Promise<(SessionWorkspaceConfig & Partial<Record<TExtra, string>> & {
+    runtimeControlValues?: Record<string, string>;
+}) | null>;
 export declare function resolveHostWorkspaceCwd(input: {
     workspaceOptions: HostWorkspaceResolverOption[];
     config: {

package/dist/host-runtime.js

@@ -145,7 +145,7 @@ export async function publishHostSessionSnapshots(input) {
         const persistedConfig = await loadHostSessionConfig({
             conversationId,
             agentId: input.agentId,
-            extraStringFields: ['permissionMode'],
+            extraStringFields: ['permissionMode', 'effort'],
         });
         const liveConfig = input.liveSessionConfigByConversation?.get(conversationId) ?? null;
         const mergedConfig = {
@@ -163,6 +163,10 @@ export async function publishHostSessionSnapshots(input) {
             sessionConfig: {
                 ...(mergedConfig.model ? { model: mergedConfig.model } : {}),
                 ...(mergedConfig.permissionMode ? { permissionMode: mergedConfig.permissionMode } : {}),
+                ...(mergedConfig.effort ? { effort: mergedConfig.effort } : {}),
+                ...(mergedConfig.runtimeControlValues
+                    ? { runtimeControlValues: mergedConfig.runtimeControlValues }
+                    : {}),
                 ...(mergedConfig.workspaceId ? { workspaceId: mergedConfig.workspaceId } : {}),
                 ...(mergedConfig.executionMode ? { executionMode: mergedConfig.executionMode } : {}),
             },
@@ -184,6 +188,8 @@ export async function publishHostSessionSnapshots(input) {
             hostMode: true,
             model: snapshot.model ?? null,
             permissionMode: snapshot.permissionMode ?? null,
+            effort: snapshot.effort ?? null,
+            runtimeControlValues: snapshot.runtimeControlValues ?? null,
             workspaceId: snapshot.workspaceId ?? null,
             executionMode: snapshot.executionMode ?? null,
             executionBranch,
@@ -205,9 +211,16 @@ export function readHostSessionConfig(raw, extraStringFields = []) {
         const value = normalizeOptionalString(data[field]);
         return value ? [[field, value]] : [];
     }));
+    const runtimeControlValues = Object.fromEntries(Object.entries(data.runtimeControlValues && typeof data.runtimeControlValues === 'object'
+        ? data.runtimeControlValues
+        : {}).flatMap(([key, value]) => {
+        const normalizedValue = normalizeOptionalString(value);
+        return normalizedValue ? [[key, normalizedValue]] : [];
+    }));
     return {
         ...(baseConfig ?? {}),
         ...extraConfig,
+        ...(Object.keys(runtimeControlValues).length > 0 ? { runtimeControlValues } : {}),
     };
 }
 export async function loadHostSessionConfig(input) {

package/dist/host.js

@@ -24,16 +24,196 @@ import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { query } from '@anthropic-ai/claude-agent-sdk';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { CLAUDE_PERMISSION_MODE_OPTIONS, buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, releaseConversationEnvironment, } from '@canonmsg/core';
+import { CLAUDE_PERMISSION_MODE_OPTIONS, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeRuntimeInfo, writeSessionState, clearSessionState, writeTurnState, releaseConversationEnvironment, } from '@canonmsg/core';
 import { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { createStreamingBuffer } from './streaming-buffer.js';
 import { runCli } from './cli-entry.js';
 let workingDir = process.cwd();
 let workspaceOptions = [];
+let workspaceRoots = [];
+let workspaceRootMetadata = [];
 let runtimeModels = [];
+const CLAUDE_METADATA_TTL_MS = 5 * 60 * 1000;
+let runtimeMetadata = {
+    account: null,
+    mcpServers: [],
+    commands: [],
+    agents: [],
+    plugins: [],
+    loadedAt: 0,
+};
+let runtimeMetadataRefresh = null;
+function buildClaudeRuntimeDescriptor(input) {
+    return {
+        coreControls: [
+            {
+                id: 'model',
+                label: 'Model',
+                options: input.models,
+                defaultValue: input.models[0]?.value ?? null,
+                availability: 'setup_and_live',
+                liveBehavior: 'immediate',
+                selectionPolicy: 'inherit',
+            },
+            {
+                id: 'workspace',
+                label: 'Project',
+                options: input.workspaces.map((workspace) => ({
+                    value: workspace.id,
+                    label: workspace.label,
+                    ...(workspace.description ? { description: workspace.description } : {}),
+                    ...(workspace.workspaceRootId ? { workspaceRootId: workspace.workspaceRootId } : {}),
+                    ...(workspace.workspaceRelativePath ? { workspaceRelativePath: workspace.workspaceRelativePath } : {}),
+                    ...(workspace.source ? { source: workspace.source } : {}),
+                })),
+                defaultValue: input.workspaces[0]?.id ?? null,
+                availability: 'setup',
+                liveBehavior: 'none',
+                selectionPolicy: 'inherit',
+                description: input.workspaceRoots?.length
+                    ? 'Choose one of the projects discovered inside the approved local roots for this host.'
+                    : 'Choose one of the local projects advertised by this host.',
+            },
+            {
+                id: 'executionMode',
+                label: 'Execution mode',
+                options: input.executionModes.map((mode) => ({
+                    value: mode,
+                    label: mode === 'worktree' ? 'Isolated worktree' : 'Use shared project',
+                    description: mode === 'worktree'
+                        ? 'Creates or reuses a per-conversation git worktree under ~/.canon/conversation-worktrees when the selected project is a git repo.'
+                        : 'Runs directly in the selected project folder. Changes happen there.',
+                })),
+                defaultValue: null,
+                availability: 'setup',
+                liveBehavior: 'none',
+                selectionPolicy: 'required_explicit',
+            },
+        ],
+        runtimeControls: [
+            {
+                id: 'permissionMode',
+                label: 'Permission mode',
+                options: [...CLAUDE_PERMISSION_MODE_OPTIONS],
+                defaultValue: 'default',
+                availability: 'setup_and_live',
+                liveBehavior: 'immediate',
+                selectionPolicy: 'inherit',
+            },
+            {
+                id: 'effort',
+                label: 'Thinking level',
+                options: [
+                    { value: 'low', label: 'Low' },
+                    { value: 'medium', label: 'Medium' },
+                    { value: 'high', label: 'High' },
+                ],
+                defaultValue: 'medium',
+                availability: 'setup_and_live',
+                liveBehavior: 'immediate',
+                selectionPolicy: 'inherit',
+            },
+        ],
+        actions: [
+            {
+                id: 'plan',
+                label: 'Plan first',
+                description: 'Switch Claude into Plan mode. Text after /plan is kept as a ready prompt while the mode applies.',
+                aliases: ['plan'],
+                category: 'plan',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                trailingTextBehavior: 'send_as_prompt',
+                dispatch: {
+                    kind: 'control',
+                    controlId: 'permissionMode',
+                    value: 'plan',
+                },
+            },
+            {
+                id: 'runtime-status',
+                label: 'Runtime status',
+                description: 'Open Claude runtime details, including account, project, and policy status.',
+                aliases: ['status'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'status' },
+            },
+            {
+                id: 'mcp-inventory',
+                label: 'MCP servers',
+                description: 'Open the Claude MCP inventory published by the host.',
+                aliases: ['mcp'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'mcp' },
+            },
+            {
+                id: 'plugin-inventory',
+                label: 'Plugins',
+                description: 'Open the Claude plugin and command inventory published by the host.',
+                aliases: ['plugins'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'plugins' },
+            },
+            {
+                id: 'model-details',
+                label: 'Model control',
+                description: 'Open runtime details and use the live Model control.',
+                aliases: ['model'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'model' },
+            },
+            {
+                id: 'permission-details',
+                label: 'Permission mode',
+                description: 'Open runtime details and use the live Permission mode control.',
+                aliases: ['permission'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'permissionMode' },
+            },
+            {
+                id: 'effort-details',
+                label: 'Thinking level',
+                description: 'Open runtime details and use the live Thinking level control.',
+                aliases: ['effort'],
+                category: 'details',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['always'],
+                dispatch: { kind: 'open_details', target: 'effort' },
+            },
+            {
+                id: 'stop',
+                label: 'Stop',
+                description: 'Interrupt the current Claude turn.',
+                aliases: ['stop'],
+                category: 'turn',
+                placements: ['composer_slash', 'command_palette'],
+                availability: ['busy'],
+                dispatch: { kind: 'signal', signal: 'interrupt' },
+            },
+        ],
+        workspaceRoots: input.workspaceRoots,
+        supportsInterrupt: true,
+        streamingTextMode: 'delta',
+    };
+}
+function normalizeClaudeEffortLevel(value) {
+    return value === 'low' || value === 'medium' || value === 'high'
+        ? value
+        : undefined;
+}
 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
@@ -83,18 +263,18 @@ async function loadSessionConfig(conversationId, agentId) {
     const config = await loadHostSessionConfig({
         conversationId,
         agentId,
-        extraStringFields: ['permissionMode'],
+        extraStringFields: ['permissionMode', 'effort'],
     });
     return {
         ...config,
         permissionMode: config?.permissionMode,
+        effort: normalizeClaudeEffortLevel(config?.effort),
     };
 }
-// Default to 'locked' (shared workspace) when no mode has been picked. The
-// UI still lets owners flip to 'worktree'; this just stops sessions from
-// failing closed when the mode has never been written.
 function resolveSessionExecutionMode(config) {
-    return config?.executionMode ?? 'locked';
+    if (config?.executionMode)
+        return config.executionMode;
+    throw new ExecutionEnvironmentError('Session config is missing an execution mode.', 'Choose Isolated worktree or Use shared project before starting this coding session.');
 }
 function resolveWorkspaceCwd(config) {
     return resolveHostWorkspaceCwd({
@@ -103,6 +283,14 @@ function resolveWorkspaceCwd(config) {
         defaultCwd: workingDir,
     });
 }
+function resolveExecutionFallbackReason(environment) {
+    if (!environment?.reason || environment.mode !== 'locked') {
+        return null;
+    }
+    return environment.reason === 'Sharing the base workspace (locked mode)'
+        ? null
+        : environment.reason;
+}
 async function detectRuntimeModels(cwd) {
     const emptyPrompt = {
         async *[Symbol.asyncIterator]() { },
@@ -130,6 +318,190 @@ async function detectRuntimeModels(cwd) {
         catch { }
     }
 }
+async function inspectClaudeRuntimeMetadata(cwd, activeQuery) {
+    const emptyPrompt = {
+        async *[Symbol.asyncIterator]() { },
+    };
+    const claudeCliPath = resolveClaudeCliPath();
+    const probe = activeQuery ?? query({
+        prompt: emptyPrompt,
+        options: {
+            systemPrompt: { type: 'preset', preset: 'claude_code' },
+            tools: { type: 'preset', preset: 'claude_code' },
+            permissionMode: 'default',
+            cwd,
+            settings: { forceLoginMethod: 'claudeai' },
+            ...(claudeCliPath ? { pathToClaudeCodeExecutable: claudeCliPath } : {}),
+        },
+    });
+    try {
+        const [init, mcpServers, pluginInfo] = await Promise.all([
+            probe.initializationResult(),
+            probe.mcpServerStatus().catch(() => []),
+            probe.reloadPlugins().catch(() => null),
+        ]);
+        return {
+            account: init.account ?? null,
+            mcpServers: pluginInfo?.mcpServers ?? mcpServers,
+            commands: pluginInfo?.commands ?? init.commands ?? [],
+            agents: pluginInfo?.agents ?? init.agents ?? [],
+            plugins: pluginInfo?.plugins ?? [],
+            loadedAt: Date.now(),
+        };
+    }
+    finally {
+        if (!activeQuery) {
+            try {
+                probe.close();
+            }
+            catch { }
+        }
+    }
+}
+async function refreshClaudeRuntimeMetadata(input) {
+    if (!input.force
+        && runtimeMetadata.loadedAt > 0
+        && Date.now() - runtimeMetadata.loadedAt < CLAUDE_METADATA_TTL_MS) {
+        return runtimeMetadata;
+    }
+    if (runtimeMetadataRefresh) {
+        return runtimeMetadataRefresh;
+    }
+    runtimeMetadataRefresh = inspectClaudeRuntimeMetadata(input.cwd, input.activeQuery ?? null)
+        .then((metadata) => {
+        runtimeMetadata = metadata;
+        return metadata;
+    })
+        .finally(() => {
+        runtimeMetadataRefresh = null;
+    });
+    return runtimeMetadataRefresh;
+}
+function mapClaudeMcpStatus(status) {
+    switch (status) {
+        case 'connected':
+            return 'ready';
+        case 'needs-auth':
+            return 'auth_needed';
+        case 'disabled':
+            return 'configured';
+        case 'failed':
+            return 'error';
+        default:
+            return 'unknown';
+    }
+}
+function buildClaudeRuntimeInfo(input) {
+    const { descriptor, metadata } = input;
+    const statusItems = [
+        metadata.account?.email
+            ? {
+                id: 'account',
+                label: 'Account',
+                value: metadata.account.email,
+                tone: 'success',
+            }
+            : null,
+        metadata.account?.subscriptionType
+            ? {
+                id: 'subscription',
+                label: 'Plan',
+                value: metadata.account.subscriptionType,
+            }
+            : null,
+        metadata.account?.apiProvider
+            ? {
+                id: 'provider',
+                label: 'Provider',
+                value: metadata.account.apiProvider,
+            }
+            : null,
+        metadata.account?.tokenSource || metadata.account?.apiKeySource
+            ? {
+                id: 'auth',
+                label: 'Auth',
+                value: metadata.account.tokenSource ?? metadata.account?.apiKeySource ?? 'connected',
+            }
+            : null,
+        runtimeModels[0]
+            ? {
+                id: 'fallbackModel',
+                label: 'Fallback model',
+                value: runtimeModels[0].label,
+            }
+            : null,
+        {
+            id: 'toolPolicy',
+            label: 'Tool policy',
+            value: 'Claude Code preset',
+        },
+        {
+            id: 'browser',
+            label: 'Browser tools',
+            value: 'Runtime policy',
+        },
+    ].filter((item) => Boolean(item));
+    return {
+        descriptor,
+        surfaceMode: 'host',
+        statusItems,
+        inventories: [
+            {
+                id: 'mcp',
+                label: 'MCP',
+                entries: metadata.mcpServers.map((server) => ({
+                    id: server.name,
+                    label: server.name,
+                    status: mapClaudeMcpStatus(server.status),
+                    description: server.error
+                        ?? server.serverInfo?.version
+                        ?? server.scope
+                        ?? undefined,
+                })),
+            },
+            {
+                id: 'plugins',
+                label: 'Plugins',
+                entries: metadata.plugins.map((plugin) => ({
+                    id: plugin.name,
+                    label: plugin.name,
+                    status: 'configured',
+                    description: plugin.source ?? plugin.path,
+                })),
+            },
+            {
+                id: 'commands',
+                label: 'Commands',
+                entries: metadata.commands.map((command) => ({
+                    id: command.name,
+                    label: command.name.startsWith('/') ? command.name : `/${command.name}`,
+                    status: 'configured',
+                    description: command.description ?? command.argumentHint ?? undefined,
+                })),
+            },
+            {
+                id: 'agents',
+                label: 'Agents',
+                entries: metadata.agents.map((agent) => ({
+                    id: agent.name,
+                    label: agent.name,
+                    status: 'configured',
+                    description: agent.description ?? agent.model ?? undefined,
+                })),
+            },
+        ],
+        execution: {
+            resolvedWorkspaceLabel: input.workspaceLabel,
+            resolvedCwd: input.resolvedCwd,
+            workspaceRootId: input.workspaceRootId ?? null,
+            workspaceRelativePath: input.workspaceRelativePath ?? null,
+            executionMode: input.executionMode,
+            executionBranch: input.executionBranch,
+            worktreePath: input.worktreePath,
+            fallbackReason: input.fallbackReason,
+        },
+    };
+}
 // ── Constants ───────────────────────────────────────────────────────
 const MAX_SESSIONS = 5;
 const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
@@ -245,6 +617,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
         systemPrompt: { type: 'preset', preset: 'claude_code' },
         tools: { type: 'preset', preset: 'claude_code' },
         permissionMode: config.permissionMode,
+        allowDangerouslySkipPermissions: true,
         cwd,
         includePartialMessages: true,
         maxTurns: 200,
@@ -284,7 +657,30 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
             if (toolName === 'ExitPlanMode') {
                 try {
                     const planId = randomUUID();
-                    const planApproval = buildPlanApprovalRequest(planId);
+                    const allowedPrompts = Array.isArray(input.allowedPrompts)
+                        ? input.allowedPrompts
+                            .map((entry) => {
+                            if (!entry || typeof entry !== 'object') {
+                                return null;
+                            }
+                            const prompt = entry.prompt;
+                            const tool = entry.tool;
+                            if (typeof prompt !== 'string' || !prompt.trim()) {
+                                return null;
+                            }
+                            return {
+                                tool: typeof tool === 'string' && tool.trim() ? tool : 'Tool',
+                                prompt,
+                            };
+                        })
+                            .filter((entry) => Boolean(entry))
+                        : [];
+                    const planApproval = buildPlanApprovalRequest(planId, 'Plan ready for review.', allowedPrompts.length > 0 ? {
+                        summary: 'Claude has prepared a plan and is asking permission to continue.',
+                        allowedPrompts,
+                    } : {
+                        summary: 'Claude has prepared a plan and is asking permission to continue.',
+                    });
                     await client.sendMessage(conversationId, planApproval.text, {
                         metadata: {
                             ...planApproval.metadata,
@@ -344,6 +740,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
         currentTurnOpenedAt: null,
         lastAcceptedIntent: null,
         lastActivity: Date.now(),
+        typingKeepaliveTimer: null,
         closed: false,
         sdkSessionId: resumeSessionId || null,
         pendingReply: null,
@@ -400,6 +797,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
         session.pendingFinalDeliveryText = null;
         session.toolInProgress = false;
         session.turnState = 'idle';
+        stopVisibleWorkSignal();
         writeTurn();
         drainPendingInput();
     }
@@ -418,6 +816,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
         session.pendingFinalDeliveryText = finalText;
         session.state.state = 'running';
         session.turnState = 'streaming';
+        stopVisibleWorkSignal();
         streamingBuffer.replace(finalText);
         writeState();
         writeTurn();
@@ -468,6 +867,10 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
             cwd,
             executionMode: session.environment.mode,
             ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+            ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
+            ...(resolveExecutionFallbackReason(session.environment)
+                ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
+                : {}),
             hostMode: true,
             isActive: true,
         }).catch(() => { });
@@ -486,6 +889,25 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 : {}),
         }).catch(() => { });
     }
+    function refreshVisibleWorkSignal() {
+        if (session.closed)
+            return;
+        if (session.turnState !== 'thinking' && session.turnState !== 'tool')
+            return;
+        client.setTyping(conversationId, true, 'thinking').catch(() => { });
+    }
+    function startVisibleWorkSignal() {
+        refreshVisibleWorkSignal();
+        if (session.typingKeepaliveTimer)
+            return;
+        session.typingKeepaliveTimer = setInterval(refreshVisibleWorkSignal, 3500);
+    }
+    function stopVisibleWorkSignal() {
+        if (session.typingKeepaliveTimer) {
+            clearInterval(session.typingKeepaliveTimer);
+            session.typingKeepaliveTimer = null;
+        }
+    }
     async function markQueuedMessageAccepted(sourceMessageId, markAccepted) {
         if (!markAccepted || !sourceMessageId)
             return;
@@ -517,6 +939,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
         if (session.state.state === 'running' && intent === 'interrupt') {
             session.pendingInputs.unshift({ msg, intent, sourceMessageId, markAccepted });
             session.turnState = 'interrupted';
+            stopVisibleWorkSignal();
             writeTurn();
             void session.query.interrupt().catch(() => { });
             return;
@@ -557,18 +980,22 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                         if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
                             session.toolInProgress = true;
                             session.turnState = 'tool';
+                            startVisibleWorkSignal();
                             writeTurn();
                         }
                         else if (event?.type === 'content_block_stop' && session.toolInProgress) {
                             session.toolInProgress = false;
                             if (session.state.state === 'running') {
                                 session.turnState = 'thinking';
+                                startVisibleWorkSignal();
                                 writeTurn();
                             }
                         }
                         else if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
                             session.toolInProgress = false;
                             session.turnState = 'streaming';
+                            stopVisibleWorkSignal();
+                            client.setTyping(conversationId, false).catch(() => { });
                             writeTurn();
                             onStreamDelta(event.delta.text);
                         }
@@ -589,9 +1016,10 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                                 session.pendingFinalText = null;
                                 session.toolInProgress = false;
                                 session.turnState = 'thinking';
-                                client.setTyping(conversationId, true, 'thinking').catch(() => { });
+                                startVisibleWorkSignal();
                             }
                             else if (state === 'idle') {
+                                stopVisibleWorkSignal();
                                 client.setTyping(conversationId, false).catch(() => { });
                             }
                             else if (state === 'requires_action') {
@@ -602,6 +1030,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                                 }
                                 session.toolInProgress = false;
                                 session.turnState = 'waiting_input';
+                                stopVisibleWorkSignal();
                                 client.setTyping(conversationId, false).catch(() => { });
                             }
                             writeState();
@@ -668,6 +1097,15 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial model:`, err);
             }
         }
+        if (config.effort) {
+            try {
+                await q.applyFlagSettings({ effortLevel: 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({
@@ -692,6 +1130,12 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 availableExecutionModes: config.availableExecutionModes,
+                runtimeDescriptor: buildClaudeRuntimeDescriptor({
+                    models: modelList,
+                    workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                    workspaceRoots: workspaceRootMetadata,
+                    executionModes: config.availableExecutionModes,
+                }),
             });
             writeSessionState(conversationId, agentId, {
                 ...session.state,
@@ -699,6 +1143,10 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 cwd,
                 executionMode: session.environment.mode,
                 ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+                ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
+                ...(resolveExecutionFallbackReason(session.environment)
+                    ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
+                    : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
@@ -720,12 +1168,24 @@ export async function main() {
         options: {
             cwd: { type: 'string' },
             workspace: { type: 'string', multiple: true },
+            'workspace-root': { type: 'string', multiple: true },
         },
         strict: false,
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const configuredWorkspaces = (args.workspace ?? []).filter((value) => typeof value === 'string');
-    workspaceOptions = buildConfiguredWorkspaceOptions(workingDir, configuredWorkspaces);
+    const configuredWorkspaceRoots = (args['workspace-root'] ?? []).filter((value) => typeof value === 'string');
+    const workspaceDiscovery = buildConfiguredWorkspaceOptionsWithRoots({
+        primaryCwd: workingDir,
+        configuredWorkspaces,
+        workspaceRoots: configuredWorkspaceRoots,
+    });
+    workspaceOptions = workspaceDiscovery.workspaceOptions;
+    workspaceRoots = workspaceDiscovery.workspaceRoots;
+    workspaceRootMetadata = buildPublicWorkspaceRoots(workspaceRoots);
+    for (const warning of workspaceDiscovery.warnings) {
+        console.error(`[canon-host] ${warning}`);
+    }
     const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-host]' });
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     // ── Canon API client + RTDB auth ──
@@ -759,6 +1219,12 @@ export async function main() {
         availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         availableExecutionModes: hostAvailableExecutionModes,
+        runtimeDescriptor: buildClaudeRuntimeDescriptor({
+            models: runtimeModels,
+            workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+            workspaceRoots: workspaceRootMetadata,
+            executionModes: hostAvailableExecutionModes,
+        }),
     };
     const conversationCache = new Map();
     const knownConversationIds = new Set();
@@ -769,6 +1235,14 @@ export async function main() {
         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);
         });
@@ -786,6 +1260,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 } : {}),
                         ...(workspaceId ? { workspaceId } : {}),
                         executionMode: session.environment.mode,
                         executionBranch: session.environment.branch ?? null,
@@ -795,6 +1270,33 @@ export async function main() {
         }).catch((error) => {
             console.error('[canon-host] Failed to publish session snapshots:', error);
         });
+        await Promise.all(Array.from(knownConversationIds).map(async (conversationId) => {
+            const session = sessions.get(conversationId);
+            const workspaceId = session
+                ? resolveWorkspaceIdForBaseCwd(session.environment.baseCwd)
+                : runtimeDescriptor.defaultWorkspaceId;
+            const workspace = workspaceOptions.find((option) => option.id === workspaceId) ?? null;
+            const payload = buildClaudeRuntimeInfo({
+                descriptor: runtimeDescriptor.runtimeDescriptor ?? buildClaudeRuntimeDescriptor({
+                    models: runtimeModels,
+                    workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                    workspaceRoots: workspaceRootMetadata,
+                    executionModes: hostAvailableExecutionModes,
+                }),
+                metadata,
+                workspaceLabel: workspace?.label ?? workspaceId ?? null,
+                resolvedCwd: session?.cwd ?? workspace?.cwd ?? workingDir,
+                workspaceRootId: workspace?.workspaceRootId ?? null,
+                workspaceRelativePath: workspace?.workspaceRelativePath ?? null,
+                executionMode: session?.environment.mode ?? null,
+                executionBranch: session?.environment.branch ?? null,
+                worktreePath: session?.environment.worktreePath ?? null,
+                fallbackReason: resolveExecutionFallbackReason(session?.environment),
+            });
+            await writeRuntimeInfo(conversationId, agentId, payload);
+        })).catch((error) => {
+            console.error('[canon-host] Failed to publish runtime info:', error);
+        });
     };
     // ── Load conversations (informational — sessions created on demand) ──
     try {
@@ -807,6 +1309,12 @@ export async function main() {
             availableModels: runtimeModels,
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
+            runtimeDescriptor: buildClaudeRuntimeDescriptor({
+                models: runtimeModels,
+                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                workspaceRoots: workspaceRootMetadata,
+                executionModes: hostAvailableExecutionModes,
+            }),
         };
     }
     catch {
@@ -816,6 +1324,12 @@ export async function main() {
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
+            runtimeDescriptor: buildClaudeRuntimeDescriptor({
+                models: runtimeModels,
+                workspaces: buildPublicWorkspaceOptions(workspaceOptions),
+                workspaceRoots: workspaceRootMetadata,
+                executionModes: hostAvailableExecutionModes,
+            }),
         };
     }
     try {
@@ -873,6 +1387,10 @@ export async function main() {
         if (!session)
             return;
         session.closed = true;
+        if (session.typingKeepaliveTimer) {
+            clearInterval(session.typingKeepaliveTimer);
+            session.typingKeepaliveTimer = null;
+        }
         releaseConversationEnvironment(session.environment);
         // Save SDK session ID for future resume
         if (session.sdkSessionId) {
@@ -958,6 +1476,7 @@ export async function main() {
                 }, {
                     model: config?.model ?? runtimeModels[0]?.value,
                     permissionMode: config?.permissionMode ?? 'default',
+                    effort: config?.effort,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
                 }, resumeId);
@@ -1060,7 +1579,12 @@ export async function main() {
                         const message = error instanceof Error ? error.message : String(error);
                         const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
                         console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to create session: ${message}`);
-                        await client.sendMessage(convoId, `I couldn't start a coding session for this workspace: ${userMessage}`).catch(() => { });
+                        await client.sendMessage(convoId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+                            metadata: {
+                                turnSemantics: 'turn_complete',
+                                turnComplete: true,
+                            },
+                        }).catch(() => { });
                         return;
                     }
                     const turnMetadata = normalizeTurnMetadata(m.metadata);
@@ -1139,12 +1663,16 @@ export async function main() {
                                         console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set mode:`, err);
                                     }
                                 }
-                                if (ctrl.effort && ctrl.effort !== session.state.effort) {
-                                    session.state.effort = ctrl.effort;
-                                    session.query.applyFlagSettings({
-                                        effortLevel: ctrl.effort,
-                                    }).catch((err) => console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set effort:`, err));
-                                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Effort → ${ctrl.effort}`);
+                                const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
+                                if (nextEffort && nextEffort !== session.state.effort) {
+                                    try {
+                                        await session.query.applyFlagSettings({ effortLevel: nextEffort });
+                                        session.state.effort = nextEffort;
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Effort → ${nextEffort}`);
+                                    }
+                                    catch (err) {
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set effort:`, err);
+                                    }
                                 }
                                 writeSessionState(convoId, agentId, {
                                     ...session.state,
@@ -1152,6 +1680,10 @@ export async function main() {
                                     cwd: session.cwd,
                                     executionMode: session.environment.mode,
                                     ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+                                    ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
+                                    ...(resolveExecutionFallbackReason(session.environment)
+                                        ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
+                                        : {}),
                                     hostMode: true,
                                     isActive: true,
                                 }).catch(() => { });
@@ -1213,6 +1745,7 @@ export async function main() {
                 cwd: session.cwd,
                 executionMode: session.environment.mode,
                 ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
+                ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });

package/dist/server.js

@@ -26,6 +26,10 @@ let agentContext = null;
 let approvalManager = null;
 let approvalServer = null;
 const conversationCache = new Map();
+const TURN_COMPLETE_METADATA = {
+    turnSemantics: 'turn_complete',
+    turnComplete: true,
+};
 /** The conversation that most recently triggered work (for approval routing) */
 let triggerConversationId = null;
 function getPrimaryAttachment(message) {
@@ -221,7 +225,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         case 'reply': {
             const conversationId = args.conversation_id;
             const text = args.text;
-            const result = await client.sendMessage(conversationId, text);
+            const result = await client.sendMessage(conversationId, text, {
+                metadata: TURN_COMPLETE_METADATA,
+            });
             return {
                 content: [
                     {
@@ -261,6 +267,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             else {
                 opts.contentType = contentType;
             }
+            opts.metadata = {
+                ...(opts.metadata ?? {}),
+                ...TURN_COMPLETE_METADATA,
+            };
             const result = await client.sendMessage(conversationId, text, opts);
             return {
                 content: [
@@ -288,6 +298,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const messageOptions = typeof args.message_options === 'object' && args.message_options != null
                 ? args.message_options
                 : undefined;
+            const linkedMessageOptions = messageOptions;
             const result = await client.sendLinkedMessage({
                 sourceConversationId,
                 targetConversationId,
@@ -308,11 +319,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         targetContext: targetContext,
                     }
                     : {}),
-                ...(messageOptions
+                ...(linkedMessageOptions
                     ? {
-                        messageOptions: messageOptions,
+                        messageOptions: {
+                            ...linkedMessageOptions,
+                            metadata: {
+                                ...(linkedMessageOptions.metadata ?? {}),
+                                ...TURN_COMPLETE_METADATA,
+                            },
+                        },
                     }
-                    : {}),
+                    : { messageOptions: { metadata: TURN_COMPLETE_METADATA } }),
             });
             return {
                 content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.9.6",
+  "version": "0.12.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.101",
-    "@canonmsg/agent-sdk": "^0.8.3",
-    "@canonmsg/core": "^0.7.5",
+    "@canonmsg/agent-sdk": "^0.9.2",
+    "@canonmsg/core": "^0.10.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {