@canonmsg/claude-code-plugin 0.30.0 → 0.31.1

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.30.0",
+  "version": "0.31.1",
   "channels": [
     {
       "server": "canon-channel",

package/dist/host.js

@@ -27,13 +27,13 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
-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, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+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, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, 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';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeStreamingWrite, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, claudeFinalTurnTrail, publishedClaudeTurnState, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, shouldStopTypingDotsOnStreamedText, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeFinalText, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
+import { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeStreamingWrite, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, claudeFinalTurnTrail, publishedClaudeTurnState, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, shouldStopTypingDotsOnStreamedText, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeTurnFinal, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, shouldRouteClaudeTurnArtifacts, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
 import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
@@ -981,6 +981,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         conversationId,
                         ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                         ...(routing.responseUserId ? { responseUserId: routing.responseUserId } : {}),
+                        ...(session.activeInput?.sourceMessageId
+                            ? { sourceMessageId: session.activeInput.sourceMessageId }
+                            : {}),
                     };
                 }, (verb) => {
                     if (verb !== 'no_reply')
@@ -1600,37 +1603,32 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             metadata: buildArtifactMediaMetadata(),
         });
     }
-    async function routeWorkspaceGeneratedArtifacts(input) {
-        if (!input.artifactBaseline)
-            return;
-        try {
-            const result = await collectTurnArtifacts({
-                cwd: session.cwd,
-                baseline: input.artifactBaseline,
-            });
-            for (const file of result.files) {
-                try {
-                    const { messageId } = await sendTurnArtifactFile(file);
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Routed generated artifact ${file.relativePath ?? file.fileName} (${messageId})`);
-                }
-                catch (error) {
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Artifact upload failed for ${file.relativePath ?? file.fileName}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            for (const skipped of result.skipped) {
-                if (skipped.reason === 'too-large' || skipped.reason === 'file-cap' || skipped.reason === 'scan-limit') {
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Artifact skipped ${skipped.fileName} (${skipped.reason})`);
-                }
-            }
-        }
-        catch (error) {
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Artifact routing failed:`, error instanceof Error ? error.message : error);
-        }
-    }
-    async function routeArtifactsForInput(input) {
-        if (input.artifactRoutingMode === 'workspace-generated') {
-            await routeWorkspaceGeneratedArtifacts(input);
-        }
+    /**
+     * The one path from a completed turn to posting its workspace artifacts.
+     *
+     * The router owns the collect-and-post loop, so no completion branch can
+     * reach the workspace around the gate. It is built per turn rather than per
+     * session because its once-only latch is a TURN's latch — Codex reaches
+     * completion through five branches and needs it; this host calls it once,
+     * and gets the same guarantee for free.
+     *
+     * `finalText` is the model's own reply, which decides whether the turn's
+     * silence actually suppresses anything — the same reading
+     * `composeClaudeTurnFinal` makes for the text.
+     */
+    function routeArtifactsForInput(input, finalText) {
+        return createTurnArtifactRouter({
+            decide: () => shouldRouteClaudeTurnArtifacts({
+                turn: input,
+                interruptedTurnKeys: session.interruptedTurnKeys,
+                silencedTurnKeys: session.silencedTurnKeys,
+                finalText,
+            }),
+            baseline: () => input.artifactBaseline,
+            cwd: () => session.cwd,
+            send: (file) => sendTurnArtifactFile(file),
+            log: (line) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] ${line}`),
+        }).route();
     }
     function scheduleFinalDeliveryRetry(pending = session.pendingFinalDelivery) {
         if (!pending || session.closed || session.pendingFinalDelivery?.turnKey !== pending.turnKey)
@@ -2218,11 +2216,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         // working, at their existing accuracy.
                         const completedInput = takeClaudeResultOwner(dispatchedInputs, msg.user_message_uuid) ?? session.activeInput;
                         console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn complete (${msg.subtype})`);
-                        // Turn artifacts land before the final text reply.
-                        if (completedInput?.kind === 'canon'
-                            && !session.interruptedTurnKeys.has(completedInput.turnKey)) {
-                            await routeArtifactsForInput(completedInput);
-                        }
                         const resultText = typeof msg.result === 'string'
                             ? msg.result.trim()
                             : '';
@@ -2237,25 +2230,42 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn failed (${msg.subtype}): `
                                 + (errorList.join(' | ') || 'no error detail'));
                         }
-                        const finalText = composeClaudeFinalText({
+                        const silenced = Boolean(completedInput?.turnKey && session.silencedTurnKeys.has(completedInput.turnKey));
+                        // Composed before the artifacts are routed, because the artifact
+                        // gate weighs silence against this same model text — a turn cannot
+                        // speak and withhold its files, or the reverse. Composing is pure;
+                        // the artifacts still POST first, ahead of the reply they belong to.
+                        const turnFinal = composeClaudeTurnFinal({
                             resultText,
                             streamedText: session.pendingFinalText,
                             failureNotice,
+                            silenced,
                         });
-                        const silenced = Boolean(completedInput?.turnKey && session.silencedTurnKeys.has(completedInput.turnKey));
-                        // `no_reply` suppresses the MODEL's reply, never Canon's own "this
-                        // turn broke" diagnostic: a turn that goes silent and then fails
-                        // would otherwise leave the owner with nothing at all, which is the
-                        // exact outcome the notice exists to prevent.
-                        const suppressFinal = silenced && !failureNotice;
-                        const delivery = resolveSilentTurnDelivery({ silenced: suppressFinal, finalText });
-                        const shouldDeliverFinal = delivery === 'deliver'
+                        const finalText = turnFinal.finalText;
+                        if (completedInput?.kind === 'canon') {
+                            await routeArtifactsForInput(completedInput, turnFinal.modelText);
+                        }
+                        const shouldDeliverFinal = finalText
                             ? shouldDeliverClaudeFinal({
                                 turn: completedInput,
                                 finalizedTurnKeys: session.finalizedTurnKeys,
                                 interruptedTurnKeys: session.interruptedTurnKeys,
                             })
                             : false;
+                        // Silence drops the model's own words without sending them. Say so:
+                        // a suppressed final is invisible in the conversation, and the
+                        // failure notice that may follow it is Canon's line, not the
+                        // model's, so nothing else would record what was swallowed.
+                        if (turnFinal.speechSuppressed && turnFinal.modelText) {
+                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] `
+                                + `Final not delivered (${turnFinal.modelText.length} chars): `
+                                + describeUndeliveredClaudeFinal({
+                                    turn: completedInput,
+                                    finalizedTurnKeys: session.finalizedTurnKeys,
+                                    interruptedTurnKeys: session.interruptedTurnKeys,
+                                    silencedTurnKeys: session.silencedTurnKeys,
+                                }));
+                        }
                         // Gated finals are dropped without sending. That is correct for the
                         // seed's own turn, but it is also how a misattributed Canon reply
                         // disappears — silently, which is why this class of bug went unseen.
@@ -2267,7 +2277,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                                     turn: completedInput,
                                     finalizedTurnKeys: session.finalizedTurnKeys,
                                     interruptedTurnKeys: session.interruptedTurnKeys,
-                                    silencedTurnKeys: suppressFinal ? session.silencedTurnKeys : undefined,
                                 }));
                         }
                         const finalDelivered = finalText && shouldDeliverFinal
@@ -2298,7 +2307,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             if (shouldDeliverFinal && finalText) {
                                 scheduleFinalHandoffReset();
                             }
-                            else if (suppressFinal) {
+                            else if (turnFinal.speechSuppressed) {
                                 // Deliberate silence: blank the node (text '' AND an explicit
                                 // empty blocks array) before deleting it, or onStreamingCleared
                                 // salvages this turn's narration into a durable bubble. Teardown

package/dist/session-state.d.ts

@@ -1,6 +1,6 @@
 import type { PermissionMode, SDKMessageOrigin, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { DeliveryIntent, ModelOption, RuntimeStreamingPayload, TurnLifecycleState, TurnOutputBlock, TurnOutputSnapshot, TurnVerbosity } from '@canonmsg/core';
-import type { TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
+import type { TurnArtifactRoutingDecision, TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
@@ -118,6 +118,23 @@ export declare function shouldDeliverClaudeFinal(input: {
     finalizedTurnKeys: ReadonlySet<string>;
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
+/**
+ * The artifact half of `shouldDeliverClaudeFinal`: workspace media is posted as
+ * a message, so the same turn-level gates apply to it. Silence is the one this
+ * host was missing — see `resolveTurnArtifactRouting` for the ruling.
+ *
+ * The only place silence is resolved for Claude artifacts. `finalText` is the
+ * model's own reply for the turn (never Canon's failure notice, which is a host
+ * diagnostic and goes out either way), weighed by `isSilentTurnSuppressed` —
+ * the same switch `composeClaudeTurnFinal` reads. One switch, so flipping
+ * `DEFAULT_SILENT_TURN_PRECEDENCE` moves a turn's text and its files together.
+ */
+export declare function shouldRouteClaudeTurnArtifacts(input: {
+    turn: Pick<ClaudeInputEnvelope, 'artifactRoutingMode' | 'turnKey'>;
+    interruptedTurnKeys: ReadonlySet<string>;
+    silencedTurnKeys: ReadonlySet<string>;
+    finalText: string | null | undefined;
+}): TurnArtifactRoutingDecision;
 export declare function rememberDispatchedClaudeInput(dispatched: Map<string, ClaudeInputEnvelope>, input: ClaudeInputEnvelope): void;
 /**
  * The envelope a turn result belongs to, matched by `user_message_uuid`.
@@ -497,6 +514,41 @@ export declare function composeClaudeFinalText(input: {
     streamedText?: string | null;
     failureNotice?: string | null;
 }): string | null;
+export interface ClaudeTurnFinal {
+    /** What actually goes to Canon, or null when the turn says nothing. */
+    finalText: string | null;
+    /** The model's own text for the turn, whether or not it is delivered. */
+    modelText: string | null;
+    /**
+     * Silence — not "no text" — is why the model's own words are being dropped.
+     * The artifact gate reads the same verdict, so a silenced turn withholds its
+     * files and its speech together.
+     */
+    speechSuppressed: boolean;
+}
+/**
+ * What a completed turn actually says, once `no_reply` is taken into account.
+ *
+ * Silence suppresses the MODEL's output and nothing else — its result text or,
+ * failing that, the text it streamed before going quiet. Canon's own "this turn
+ * broke" notice still goes out: suppressing it would leave the owner with a
+ * turn that failed and said nothing, which is exactly what the notice exists to
+ * prevent.
+ *
+ * The two used to be merged. `composeClaudeFinalText` appends the notice to
+ * whatever partial text exists, and the host then turned silence OFF entirely
+ * whenever a notice was present — so a turn that streamed "Here's the chart:",
+ * called `no_reply`, and then hit `error_max_turns` posted the model's line
+ * next to the notice while withholding the chart itself. Codex has never done
+ * that: its failure branches send `formatCodexTurnFailure(...)` alone and never
+ * `result.finalMessage`. This is the same contract on both hosts.
+ */
+export declare function composeClaudeTurnFinal(input: {
+    resultText?: string | null;
+    streamedText?: string | null;
+    failureNotice?: string | null;
+    silenced: boolean;
+}): ClaudeTurnFinal;
 export type ClaudeFinalDeliveryFailure = 'retry' | 'permanent';
 /**
  * How the host should react to a failed final-reply send.

package/dist/session-state.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { USAGE_LIMIT_ERROR_PREFIXES } from '@anthropic-ai/claude-agent-sdk';
-import { buildBoundedTurnTrail, DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES, isRetryableCanonDeliveryError, shouldPublishTurnTrail, utf8ByteLength, VERB_LIMITS, } from '@canonmsg/core';
-import { boundTrailBlockMap, buildTrailBlockId, buildUndeliverableFinalNotice as buildHostUndeliverableFinalNotice, normalizePlanStepStatus, normalizeTrailKey, PLAN_BLOCK_TITLE, renderPlanSteps, truncateFailureDetail, } from '@canonmsg/coding-agent-host';
+import { buildBoundedTurnTrail, DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES, isRetryableCanonDeliveryError, isSilentTurnSuppressed, shouldPublishTurnTrail, utf8ByteLength, VERB_LIMITS, } from '@canonmsg/core';
+import { boundTrailBlockMap, buildTrailBlockId, buildUndeliverableFinalNotice as buildHostUndeliverableFinalNotice, normalizePlanStepStatus, normalizeTrailKey, PLAN_BLOCK_TITLE, renderPlanSteps, resolveTurnArtifactRouting, truncateFailureDetail, } from '@canonmsg/coding-agent-host';
 export function createClaudeInputEnvelope(input) {
     const sourceMessageId = input.sourceMessageId ?? null;
     const fallbackId = randomUUID();
@@ -60,6 +60,27 @@ export function shouldDeliverClaudeFinal(input) {
         return false;
     return true;
 }
+/**
+ * The artifact half of `shouldDeliverClaudeFinal`: workspace media is posted as
+ * a message, so the same turn-level gates apply to it. Silence is the one this
+ * host was missing — see `resolveTurnArtifactRouting` for the ruling.
+ *
+ * The only place silence is resolved for Claude artifacts. `finalText` is the
+ * model's own reply for the turn (never Canon's failure notice, which is a host
+ * diagnostic and goes out either way), weighed by `isSilentTurnSuppressed` —
+ * the same switch `composeClaudeTurnFinal` reads. One switch, so flipping
+ * `DEFAULT_SILENT_TURN_PRECEDENCE` moves a turn's text and its files together.
+ */
+export function shouldRouteClaudeTurnArtifacts(input) {
+    return resolveTurnArtifactRouting({
+        artifactRoutingMode: input.turn.artifactRoutingMode,
+        interrupted: input.interruptedTurnKeys.has(input.turn.turnKey),
+        silenced: isSilentTurnSuppressed({
+            silenced: input.silencedTurnKeys.has(input.turn.turnKey),
+            finalText: input.finalText,
+        }),
+    });
+}
 /** Bounds the correlation map if the SDK ever stops reporting a uuid we sent. */
 const MAX_TRACKED_DISPATCHED_INPUTS = 64;
 export function rememberDispatchedClaudeInput(dispatched, input) {
@@ -777,6 +798,45 @@ export function composeClaudeFinalText(input) {
         return primary;
     return primary ? `${primary}\n\n${input.failureNotice}` : input.failureNotice;
 }
+/**
+ * What a completed turn actually says, once `no_reply` is taken into account.
+ *
+ * Silence suppresses the MODEL's output and nothing else — its result text or,
+ * failing that, the text it streamed before going quiet. Canon's own "this turn
+ * broke" notice still goes out: suppressing it would leave the owner with a
+ * turn that failed and said nothing, which is exactly what the notice exists to
+ * prevent.
+ *
+ * The two used to be merged. `composeClaudeFinalText` appends the notice to
+ * whatever partial text exists, and the host then turned silence OFF entirely
+ * whenever a notice was present — so a turn that streamed "Here's the chart:",
+ * called `no_reply`, and then hit `error_max_turns` posted the model's line
+ * next to the notice while withholding the chart itself. Codex has never done
+ * that: its failure branches send `formatCodexTurnFailure(...)` alone and never
+ * `result.finalMessage`. This is the same contract on both hosts.
+ */
+export function composeClaudeTurnFinal(input) {
+    const modelText = composeClaudeFinalText({
+        resultText: input.resultText,
+        streamedText: input.streamedText,
+    });
+    const speechSuppressed = isSilentTurnSuppressed({
+        silenced: input.silenced,
+        finalText: modelText,
+    });
+    if (speechSuppressed) {
+        return {
+            finalText: input.failureNotice?.trim() || null,
+            modelText,
+            speechSuppressed: true,
+        };
+    }
+    return {
+        finalText: composeClaudeFinalText(input),
+        modelText,
+        speechSuppressed: false,
+    };
+}
 /**
  * How the host should react to a failed final-reply send.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.30.0",
+  "version": "0.31.1",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,10 +31,10 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.220",
-    "@canonmsg/agent-sdk": "^8.2.0",
-    "@canonmsg/agent-tools": "^0.4.0",
-    "@canonmsg/coding-agent-host": "^0.4.0",
-    "@canonmsg/core": "^10.0.0",
+    "@canonmsg/agent-sdk": "^8.3.0",
+    "@canonmsg/agent-tools": "^0.5.0",
+    "@canonmsg/coding-agent-host": "^0.5.0",
+    "@canonmsg/core": "^10.2.0",
     "@canonmsg/rich-cards": "^0.9.1",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },