@canonmsg/claude-code-plugin 0.34.5 → 0.36.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.34.5",
+  "version": "0.36.0",
   "channels": [
     {
       "server": "canon-channel",

package/dist/host.js

@@ -27,10 +27,10 @@ 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, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, } from '@canonmsg/coding-agent-host';
 import { buildCanonUserContent, renderClaudeInboundContent, withClaudeReplyContextMediaReferences, } from './canon-user-content.js';
 import { buildClaudeNativeCommandInput, createClaudeCommandContextHook, getClaudeNativeCommandOutput, } from './native-command-input.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, createRuntimeHeartbeat, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, resolveLocalRuntimeSessionState, saveRuntimeSessionState, clearRuntimeSessionState, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonGroupContext, buildCompactGroupContextLines, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createRuntimeHeartbeat, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, isPendingCanonOperation, sendMessageWithRetry, sendMessageWithRetryChunked, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, resolveLocalRuntimeSessionState, saveRuntimeSessionState, clearRuntimeSessionState, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, resolveTurnVerbosity, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { runCli } from '@canonmsg/core';
 import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer } from '@canonmsg/agent-tools';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
@@ -615,6 +615,22 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     // Only Canon turns may own the active-input slot. Result ownership comes from
     // UUID correlation, while this slot drives live tool/dialog state.
     function bindActiveInput(input) {
+        if (claudeInputOwnsTurnSlot(input)) {
+            const roster = config.currentParticipantContext?.();
+            if (roster && input.commandContext) {
+                // Native slash-command arguments must stay byte-for-byte intact. Their
+                // context travels through UserPromptExpansion rather than the command.
+                input.commandContext = `${input.commandContext}\n\n${roster}`;
+            }
+            else if (roster) {
+                const content = input.msg.message.content;
+                input.msg = { ...input.msg, message: { ...input.msg.message,
+                        content: typeof content === 'string'
+                            ? `${content}\n\n${roster}`
+                            : [...content, { type: 'text', text: roster }],
+                    } };
+            }
+        }
         rememberDispatchedClaudeInput(dispatchedInputs, input);
         // The slot drives in-turn concerns (tool routing, dialogs, interrupts), so
         // it tracks the newest Canon turn. Result ownership is resolved by uuid, not
@@ -1316,7 +1332,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             const deliveredMessageIds = chunkedFailure
                 ? chunkedFailure.deliveredMessageIds
                 : resume.deliveredMessageIds;
-            const failure = classifyFinalDeliveryFailure(cause);
+            const failure = isPendingCanonOperation(cause) ? 'retryable' : classifyFinalDeliveryFailure(cause);
             if (failure === 'permanent') {
                 // Re-sending is pointless — the same request fails the same way. Surface
                 // what can be surfaced and finish the turn instead of burning the retry
@@ -1359,8 +1375,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             return false;
         }
     }
-    function sendTurnArtifactFile(file) {
+    function sendTurnArtifactFile(file, canPublish) {
         return sendMediaFileMessage(client, conversationId, file.path, '', {
+            canPublish,
             ...(session.activeInput?.replyAuthority
                 ? { replyAuthority: session.activeInput.replyAuthority }
                 : {}),
@@ -1382,16 +1399,18 @@ function createSession(conversationId, environment, agentId, client, typingSigna
      * `composeClaudeTurnFinal` makes for the text.
      */
     function routeArtifactsForInput(input, finalText) {
+        const decideArtifactRouting = () => shouldRouteClaudeTurnArtifacts({
+            turn: input,
+            interruptedTurnKeys: session.interruptedTurnKeys,
+            silencedTurnKeys: session.silencedTurnKeys,
+            finalText,
+            currentAudience: config.currentArtifactAudience?.() ?? { agentId, ownerId: config.ownerId },
+        });
         return createTurnArtifactRouter({
-            decide: () => shouldRouteClaudeTurnArtifacts({
-                turn: input,
-                interruptedTurnKeys: session.interruptedTurnKeys,
-                silencedTurnKeys: session.silencedTurnKeys,
-                finalText,
-            }),
+            decide: decideArtifactRouting,
             baseline: () => input.artifactBaseline,
             cwd: () => session.cwd,
-            send: (file) => sendTurnArtifactFile(file),
+            send: (file) => sendTurnArtifactFile(file, () => decideArtifactRouting().route),
             log: (line) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] ${line}`),
         }).route();
     }
@@ -1616,7 +1635,16 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 .updateMessageDisposition(conversationId, input.sourceMessageId, 'rejected')
                 .catch(() => { });
         }
-        markInputCompleted(input);
+        if (input.kind === 'canon' && input.sourceMessageId) {
+            const id = `message:${conversationId}:${input.sourceMessageId}`;
+            void client.getEndpoint().then(async (engine) => {
+                const entry = await engine.getInbound(id);
+                if (entry && ['observed', 'offered', 'deferred'].includes(entry.state)) {
+                    await engine.setInboundState(id, 'deferred', 'native-preflight');
+                    config.onInputDeferred?.(input.sourceMessageId);
+                }
+            }).catch((error) => console.error('[canon-host] Failed to defer native input:', error));
+        }
         // resetTurnToIdle releases the slot, tears the published turn down (typing
         // signal, seeded /streaming, turn state) and drains the queue. On a closed
         // session it is a no-op, which is correct: the teardown owns that path.
@@ -1626,7 +1654,16 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         return dispatchClaudeInput(session, input, {
             openTurn,
             markAccepted: (dispatched) => markQueuedMessageAccepted(dispatched.sourceMessageId, dispatched.markAccepted),
-            prepareArtifacts: prepareArtifactsForInput,
+            prepareArtifacts: async (input) => {
+                await prepareArtifactsForInput(input);
+                if (input.kind === 'canon' && input.sourceMessageId) {
+                    const engine = await client.getEndpoint();
+                    const id = `message:${conversationId}:${input.sourceMessageId}`;
+                    if (!await engine.claimInbound(id)) {
+                        throw new Error('Canon input already has an execution owner.');
+                    }
+                }
+            },
             send: sendInput,
             abandon: abandonDispatchedInput,
         });
@@ -2211,7 +2248,8 @@ export async function main() {
         throw error;
     }
     // ── Canon API client + RTDB auth ──
-    const client = new CanonClient(apiKey, baseUrl);
+    const client = new CanonClient(apiKey, baseUrl, { environmentId: resolvedAgent.environmentId, streamUrl });
+    const endpoint = await client.getEndpoint();
     const rtdb = initRTDBAuth(client, { rtdbUrl, firebaseApiKey });
     const typingSignals = createTypingStatusPublisher({
         setTyping: (conversationId, typing, status) => status
@@ -2532,19 +2570,23 @@ export async function main() {
         if (cached) {
             conversationCache.set(payload.conversationId, {
                 ...cached,
+                ...payload.changes,
                 memberIds,
             });
+            void client.rememberConversation(conversationCache.get(payload.conversationId))
+                .catch((error) => console.error('[canon] Failed to persist conversation update:', error));
         }
         if (membershipChange) {
             pendingMembershipChanges.set(payload.conversationId, membershipChange);
         }
         if (!memberIds.includes(agentId)) {
             knownConversationIds.delete(payload.conversationId);
-            conversationCache.delete(payload.conversationId);
+            pendingMembershipChanges.delete(payload.conversationId);
+            closeSession(payload.conversationId);
         }
     }
     function getGroupContextMode(conversationId, conversation) {
-        if (conversation?.type !== 'group')
+        if (!conversation)
             return undefined;
         if (pendingMembershipChanges.has(conversationId))
             return 'membership_change';
@@ -2562,7 +2604,7 @@ export async function main() {
     }
     async function loadHydratedInboundContext(input) {
         const [conversation, page] = await Promise.all([
-            getConversationMeta(input.conversationId),
+            getConversationMeta(input.conversationId, { refreshIfMemberMissing: agentId }),
             input.hydratedPage
                 ? Promise.resolve(input.hydratedPage)
                 : client.getMessagesPage(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => null),
@@ -2571,6 +2613,7 @@ export async function main() {
             agentId,
             conversationId: input.conversationId,
             conversation,
+            requireAgentMembership: true,
             page,
             activeSelfContextId: input.activeSelfContextId,
             selfContexts: input.selfContexts,
@@ -2704,6 +2747,10 @@ export async function main() {
         }
     }
     async function getOrCreateSession(conversationId) {
+        const current = conversationCache.get(conversationId);
+        if (current && !current.memberIds.includes(agentId)) {
+            throw new Error('Agent is no longer a member of this conversation');
+        }
         knownConversationIds.add(conversationId);
         const existing = sessions.get(conversationId);
         if (existing && !existing.closed) {
@@ -2813,9 +2860,21 @@ export async function main() {
                     runtimeId,
                     ownerId,
                     communicationEnabled,
+                    currentParticipantContext: () => {
+                        const roster = buildCanonGroupContext({
+                            conversation: conversationCache.get(conversationId), messages: [], agentId, ownerId, ownerName,
+                        });
+                        return roster ? buildCompactGroupContextLines(roster, 'initial').join('\n') : '';
+                    },
+                    currentArtifactAudience: () => ({ memberIds: conversationCache.get(conversationId)?.memberIds, agentId, ownerId }),
+                    onInputDeferred: (sourceMessageId) => settleInboundMessageId(sourceMessageId, false),
                     onInputCompleted: (sourceMessageId) => {
                         recoveryCheckpointsFor(conversationId).settle(sourceMessageId);
                         settleInboundMessageId(sourceMessageId, true);
+                        const id = `message:${conversationId}:${sourceMessageId}`;
+                        void endpoint.getInbound(id).then((entry) => entry
+                            ? endpoint.setInboundState(id, 'settled', 'native-completed') : undefined)
+                            .catch((error) => console.error('[canon-host] Failed to settle native input:', error));
                     },
                     publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
                 }, resumeId);
@@ -2840,134 +2899,6 @@ export async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    async function enqueueRecoveredInboundMessage(input) {
-        const m = {
-            id: input.message.id,
-            senderId: input.message.senderId,
-            senderName: input.message.senderName,
-            senderType: input.message.senderType,
-            isOwner: input.message.isOwner,
-            text: input.message.text ?? undefined,
-            contentType: input.message.contentType,
-            attachments: input.message.attachments,
-            mentions: input.message.mentions,
-            reactions: input.message.reactions,
-            replyTo: input.message.replyTo ?? undefined,
-            replyToPosition: input.message.replyToPosition ?? undefined,
-            forwarded: input.message.forwarded,
-            forwardedFrom: input.message.forwardedFrom,
-            metadata: input.message.metadata,
-            contactCard: input.message.contactCard,
-            createdAt: input.message.createdAt,
-        };
-        if (m.senderId === agentId)
-            return 'handled';
-        let materialized = [];
-        if (m.id) {
-            try {
-                materialized = await materializeMessageMedia({
-                    id: m.id,
-                    attachments: m.attachments ?? [],
-                }, { agentId, conversationId: input.conversationId });
-            }
-            catch (error) {
-                console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Failed to materialize recovered media:`, error instanceof Error ? error.message : error);
-            }
-        }
-        const sender = m.senderName || m.senderId;
-        const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-        const content = renderInboundContent(m, materialized);
-        const hydrated = await loadHydratedInboundContext({
-            conversationId: input.conversationId,
-            message: m,
-            senderName: sender,
-            isOwner,
-            hydratedPage: input.hydratedPage,
-        });
-        const behavior = input.hydratedPage?.behavior ?? hydrated.behavior;
-        const activeSelfContextId = hydrated.activeSelfContextId;
-        const selfContexts = hydrated.selfContexts;
-        const replyMedia = await materializePromptReplyContext({
-            replyContext: hydrated.replyContext,
-            agentId,
-            conversationId: input.conversationId,
-            logPrefix: `[canon-host] [${input.conversationId.slice(0, 8)}]`,
-        });
-        const replyContext = replyMedia.replyContext;
-        const participantContext = hydrated.participantContext;
-        const autoReply = decideAutoReply(participantContext, behavior);
-        if (!autoReply.allow) {
-            console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Suppressed recovered auto-reply: ${autoReply.reason}`);
-            return 'handled';
-        }
-        markGroupContextModeUsed(input.conversationId, participantContext.groupContextMode);
-        const turnMetadata = normalizeTurnMetadata(m.metadata);
-        const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
-        const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
-        let session;
-        try {
-            session = await getOrCreateSession(input.conversationId);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Failed to create recovered session: ${message}`);
-            await runtimeState.patchAgentSessionSnapshot(input.conversationId, {
-                configurationStatus: 'configuration_required',
-                lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
-            }).catch(() => { });
-            await markQueuedMessageAcceptedForConversation(input.conversationId, m.id ?? null, shouldMarkAccepted);
-            await sendMessageWithRetry(client, input.conversationId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
-                messageId: `claude-start-failed-${m.id}`,
-                ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
-                metadata: {
-                    runtimeStatus: 'configuration_required',
-                    turnSemantics: 'turn_complete',
-                    replyBehavior: 'suppress_auto_reply',
-                },
-            }).catch(() => { });
-            return 'handled';
-        }
-        session.activeSelfContextId = activeSelfContextId;
-        const promptText = buildCanonPrompt({
-            content,
-            conversationId: input.conversationId,
-            participantContext,
-            behavior,
-            selfContexts,
-            activeSelfContextId,
-            provenance: hydrated.provenance,
-            replyContext,
-            message: m,
-        });
-        const commandInput = buildClaudeNativeCommandInput({
-            text: m.text,
-            senderType: m.senderType,
-            promptText,
-            commands: runtimeMetadata.commands,
-        });
-        const messageContent = await buildCanonUserContent({
-            promptText: commandInput.promptText,
-            materialized: [...replyMedia.materialized, ...materialized],
-        });
-        const turnModes = {
-            ...resolveClaudeTurnModes(participantContext),
-            commandContext: commandInput.commandContext,
-        };
-        session.enqueueInbound({
-            type: 'user',
-            message: {
-                role: 'user',
-                content: messageContent,
-            },
-            parent_tool_use_id: null,
-            origin: claudeOriginForCanonSender({
-                senderType: m.senderType,
-                senderId: m.senderId,
-                senderName: m.senderName,
-            }),
-        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
-        return 'queued';
-    }
     const acceptedInboundMessageIds = new Set();
     const inFlightInboundMessageIds = new Set();
     function claimInboundMessageId(messageId) {
@@ -3038,223 +2969,177 @@ export async function main() {
             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',
-                });
-                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))
-                        continue;
-                    try {
-                        let queued = false;
-                        if (!handleRuntimeReplyMessage(conversationId, message)) {
-                            const trigger = shouldTriggerAgentTurn({
-                                senderType: message.senderType,
-                                metadata: message.metadata,
-                            });
-                            if (trigger.allow) {
-                                queued = await enqueueRecoveredInboundMessage({
-                                    conversationId,
-                                    message,
-                                    hydratedPage: recovered.newestPage,
-                                }) === 'queued';
-                            }
-                        }
-                        if (!queued) {
-                            recoveryCheckpoints.settle(message.id);
-                            settleInboundMessageId(message.id, true);
-                        }
-                    }
-                    catch (error) {
-                        settleInboundMessageId(message.id, false);
-                        throw error;
-                    }
-                }
-                if (recovered.messages.length > 0) {
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovered ${recovered.messages.length} inbound message(s) (${recovered.mode})`);
-                }
-            }
-            catch (error) {
-                recoveryBatch.cancel();
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Startup recovery failed:`, error instanceof Error ? error.message : error);
-            }
-        }
-        startupRecoveryComplete = true;
     }
     const reconnectRecovery = createReconnectRecoveryCoordinator(performMissedInboundRecovery);
     await reconnectRecovery.recoverNow();
     // ── Connect SSE stream for inbound Canon messages ──
-    const stream = new CanonStream({
-        apiKey,
-        agentId,
-        streamUrl,
-        handler: {
-            onMessage: (payload) => {
-                const m = payload.message;
-                if (m.senderId === agentId)
-                    return;
-                const convoId = payload.conversationId;
-                if (!claimInboundMessageId(m.id))
-                    return;
-                recoveryCheckpointsFor(convoId).track(m.id);
-                knownConversationIds.add(convoId);
-                if (handleRuntimeReplyMessage(convoId, m)) {
-                    recoveryCheckpointsFor(convoId).settle(m.id);
-                    settleInboundMessageId(m.id, true);
-                    return;
-                }
-                const sender = m.senderName || m.senderId;
-                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;
-                }
-                void (async () => {
-                    let materialized = [];
-                    if (m.id) {
-                        try {
-                            materialized = await materializeMessageMedia({
-                                id: m.id,
-                                attachments: m.attachments ?? [],
-                            }, { agentId, conversationId: convoId });
-                        }
-                        catch (error) {
-                            console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
-                        }
-                    }
-                    const content = renderInboundContent(m, materialized);
-                    const hydrated = await loadHydratedInboundContext({
-                        conversationId: convoId,
-                        message: m,
-                        senderName: sender,
-                        isOwner,
-                        activeSelfContextId: payload.activeSelfContextId,
-                        selfContexts: payload.selfContexts,
-                        provenance: payload.provenance,
-                    });
-                    const behavior = payload.behavior ?? hydrated.behavior;
-                    const activeSelfContextId = hydrated.activeSelfContextId;
-                    const selfContexts = hydrated.selfContexts;
-                    const replyMedia = await materializePromptReplyContext({
-                        replyContext: hydrated.replyContext,
-                        agentId,
-                        conversationId: convoId,
-                        logPrefix: `[canon-host] [${convoId.slice(0, 8)}]`,
-                    });
-                    const replyContext = replyMedia.replyContext;
-                    const participantContext = hydrated.participantContext;
-                    const autoReply = payload.turnDispatch?.kind === 'run_turn'
-                        ? {
-                            allow: true,
-                            reason: payload.turnDispatch.reason || 'server dispatch allowed this turn',
-                        }
-                        : decideAutoReply(participantContext, behavior);
-                    if (!autoReply.allow) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
-                        return false;
-                    }
-                    markGroupContextModeUsed(convoId, participantContext.groupContextMode);
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
-                    const turnMetadata = normalizeTurnMetadata(m.metadata);
-                    const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
-                    const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
-                    let session;
+    const inbound = endpoint.acceptInbound({ kind: 'message.created',
+        offer: async (event) => {
+            const payload = event.data;
+            const m = payload.message;
+            if (m.senderId === agentId) {
+                await endpoint.setInboundState(event.id, 'settled', 'own-message');
+                return;
+            }
+            const convoId = payload.conversationId;
+            if (!claimInboundMessageId(m.id))
+                return;
+            recoveryCheckpointsFor(convoId).track(m.id);
+            knownConversationIds.add(convoId);
+            if (handleRuntimeReplyMessage(convoId, m)) {
+                recoveryCheckpointsFor(convoId).settle(m.id);
+                settleInboundMessageId(m.id, true);
+                await endpoint.setInboundState(`message:${convoId}:${m.id}`, 'settled', 'not-dispatched');
+                return;
+            }
+            const sender = m.senderName || m.senderId;
+            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);
+                await endpoint.setInboundState(`message:${convoId}:${m.id}`, 'settled', 'not-dispatched');
+                return;
+            }
+            await (async () => {
+                let materialized = [];
+                if (m.id) {
                     try {
-                        session = await getOrCreateSession(convoId);
+                        materialized = await materializeMessageMedia({
+                            id: m.id,
+                            attachments: m.attachments ?? [],
+                        }, { agentId, conversationId: convoId });
                     }
                     catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to create session: ${message}`);
-                        await runtimeState.patchAgentSessionSnapshot(convoId, {
-                            configurationStatus: 'configuration_required',
-                            lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
-                        }).catch(() => { });
-                        await markQueuedMessageAcceptedForConversation(convoId, m.id ?? null, shouldMarkAccepted);
-                        await sendMessageWithRetry(client, convoId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
-                            messageId: `claude-start-failed-${m.id}`,
-                            ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
-                            metadata: {
-                                turnId: `claude-start:${m.id}`,
-                                runtimeStatus: 'configuration_required',
-                                turnSemantics: 'turn_complete',
-                                replyBehavior: 'suppress_auto_reply',
-                            },
-                            ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
-                        }).catch(() => { });
-                        return false;
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
                     }
-                    session.activeSelfContextId = activeSelfContextId;
-                    const promptText = buildCanonPrompt({
-                        content,
-                        conversationId: convoId,
-                        participantContext,
-                        behavior,
-                        selfContexts,
-                        activeSelfContextId,
-                        provenance: hydrated.provenance,
-                        replyContext,
-                        message: m,
-                    });
-                    const commandInput = buildClaudeNativeCommandInput({
-                        text: m.text,
-                        senderType: m.senderType,
-                        promptText,
-                        commands: runtimeMetadata.commands,
-                    });
-                    const messageContent = await buildCanonUserContent({
-                        promptText: commandInput.promptText,
-                        materialized: [...replyMedia.materialized, ...materialized],
-                    });
-                    const turnModes = {
-                        ...resolveClaudeTurnModes(participantContext),
-                        commandContext: commandInput.commandContext,
-                        replyAuthority: payload.replyAuthority ?? null,
-                    };
-                    session.enqueueInbound({
-                        type: 'user',
-                        message: {
-                            role: 'user',
-                            content: messageContent,
-                        },
-                        parent_tool_use_id: null,
-                        origin: claudeOriginForCanonSender({
-                            senderType: m.senderType,
-                            senderId: m.senderId,
-                            senderName: m.senderName,
-                        }),
-                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
-                    return true;
-                })().then((queued) => {
-                    if (!queued) {
-                        recoveryCheckpointsFor(convoId).settle(m.id);
-                        settleInboundMessageId(m.id, true);
+                }
+                const content = renderInboundContent(m, materialized);
+                const hydrated = await loadHydratedInboundContext({
+                    conversationId: convoId,
+                    message: m,
+                    senderName: sender,
+                    isOwner,
+                    activeSelfContextId: payload.activeSelfContextId,
+                    selfContexts: payload.selfContexts,
+                    provenance: payload.provenance,
+                });
+                const behavior = payload.behavior ?? hydrated.behavior;
+                const activeSelfContextId = hydrated.activeSelfContextId;
+                const selfContexts = hydrated.selfContexts;
+                const replyMedia = await materializePromptReplyContext({
+                    replyContext: hydrated.replyContext,
+                    agentId,
+                    conversationId: convoId,
+                    logPrefix: `[canon-host] [${convoId.slice(0, 8)}]`,
+                });
+                const replyContext = replyMedia.replyContext;
+                const participantContext = hydrated.participantContext;
+                const autoReply = payload.turnDispatch?.kind === 'run_turn'
+                    ? {
+                        allow: true,
+                        reason: payload.turnDispatch.reason || 'server dispatch allowed this turn',
                     }
-                }).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);
+                    : decideAutoReply(participantContext, behavior);
+                if (!autoReply.allow) {
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+                    return false;
+                }
+                markGroupContextModeUsed(convoId, participantContext.groupContextMode);
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
+                const turnMetadata = normalizeTurnMetadata(m.metadata);
+                const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+                const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+                let session;
+                try {
+                    session = await getOrCreateSession(convoId);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to create session: ${message}`);
+                    await runtimeState.patchAgentSessionSnapshot(convoId, {
+                        configurationStatus: 'configuration_required',
+                        lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
+                    }).catch(() => { });
+                    await markQueuedMessageAcceptedForConversation(convoId, m.id ?? null, shouldMarkAccepted);
+                    await sendMessageWithRetry(client, convoId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
+                        messageId: `claude-start-failed-${m.id}`,
+                        ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
+                        metadata: {
+                            turnId: `claude-start:${m.id}`,
+                            runtimeStatus: 'configuration_required',
+                            turnSemantics: 'turn_complete',
+                            replyBehavior: 'suppress_auto_reply',
+                        },
+                        ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
+                    }).catch(() => { });
+                    return false;
+                }
+                session.activeSelfContextId = activeSelfContextId;
+                const promptText = buildCanonPrompt({
+                    content,
+                    conversationId: convoId,
+                    participantContext,
+                    behavior,
+                    selfContexts,
+                    activeSelfContextId,
+                    provenance: hydrated.provenance,
+                    replyContext,
+                    message: m,
+                });
+                const commandInput = buildClaudeNativeCommandInput({
+                    text: m.text,
+                    senderType: m.senderType,
+                    promptText,
+                    commands: runtimeMetadata.commands,
+                });
+                const messageContent = await buildCanonUserContent({
+                    promptText: commandInput.promptText,
+                    materialized: [...replyMedia.materialized, ...materialized],
                 });
+                const turnModes = {
+                    ...resolveClaudeTurnModes(participantContext),
+                    commandContext: commandInput.commandContext,
+                    replyAuthority: payload.replyAuthority ?? null,
+                };
+                session.enqueueInbound({
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: messageContent,
+                    },
+                    parent_tool_use_id: null,
+                    origin: claudeOriginForCanonSender({
+                        senderType: m.senderType,
+                        senderId: m.senderId,
+                        senderName: m.senderName,
+                    }),
+                }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
+                return true;
+            })().then(async (queued) => {
+                if (!queued) {
+                    recoveryCheckpointsFor(convoId).settle(m.id);
+                    settleInboundMessageId(m.id, true);
+                    await endpoint.setInboundState(`message:${convoId}:${m.id}`, 'settled', 'not-dispatched');
+                }
+            }).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);
+                throw error;
+            });
+        },
+        onError: (error) => console.error('[canon-host] Endpoint input deferred:', error), });
+    inbound.start();
+    const stream = new CanonStream({
+        endpoint,
+        agentId,
+        handler: {
+            onMessage: (payload) => {
+                void inbound.receive({ id: `message:${payload.conversationId}:${payload.message.id}`,
+                    kind: 'message.created', conversationId: payload.conversationId, durable: true,
+                    data: payload });
             },
             onMessageDeleted: (payload) => {
                 removeQueuedInput(payload.conversationId, payload.messageId);
@@ -3403,6 +3288,7 @@ export async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
+        await inbound.close();
         approvalManager?.dispose();
         runtimeInputManager.dispose();
         await runtimeHeartbeat.dispose();

package/dist/server.js

@@ -578,7 +578,7 @@ async function startChannel() {
     if (profile) {
         console.error(`[canon] Using agent profile: ${profile}`);
     }
-    client = new CanonClient(apiKey, baseUrl);
+    client = new CanonClient(apiKey, baseUrl, { environmentId: resolvedRuntime.environmentId, streamUrl: resolvedRuntime.streamUrl });
     // Get agent identity — try /agents/me first, fall back to /agents/auth-token
     let agentId;
     try {
@@ -645,9 +645,8 @@ async function startChannel() {
     }
     // Start SSE stream
     stream = new CanonStream({
-        apiKey,
+        endpoint: await client.getEndpoint(),
         agentId,
-        streamUrl: resolvedRuntime.streamUrl,
         handler: {
             onMessage: handleInboundMessage,
             onAgentContext: (ctx) => {

package/dist/session-state.d.ts

@@ -142,6 +142,11 @@ export declare function shouldRouteClaudeTurnArtifacts(input: {
     interruptedTurnKeys: ReadonlySet<string>;
     silencedTurnKeys: ReadonlySet<string>;
     finalText: string | null | undefined;
+    currentAudience?: {
+        memberIds?: readonly string[];
+        agentId: string;
+        ownerId: string | null | undefined;
+    };
 }): TurnArtifactRoutingDecision;
 export declare function rememberDispatchedClaudeInput(dispatched: Map<string, ClaudeInputEnvelope>, input: ClaudeInputEnvelope): void;
 /**

package/dist/session-state.js

@@ -74,8 +74,12 @@ export function shouldDeliverClaudeFinal(input) {
  * `DEFAULT_SILENT_TURN_PRECEDENCE` moves a turn's text and its files together.
  */
 export function shouldRouteClaudeTurnArtifacts(input) {
+    const audience = input.currentAudience;
+    const ownerPair = !audience || (audience.ownerId !== audience.agentId
+        && Boolean(audience.ownerId) && audience.memberIds?.length === 2
+        && audience.memberIds.includes(audience.agentId) && audience.memberIds.includes(audience.ownerId));
     return resolveTurnArtifactRouting({
-        artifactRoutingMode: input.turn.artifactRoutingMode,
+        artifactRoutingMode: ownerPair ? input.turn.artifactRoutingMode : 'disabled',
         interrupted: input.interruptedTurnKeys.has(input.turn.turnKey),
         silenced: isSilentTurnSuppressed({
             silenced: input.silencedTurnKeys.has(input.turn.turnKey),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.34.5",
+  "version": "0.36.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,15 +31,15 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.228",
-    "@canonmsg/agent-sdk": "^10.3.0",
-    "@canonmsg/agent-tools": "^0.9.1",
-    "@canonmsg/coding-agent-host": "^0.7.1",
-    "@canonmsg/core": "^12.4.0",
-    "@canonmsg/rich-cards": "^0.10.5",
+    "@canonmsg/agent-sdk": "^11.0.0",
+    "@canonmsg/agent-tools": "^0.11.0",
+    "@canonmsg/coding-agent-host": "^0.9.0",
+    "@canonmsg/core": "^13.0.0",
+    "@canonmsg/rich-cards": "^0.10.6",
     "@modelcontextprotocol/sdk": "^1.30.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.22.3"
   },
   "keywords": [
     "canon",