@canonmsg/claude-code-plugin 0.31.4 → 0.33.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "Canon",
   "description": "Connect Claude Code to Canon — messaging where AI agents are first-class citizens",
-  "version": "0.31.4",
+  "version": "0.33.0",
   "channels": [
     {
       "server": "canon-channel",

package/dist/host.d.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { type PermissionResult, type SDKControlReloadPluginsResponse } from '@anthropic-ai/claude-agent-sdk';
-import { type CanonRuntimeCommandDescriptor, type HostInboundParticipantContext as InboundParticipantContext, type CanonReplyContext, type MessageCreatedPayload, type ResolvedAgentBehaviorPolicy, type TurnVerbosityConfig } from '@canonmsg/core';
+import { type RecoveryCheckpointTracker } from '@canonmsg/coding-agent-host';
+import { type CanonRuntimeCommandDescriptor, type ExecutionEnvironmentMode, type HostInboundParticipantContext as InboundParticipantContext, type CanonReplyContext, type MessageCreatedPayload, type ResolvedAgentBehaviorPolicy, type TurnVerbosityConfig } from '@canonmsg/core';
 /**
  * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
  * per-conversation-type default".
@@ -24,6 +25,10 @@ export declare function buildClaudePlanAllowResult(input: Record<string, unknown
  * through. Canon-injected aliases keep precedence over native names.
  */
 export declare function buildNativeSlashCommandDescriptors(native: SDKControlReloadPluginsResponse['commands'], reservedAliases: ReadonlySet<string>): CanonRuntimeCommandDescriptor[];
+export declare function resolveSessionExecutionMode(config: {
+    executionMode?: ExecutionEnvironmentMode;
+} | null | undefined, defaultExecutionMode?: ExecutionEnvironmentMode): ExecutionEnvironmentMode;
+export declare function createClaudeRecoveryCheckpointTracker(persist: (messageId: string) => boolean): RecoveryCheckpointTracker;
 export declare const NO_REPLY_TOOL_NAME: string;
 export declare function buildCanonPrompt(input: {
     content: string;

package/dist/host.js

@@ -27,7 +27,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
-import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
 import { buildCanonUserContent, renderClaudeInboundContent, withClaudeReplyContextMediaReferences, } from './canon-user-content.js';
 import { EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { runCli } from '@canonmsg/core';
@@ -53,6 +53,8 @@ COMMON FLAGS
   --cwd <path>             Project directory to run Claude Code from
   --workspace <path>       Additional project to expose in Canon
   --workspace-root <path>  Discover projects under an approved root
+  --default-execution-mode <worktree|locked>
+                          Default for new Canon conversations
   --runtime-visibility <normal|minimal|full>
                           Detail visibility preset
   --show-runtime-detail <field>
@@ -271,6 +273,7 @@ function buildClaudeRuntimeDescriptor(input) {
         workspaces: input.workspaces,
         workspaceRoots: input.workspaceRoots,
         executionModes: input.executionModes,
+        defaultExecutionMode: input.defaultExecutionMode,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         effortOptions: [...EFFORT_OPTIONS],
@@ -431,10 +434,15 @@ async function loadSessionConfig(conversationId, agentId, rtdb) {
         ultracode: parseClaudeUltracodeMode(config?.runtimeControlValues?.ultracode),
     };
 }
-function resolveSessionExecutionMode(config) {
-    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.');
+export function resolveSessionExecutionMode(config, defaultExecutionMode = 'worktree') {
+    return config?.executionMode ?? defaultExecutionMode;
+}
+function resolveConfiguredDefaultExecutionMode(value) {
+    if (value == null || value === '')
+        return 'worktree';
+    if (value === 'worktree' || value === 'locked')
+        return value;
+    throw new Error('--default-execution-mode must be worktree or locked');
 }
 function resolveWorkspaceCwd(config) {
     return resolveHostWorkspaceCwd({
@@ -728,6 +736,9 @@ const FINAL_DELIVERY_RETRY_MS = 30_000;
 // without delaying anything that was going to fail anyway.
 const MAX_FINAL_DELIVERY_RETRIES = 2;
 const CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID = 'claude-recovery-cursor-v1';
+export function createClaudeRecoveryCheckpointTracker(persist) {
+    return createRecoveryCheckpointTracker(persist);
+}
 const CLAUDE_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
@@ -979,7 +990,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     const turnKey = session.activeInput?.turnKey;
                     if (turnKey)
                         session.silencedTurnKeys.add(turnKey);
-                }),
+                }, { communication: config.communicationEnabled !== false }),
             },
         },
         ...(claudeCliPath ? { pathToClaudeCodeExecutable: claudeCliPath } : {}),
@@ -1260,19 +1271,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     function markInputCompleted(input) {
         if (input?.kind !== 'canon' || !input.sourceMessageId)
             return;
-        if (config.runtimeId) {
-            try {
-                saveRuntimeSessionState(config.runtimeId, {
-                    conversationId,
-                    baseCwd: config.recoveryBaseCwd ?? environment.baseCwd,
-                    workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
-                    lastInboundMessageId: input.sourceMessageId,
-                });
-            }
-            catch (error) {
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to persist inbound recovery cursor:`, error instanceof Error ? error.message : error);
-            }
-        }
         config.onInputCompleted?.(input.sourceMessageId);
     }
     /**
@@ -2396,11 +2394,13 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 availableExecutionModes: config.availableExecutionModes,
+                defaultExecutionMode: config.defaultExecutionMode,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: modelList,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: config.availableExecutionModes,
+                    defaultExecutionMode: config.defaultExecutionMode,
                     presentation: config.runtimePresentation,
                 }),
             });
@@ -2430,6 +2430,7 @@ export async function main() {
             cwd: { type: 'string' },
             workspace: { type: 'string', multiple: true },
             'workspace-root': { type: 'string', multiple: true },
+            'default-execution-mode': { type: 'string' },
             'runtime-visibility': { type: 'string' },
             'show-runtime-detail': { type: 'string', multiple: true },
             'hide-runtime-detail': { type: 'string', multiple: true },
@@ -2442,6 +2443,7 @@ export async function main() {
         env: process.env.CANON_TURN_VERBOSITY,
         onWarning: (message) => console.error(`[canon-host] ${message}`),
     });
+    const defaultExecutionMode = resolveConfiguredDefaultExecutionMode(args['default-execution-mode']);
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const configuredWorkspaces = (args.workspace ?? []).filter((value) => typeof value === 'string');
     const configuredWorkspaceRoots = (args['workspace-root'] ?? []).filter((value) => typeof value === 'string');
@@ -2482,11 +2484,13 @@ export async function main() {
     let agentId;
     let ownerId = null;
     let ownerName = null;
+    let communicationEnabled = true;
     try {
         const ctx = await client.getAgentMe();
         agentId = ctx.agentId;
         ownerId = ctx.ownerId;
         ownerName = ctx.ownerName;
+        communicationEnabled = ctx.outboundPolicy !== 'closed';
         console.error(`[canon-host] Connected as ${ctx.displayName || agentId}`);
     }
     catch {
@@ -2544,6 +2548,7 @@ export async function main() {
         hide: stringArgs(args['hide-runtime-detail']),
     });
     let runtimeDescriptor = {
+        defaultExecutionMode,
         defaultWorkspaceId: workspaceOptions[0]?.id,
         defaultPermissionMode: 'default',
         availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
@@ -2554,6 +2559,7 @@ export async function main() {
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
+            defaultExecutionMode,
             presentation: runtimePresentation,
         }),
     };
@@ -2632,6 +2638,7 @@ export async function main() {
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: hostAvailableExecutionModes,
+                    defaultExecutionMode,
                     presentation: runtimePresentation,
                 }),
             };
@@ -2666,6 +2673,7 @@ export async function main() {
     try {
         runtimeModels = await detectRuntimeModels(workingDir);
         runtimeDescriptor = {
+            defaultExecutionMode,
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
@@ -2678,12 +2686,14 @@ export async function main() {
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
+                defaultExecutionMode,
                 presentation: runtimePresentation,
             }),
         };
     }
     catch {
         runtimeDescriptor = {
+            defaultExecutionMode,
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
@@ -2694,6 +2704,7 @@ export async function main() {
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
+                defaultExecutionMode,
                 presentation: runtimePresentation,
             }),
         };
@@ -2716,6 +2727,15 @@ export async function main() {
     }
     // ── Session manager ──
     const sessions = new Map();
+    const recoveryCheckpointTrackers = new Map();
+    function recoveryCheckpointsFor(conversationId) {
+        let tracker = recoveryCheckpointTrackers.get(conversationId);
+        if (!tracker) {
+            tracker = createClaudeRecoveryCheckpointTracker((messageId) => persistConversationRecoveryCursor(conversationId, messageId));
+            recoveryCheckpointTrackers.set(conversationId, tracker);
+        }
+        return tracker;
+    }
     const approvalManager = ownerId ? new ApprovalManager(client, agentId, ownerId) : null;
     // Interactive runtime input (AskUserQuestion) works with or without an owner,
     // so its poll engine is always present. Create + poll fold onto the built-in
@@ -2944,10 +2964,12 @@ export async function main() {
         const session = sessions.get(conversationId);
         if (!session || session.pendingInputs.length === 0)
             return;
-        const before = session.pendingInputs.length;
-        session.pendingInputs = session.pendingInputs.filter((input) => input.sourceMessageId !== sourceMessageId);
-        if (session.pendingInputs.length === before)
+        const removed = session.pendingInputs.filter((input) => input.sourceMessageId === sourceMessageId);
+        if (removed.length === 0)
             return;
+        session.pendingInputs = session.pendingInputs.filter((input) => input.sourceMessageId !== sourceMessageId);
+        for (const input of removed)
+            session.markInputCompleted(input);
         session.writeTurn();
     }
     function evictOldestIdle() {
@@ -2979,7 +3001,7 @@ export async function main() {
         }
         const creation = (async () => {
             const config = await loadSessionConfig(conversationId, agentId, rtdb);
-            const sessionExecutionMode = resolveSessionExecutionMode(config);
+            const sessionExecutionMode = resolveSessionExecutionMode(config, defaultExecutionMode);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
                 agentId,
@@ -3040,14 +3062,16 @@ export async function main() {
                     ultracode: config?.ultracode,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
+                    defaultExecutionMode,
                     runtimePresentation,
                     approvalManager,
                     runtimeInputManager,
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
-                    recoveryBaseCwd: workingDir,
                     ownerId,
+                    communicationEnabled,
                     onInputCompleted: (sourceMessageId) => {
+                        recoveryCheckpointsFor(conversationId).settle(sourceMessageId);
                         settleInboundMessageId(sourceMessageId, true);
                     },
                     publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
@@ -3239,16 +3263,44 @@ export async function main() {
             workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
         })?.lastInboundMessageId ?? null;
     }
+    function persistConversationRecoveryCursor(conversationId, messageId) {
+        try {
+            saveRuntimeSessionState(runtimeId, {
+                conversationId,
+                baseCwd: workingDir,
+                workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
+                lastInboundMessageId: messageId,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to persist inbound recovery cursor:`, error instanceof Error ? error.message : error);
+            return false;
+        }
+    }
+    let startupRecoveryComplete = false;
     async function performMissedInboundRecovery() {
+        const knownBeforeRefresh = new Set(knownConversationIds);
+        await refreshKnownConversationIds(true);
+        const conversationsDiscoveredWhileOffline = startupRecoveryComplete
+            ? new Set([...knownConversationIds].filter((id) => !knownBeforeRefresh.has(id)))
+            : new Set();
         for (const conversationId of knownConversationIds) {
+            const recoveryCheckpoints = recoveryCheckpointsFor(conversationId);
+            const recoveryBatch = recoveryCheckpoints.reserveBatch();
             try {
                 const recovered = await collectMissedInboundMessages({
                     fetchPage: (before) => client.getMessagesPage(conversationId, STARTUP_RECOVERY_PAGE_SIZE, before),
                     cursor: persistedConversationCursor(conversationId),
                     agentId,
+                    requireContiguousCursor: true,
+                    noCursorMode: conversationsDiscoveredWhileOffline.has(conversationId)
+                        ? 'bounded-window'
+                        : 'latest-only',
                 });
-                if (recovered.mode === 'truncated-window') {
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovery cursor was not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; replaying the bounded recent window`);
+                recoveryBatch.commit(recovered.messages.map((message) => message.id), recovered.mode === 'incomplete-gap' ? recovered.recoveryCursor : null);
+                if (recovered.mode === 'incomplete-gap') {
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] recovery_incomplete_gap: cursor is missing; replaying ${recovered.messages.length} bounded inbound message(s) before advancing to ${recovered.recoveryCursor ?? 'no cursor'}`);
                 }
                 for (const message of recovered.messages) {
                     if (!claimInboundMessageId(message.id))
@@ -3268,8 +3320,10 @@ export async function main() {
                                 }) === 'queued';
                             }
                         }
-                        if (!queued)
+                        if (!queued) {
+                            recoveryCheckpoints.settle(message.id);
                             settleInboundMessageId(message.id, true);
+                        }
                     }
                     catch (error) {
                         settleInboundMessageId(message.id, false);
@@ -3281,21 +3335,14 @@ export async function main() {
                 }
             }
             catch (error) {
+                recoveryBatch.cancel();
                 console.error(`[canon-host] [${conversationId.slice(0, 8)}] Startup recovery failed:`, error instanceof Error ? error.message : error);
             }
         }
+        startupRecoveryComplete = true;
     }
-    let recoveryInFlight = null;
-    function recoverMissedInboundMessages() {
-        if (recoveryInFlight)
-            return recoveryInFlight;
-        recoveryInFlight = performMissedInboundRecovery().finally(() => {
-            recoveryInFlight = null;
-        });
-        return recoveryInFlight;
-    }
-    const shouldRecoverAfterStreamConnect = createReconnectRecoveryGate();
-    await recoverMissedInboundMessages();
+    const reconnectRecovery = createReconnectRecoveryCoordinator(performMissedInboundRecovery);
+    await reconnectRecovery.recoverNow();
     // ── Connect SSE stream for inbound Canon messages ──
     const stream = new CanonStream({
         apiKey,
@@ -3306,11 +3353,13 @@ export async function main() {
                 const m = payload.message;
                 if (m.senderId === agentId)
                     return;
+                const convoId = payload.conversationId;
                 if (!claimInboundMessageId(m.id))
                     return;
-                const convoId = payload.conversationId;
+                recoveryCheckpointsFor(convoId).track(m.id);
                 knownConversationIds.add(convoId);
                 if (handleRuntimeReplyMessage(convoId, m)) {
+                    recoveryCheckpointsFor(convoId).settle(m.id);
                     settleInboundMessageId(m.id, true);
                     return;
                 }
@@ -3318,6 +3367,7 @@ export async function main() {
                 const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
                 if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
                     console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
+                    recoveryCheckpointsFor(convoId).settle(m.id);
                     settleInboundMessageId(m.id, true);
                     return;
                 }
@@ -3421,8 +3471,10 @@ export async function main() {
                     }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
                     return true;
                 })().then((queued) => {
-                    if (!queued)
+                    if (!queued) {
+                        recoveryCheckpointsFor(convoId).settle(m.id);
                         settleInboundMessageId(m.id, true);
+                    }
                 }).catch((error) => {
                     settleInboundMessageId(m.id, false);
                     console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to process inbound message:`, error instanceof Error ? error.message : error);
@@ -3434,11 +3486,19 @@ export async function main() {
             onConversationUpdated: (payload) => {
                 handleConversationUpdated(payload);
             },
+            onReplayExpired: () => {
+                void reconnectRecovery.onReplayExpired().catch((error) => {
+                    console.error('[canon-host] Replay-expiry recovery failed:', error instanceof Error ? error.message : error);
+                });
+            },
             onConnected: () => {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
-                if (shouldRecoverAfterStreamConnect()) {
-                    void recoverMissedInboundMessages();
+                const recovery = reconnectRecovery.onConnected();
+                if (recovery) {
+                    void recovery.catch((error) => {
+                        console.error('[canon-host] Reconnect recovery failed:', error instanceof Error ? error.message : error);
+                    });
                 }
                 console.error('[canon-host] SSE connected');
             },

package/dist/server.js

@@ -16,7 +16,7 @@ import { ApprovalHttpServer } from './approval-server.js';
 import { renderClaudeInboundContent } from './canon-user-content.js';
 import { runCli } from '@canonmsg/core';
 import { parseReplyArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
-import { canonVerbToolDefinitions, executeCanonVerbTool, isCanonToolVerb, stampSendToTurnComplete, } from '@canonmsg/agent-tools';
+import { canonVerbToolDefinitions, createCanonCommunicationBinding, executeCanonVerbTool, isCanonToolVerb, } from '@canonmsg/agent-tools';
 const HELP = `canon-channel-server — Claude Code MCP channel server for Canon
 
 USAGE
@@ -45,6 +45,7 @@ const conversationCache = new Map();
 const TURN_COMPLETE_METADATA = {
     turnSemantics: 'turn_complete',
 };
+const communicationBinding = createCanonCommunicationBinding();
 /** Last owner-visible conversation to route approval cards into. */
 let approvalConversationId = null;
 /** Whether the message that most recently triggered work came from the owner. */
@@ -175,6 +176,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         // Channel mode owns no turn, so `no_reply` is an ack-only no-op here: the
         // standalone session has no final delivery for it to suppress.
         ...canonVerbToolDefinitions(),
+        ...(agentContext?.outboundPolicy === 'closed' ? [] : communicationBinding.tools),
     ],
 }));
 // ── Tool handlers ──────────────────────────────────────────────────────
@@ -314,10 +316,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         default: {
             const name = request.params.name;
+            if (communicationBinding.isToolName(name)) {
+                const result = await communicationBinding.execute(client, name, args);
+                return {
+                    content: result.content.map((item) => ({ type: 'text', text: item.text })),
+                    ...(result.isError ? { isError: true } : {}),
+                };
+            }
             if (isCanonToolVerb(name)) {
                 const rawArgs = args && typeof args === 'object' ? { ...args } : {};
-                const verbArgs = name === 'send_to' ? stampSendToTurnComplete(rawArgs) : rawArgs;
-                const verbResult = await executeCanonVerbTool(client, name, verbArgs);
+                const verbResult = await executeCanonVerbTool(client, name, rawArgs);
                 return {
                     content: verbResult.content.map((item) => ({ type: 'text', text: item.text })),
                     ...(verbResult.isError ? { isError: true } : {}),

package/dist/tool-policy.js

@@ -37,13 +37,9 @@ function normalizeToolName(toolName) {
 function isCanonOutboundTool(normalizedToolName) {
     return normalizedToolName.endsWith('__reply')
         || normalizedToolName.endsWith('__send_message')
-        || normalizedToolName.endsWith('__send_contextual_message')
-        || normalizedToolName.endsWith('__send_to')
         || normalizedToolName.endsWith('__share_contact')
         || normalizedToolName === 'reply'
         || normalizedToolName === 'send_message'
-        || normalizedToolName === 'send_contextual_message'
-        || normalizedToolName === 'send_to'
         || normalizedToolName === 'share_contact';
 }
 /**
@@ -79,7 +75,7 @@ const CANON_INTERACTION_LIFECYCLE_VERBS = new Set([
  * Verbs a NON-owner conversation member may trigger: same-conversation HITL
  * and display surfaces, whose responder routing and owner-only escalation
  * (secret/sudo, session rules) are enforced server-side. Cross-conversation
- * verbs (send_to, share_contact) and the reads (contacts, conversation
+ * cross-conversation verbs (share_contact) and the reads (contacts, conversation
  * lists — they expose the agent's other relationships to this conversation)
  * stay owner-only until the provenance trigger-token primitive lands.
  */
@@ -257,7 +253,7 @@ export async function decideClaudeToolPermissionForMode(input) {
         }
         // HITL + read verbs are allowed without an approval card: the HITL verbs
         // themselves render the human-facing card (recursion otherwise), and the
-        // reads are side-effect free. Outbound verbs (send_to, share_contact)
+        // reads are side-effect free. Outbound verbs (share_contact)
         // fall through to the mode policy — in native-approval mode they gate
         // like any other side effect; in default mode owner turns allow.
         if (CANON_HITL_OR_READ_VERBS.has(canonVerb) && !input.ruleForcedAsk) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.31.4",
+  "version": "0.33.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.228",
-    "@canonmsg/agent-sdk": "^8.6.0",
-    "@canonmsg/agent-tools": "^0.5.3",
-    "@canonmsg/coding-agent-host": "^0.5.0",
-    "@canonmsg/core": "^10.4.0",
-    "@canonmsg/rich-cards": "^0.10.2",
+    "@canonmsg/agent-sdk": "^9.0.0",
+    "@canonmsg/agent-tools": "^0.7.0",
+    "@canonmsg/coding-agent-host": "^0.7.0",
+    "@canonmsg/core": "^11.0.0",
+    "@canonmsg/rich-cards": "^0.10.3",
     "@modelcontextprotocol/sdk": "^1.30.0"
   },
   "engines": {