@canonmsg/claude-code-plugin 0.29.4 → 0.31.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.29.4",
+  "version": "0.31.0",
   "channels": [
     {
       "server": "canon-channel",

package/README.md

@@ -47,6 +47,7 @@ Public docs: <https://canonmail.com/agents/integrations>. Coding-host concepts:
 - **Interrupt** — Stop Claude mid-response from the app
 - **Context meter** — See context window usage in the app
 - **Max plan auth** — Uses your Claude subscription, no API key billing
+- **Quiet group turns** — In groups the host shows the thinking indicator and the answer only; direct chats keep the live preview and margin activity (`--turn-verbosity`)
 
 ## Working directory
 
@@ -72,6 +73,24 @@ Current Canon truth for Claude host mode:
 - non-owner turns deny local filesystem, shell, web/network, task, MCP, and Canon outbound tools by default in first-party host mode; pure text replies still work, and owners can allow exact safe tool names with `CANON_CLAUDE_NON_OWNER_ALLOWED_TOOLS`
 - if worktree creation is unavailable for the selected project, Canon may fall back to shared-project execution and surface the fallback reason in session details
 
+## Turn verbosity
+
+```bash
+canon-claude --cwd /path/to/project --turn-verbosity quiet
+```
+
+`--turn-verbosity <verbose|quiet|auto>` controls how much of a turn's middle readers see. `CANON_TURN_VERBOSITY` is the environment fallback; the flag wins when both are set.
+
+| Value | Effect |
+|---|---|
+| `auto` (default, same as unset) | Verbose in direct chats, quiet in groups |
+| `verbose` | Live streaming text plus the margin activity rows on the final, everywhere |
+| `quiet` | The thinking indicator and the answer, nothing in between, everywhere |
+
+Quiet drops the live `/streaming` narration and the final's `turnTrail` activity rows. It does **not** drop the thinking indicator (which now stays up for the turn's whole working phase rather than handing over to a bubble that never appears; while the turn is parked on an approval the clients suppress an agent's dots and the header line carries the state), the turn state, the answer — including every part of a long chunked one — failure notices, generated files, or approval and question cards and their receipts.
+
+This is an agent-developer setting. Canon never changes it, and it is deliberately not part of the per-conversation session config a user can edit. `canon-necromance` replays a stored launch command verbatim, so add the flag at registration time if you want a non-default value.
+
 ## Multiple agents
 
 ```bash

package/dist/host.d.ts

@@ -1,6 +1,21 @@
 #!/usr/bin/env node
 import { type PermissionResult, type SDKControlReloadPluginsResponse } from '@anthropic-ai/claude-agent-sdk';
-import { type CanonRuntimeCommandDescriptor } from '@canonmsg/core';
+import { type CanonRuntimeCommandDescriptor, 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".
+ *
+ * A value that parses to nothing is reported and then ignored rather than
+ * thrown on — this host's `parseArgs` is `strict: false`, so a typo'd flag
+ * already survives argv, and refusing to start over a presentation setting
+ * would take the agent offline for it. An empty declaration (`ENV=` in a plist
+ * or `--turn-verbosity ''`) is absence, not a mistake, so it says nothing.
+ */
+export declare function resolveConfiguredClaudeTurnVerbosity(input: {
+    flag?: unknown;
+    env?: string | undefined;
+    onWarning?: (message: string) => void;
+}): TurnVerbosityConfig | null;
 export declare function buildClaudePlanAllowResult(input: Record<string, unknown>): PermissionResult;
 /**
  * Claude Code's own slash commands (built-ins, plugins, project .claude/
@@ -9,4 +24,16 @@ 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 const NO_REPLY_TOOL_NAME: string;
+export declare function buildCanonPrompt(input: {
+    content: string;
+    conversationId: string;
+    participantContext: InboundParticipantContext;
+    behavior?: ResolvedAgentBehaviorPolicy | null;
+    selfContexts?: MessageCreatedPayload['selfContexts'];
+    activeSelfContextId?: string | null;
+    provenance: NonNullable<MessageCreatedPayload['provenance']>;
+    replyContext?: CanonReplyContext | null;
+    message?: MessageCreatedPayload['message'];
+}): string;
 export declare function main(): Promise<void>;

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, buildBoundedTurnTrail, 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, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, 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, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, prepareTurnTrailForDelivery, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, 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;
@@ -58,6 +58,12 @@ COMMON FLAGS
                           Override a hidden detail field
   --hide-runtime-detail <field>
                           Hide a runtime detail field
+  --turn-verbosity <verbose|quiet|auto>
+                          How much of a turn's middle readers see. Default
+                          (auto): verbose in direct chats, quiet in groups —
+                          quiet shows the thinking indicator and the answer,
+                          with no live narration and no margin activity rows.
+                          Env: CANON_TURN_VERBOSITY
   --help, -h               Show this help
   --version, -V            Show package version
 
@@ -80,6 +86,37 @@ let workspaceRootMetadata = [];
 let runtimeModels = [];
 const CLAUDE_METADATA_TTL_MS = 5 * 60 * 1000;
 const allowedNonOwnerClaudeTools = parseAllowedNonOwnerClaudeTools(process.env.CANON_CLAUDE_NON_OWNER_ALLOWED_TOOLS);
+/**
+ * Agent-developer setting, resolved once at startup. Deliberately NOT read from
+ * `/session-config`: that path is the USER's per-conversation control plane,
+ * and owner ruling 5 puts turn verbosity outside user control.
+ */
+let configuredTurnVerbosity = null;
+/**
+ * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
+ * per-conversation-type default".
+ *
+ * A value that parses to nothing is reported and then ignored rather than
+ * thrown on — this host's `parseArgs` is `strict: false`, so a typo'd flag
+ * already survives argv, and refusing to start over a presentation setting
+ * would take the agent offline for it. An empty declaration (`ENV=` in a plist
+ * or `--turn-verbosity ''`) is absence, not a mistake, so it says nothing.
+ */
+export function resolveConfiguredClaudeTurnVerbosity(input) {
+    const sources = [
+        ['--turn-verbosity', typeof input.flag === 'string' ? input.flag : undefined],
+        ['CANON_TURN_VERBOSITY', input.env],
+    ];
+    for (const [name, raw] of sources) {
+        const parsed = parseTurnVerbosityConfig(raw);
+        if (parsed)
+            return parsed;
+        if (raw && raw.trim()) {
+            input.onWarning?.(`Ignoring ${name}=${JSON.stringify(raw)} — expected verbose, quiet or auto.`);
+        }
+    }
+    return null;
+}
 let runtimeMetadata = {
     account: null,
     mcpServers: [],
@@ -699,7 +736,19 @@ const CLAUDE_RUNTIME_CAPABILITIES = {
     supportsRequiresAction: true,
     supportsNonFinalPermanentMessages: false,
 };
-function buildCanonPrompt(input) {
+/**
+ * The silence affordance as the model sees it here: the verbs are mounted as an
+ * in-process MCP server, so `no_reply` reaches the model namespaced. The group
+ * guidance in the shared frame names it; a runtime without the tool passes
+ * nothing and its cue drops the silence clause entirely.
+ *
+ * The verb segment is type-anchored: renaming the verb in `canon.verbs.v1` must
+ * fail the build here rather than leave every group turn pointing the model at
+ * a tool it does not have.
+ */
+const NO_REPLY_VERB = 'no_reply';
+export const NO_REPLY_TOOL_NAME = `mcp__${CANON_VERB_MCP_SERVER_NAME}__${NO_REPLY_VERB}`;
+export function buildCanonPrompt(input) {
     return renderCodingHostInboundPrompt(buildCanonInboundFrameV1(buildCanonTurnContextV2({
         content: input.content,
         conversationId: input.conversationId,
@@ -710,13 +759,27 @@ function buildCanonPrompt(input) {
         provenance: input.provenance,
         replyContext: input.replyContext,
         message: input.message,
-    })));
+    })), { noReplyToolName: NO_REPLY_TOOL_NAME });
 }
 function resolveArtifactRoutingMode(participantContext) {
     return participantContext.conversationType === 'direct' && participantContext.isOwner
         ? 'workspace-generated'
         : 'disabled';
 }
+/**
+ * Everything about a turn that is decided from the message that started it, in
+ * one place. Both are resolved at the enqueue site and ride the envelope so a
+ * message that waits in the queue still runs under the answer it arrived with.
+ */
+function resolveClaudeTurnModes(participantContext) {
+    return {
+        artifactRoutingMode: resolveArtifactRoutingMode(participantContext),
+        turnVerbosity: resolveTurnVerbosity({
+            configured: configuredTurnVerbosity,
+            conversationType: participantContext.conversationType,
+        }),
+    };
+}
 function renderInboundContent(message, materialized) {
     return renderCanonHostInboundContent(message, materialized);
 }
@@ -773,7 +836,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             messageQueue.push(input);
         }
     };
-    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => {
+    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => {
         sendInput(createClaudeInputEnvelope({
             kind: 'canon',
             msg,
@@ -782,7 +845,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             markAccepted,
             isOwnerTurn,
             requestingUserId,
-            artifactRoutingMode,
+            ...turnModes,
         }));
     };
     // Envelopes pulled by the SDK, keyed by the uuid stamped on each message, so a
@@ -919,6 +982,12 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                         ...(routing.responseUserId ? { responseUserId: routing.responseUserId } : {}),
                     };
+                }, (verb) => {
+                    if (verb !== 'no_reply')
+                        return;
+                    const turnKey = session.activeInput?.turnKey;
+                    if (turnKey)
+                        session.silencedTurnKeys.add(turnKey);
                 }),
             },
         },
@@ -1028,7 +1097,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         }
                         // The SDK leaves plan mode when we allow ExitPlanMode, but it does
                         // not notify the host, so reset the mirrored permission mode here so
-                        // the composer turn-mode toggle and permission chip stop reporting
+                        // the permission chip and session surfaces stop reporting
                         // 'plan'. Approve-only: on reject/revise the SDK stays in plan mode.
                         if (session.state.permissionMode === 'plan') {
                             session.state.permissionMode = 'default';
@@ -1108,7 +1177,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         environment,
         query: q,
         sendInput,
-        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, requestingUserId, artifactRoutingMode),
+        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, requestingUserId, turnModes),
         state: {
             model: undefined,
             permissionMode: config.permissionMode,
@@ -1117,6 +1186,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             state: 'idle',
         },
         availableModels: config.availableModels,
+        // Corrected by the first turn that opens; a session with no turn publishes
+        // nothing anyway.
+        turnVerbosity: 'verbose',
         streamingText: '',
         streamingTimer: null,
         idleResetTimer: null,
@@ -1126,6 +1198,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         dispatchingInput: null,
         finalizedTurnKeys: new Set(),
         interruptedTurnKeys: new Set(),
+        silencedTurnKeys: new Set(),
         pendingFinalText: null,
         pendingFinalDelivery: null,
         runtimeControlErrors: {},
@@ -1156,16 +1229,15 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         writeSnapshot: (snapshot) => {
             if (session.closed)
                 return Promise.resolve();
-            const turnId = session.currentTurnId ?? snapshot.turnId;
-            session.streamingText = snapshot.text;
-            const blocks = snapshot.blocks?.map((block) => ({ ...block, turnId }));
-            return runtimeState.writeStreaming(conversationId, {
-                text: snapshot.text,
-                status: snapshot.status,
-                messageId: turnId,
-                turnId,
-                blocks,
+            const write = planClaudeStreamingWrite({
+                snapshot,
+                turnId: session.currentTurnId ?? snapshot.turnId,
+                turnVerbosity: session.turnVerbosity,
             });
+            session.streamingText = write?.text ?? '';
+            if (!write)
+                return Promise.resolve();
+            return runtimeState.writeStreaming(conversationId, write);
         },
         clearSnapshot: () => {
             session.streamingText = '';
@@ -1213,19 +1285,17 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         config.onInputCompleted?.(input.sourceMessageId);
     }
     /**
-     * The turn trail to attach to the final send.
-     *
-     * Filtering runs BEFORE bounding on purpose. `buildBoundedTurnTrail` walks
-     * blocks in sequence order and stops at the first one that would exceed its
-     * byte budget, and Claude's text blocks are the fattest entries — bounding
-     * first would spend the budget on blocks a chunked final then discards,
-     * leaving the margin with fewer tool blocks than it could have shown. With
-     * `willChunk` false this is exactly `getFinalTrail()`.
+     * The turn trail to attach to the final send. Empty on a quiet turn — see
+     * `claudeFinalTurnTrail`, which owns both that gate and the chunked-final
+     * filter.
      */
     function getFinalTurnTrail(willChunk) {
-        const turnId = session.currentTurnId ?? `claude-${conversationId}`;
-        const blocks = prepareTurnTrailForDelivery(streamingOutput.getBlocks(), willChunk);
-        return buildBoundedTurnTrail(blocks).map((block) => ({ ...block, turnId }));
+        return claudeFinalTurnTrail({
+            blocks: streamingOutput.getBlocks(),
+            turnId: session.currentTurnId ?? `claude-${conversationId}`,
+            willChunk,
+            turnVerbosity: session.turnVerbosity,
+        });
     }
     function clearIdleResetTimer() {
         if (!session.idleResetTimer)
@@ -1530,37 +1600,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)
@@ -1684,7 +1749,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         }
         runtimeState.writeTurnState(conversationId, {
             turnId: session.currentTurnId,
-            state: session.turnState,
+            state: publishedClaudeTurnState(session.turnState, session.turnVerbosity),
             queueDepth: session.pendingInputs.length,
             currentSpeakerId: agentId,
             lastAcceptedIntent: session.lastAcceptedIntent,
@@ -1747,6 +1812,11 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         if (session.closed || !claudeInputOwnsTurnSlot(input))
             return;
         clearIdleResetTimer();
+        // Adopted BEFORE the first publish of this turn, and left alone until the
+        // next one opens: the seed, every delta, the final's trail and the
+        // turn-state writes all read it, and a mid-turn change would make them
+        // disagree with each other.
+        session.turnVerbosity = input.turnVerbosity;
         openClaudeTurn(session);
         startVisibleWorkSignal();
         writeTurn();
@@ -1874,7 +1944,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     function hasInterruptibleSdkInput() {
         return session.activeInput !== null && session.dispatchingInput === null;
     }
-    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => {
+    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => {
         session.lastActivity = Date.now();
         const input = createClaudeInputEnvelope({
             kind: 'canon',
@@ -1884,7 +1954,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             markAccepted,
             isOwnerTurn,
             requestingUserId,
-            artifactRoutingMode,
+            ...turnModes,
         });
         const decision = decideClaudeInboundDispatch({
             intent,
@@ -2035,7 +2105,13 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         else if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
                             session.toolInProgress = false;
                             session.turnState = 'streaming';
-                            stopVisibleWorkSignal();
+                            // The dots stop here only because the live bubble takes over as
+                            // the indicator. A quiet turn has no bubble, so stopping them
+                            // would leave the reader with nothing for the whole generation
+                            // phase — the longest stretch of the turn.
+                            if (shouldStopTypingDotsOnStreamedText(session.turnVerbosity)) {
+                                stopVisibleWorkSignal();
+                            }
                             writeTurn();
                             const blockIndex = typeof event.index === 'number' ? event.index : 'latest';
                             onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${blockIndex}`);
@@ -2137,11 +2213,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()
                             : '';
@@ -2156,11 +2227,21 @@ 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 finalText = turnFinal.finalText;
+                        if (completedInput?.kind === 'canon') {
+                            await routeArtifactsForInput(completedInput, turnFinal.modelText);
+                        }
                         const shouldDeliverFinal = finalText
                             ? shouldDeliverClaudeFinal({
                                 turn: completedInput,
@@ -2168,6 +2249,20 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                                 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.
@@ -2209,6 +2304,19 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             if (shouldDeliverFinal && finalText) {
                                 scheduleFinalHandoffReset();
                             }
+                            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
+                                // then rides the delivered-final handoff so the thinking
+                                // indicator ends exactly as it does for a real reply.
+                                await streamingOutput.blankAndClear().catch(() => { });
+                                // The live row is gone the moment the node is; without this the
+                                // handoff timer would leave typing dots behind it for 750 ms,
+                                // reading as "started to answer, then gave up".
+                                stopVisibleWorkSignal();
+                                scheduleFinalHandoffReset();
+                            }
                             else {
                                 // Nothing durable is coming, so retire the live bubble here.
                                 // The delivering path does this after a handoff delay; without
@@ -2322,9 +2430,15 @@ export async function main() {
             'runtime-visibility': { type: 'string' },
             'show-runtime-detail': { type: 'string', multiple: true },
             'hide-runtime-detail': { type: 'string', multiple: true },
+            'turn-verbosity': { type: 'string' },
         },
         strict: false,
     });
+    configuredTurnVerbosity = resolveConfiguredClaudeTurnVerbosity({
+        flag: args['turn-verbosity'],
+        env: process.env.CANON_TURN_VERBOSITY,
+        onWarning: (message) => console.error(`[canon-host] ${message}`),
+    });
     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');
@@ -3051,7 +3165,7 @@ export async function main() {
             promptText,
             materialized: [...replyMedia.materialized, ...materialized],
         });
-        const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+        const turnModes = resolveClaudeTurnModes(participantContext);
         session.enqueueInbound({
             type: 'user',
             message: {
@@ -3064,7 +3178,7 @@ export async function main() {
                 senderId: m.senderId,
                 senderName: m.senderName,
             }),
-        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, artifactRoutingMode);
+        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
         return 'queued';
     }
     const acceptedInboundMessageIds = new Set();
@@ -3288,7 +3402,7 @@ export async function main() {
                         promptText,
                         materialized: [...replyMedia.materialized, ...materialized],
                     });
-                    const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+                    const turnModes = resolveClaudeTurnModes(participantContext);
                     session.enqueueInbound({
                         type: 'user',
                         message: {
@@ -3301,7 +3415,7 @@ export async function main() {
                             senderId: m.senderId,
                             senderName: m.senderName,
                         }),
-                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, artifactRoutingMode);
+                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
                     return true;
                 })().then((queued) => {
                     if (!queued)

package/dist/server.js

@@ -171,6 +171,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             },
         },
         // Canonical verbs — projections of canon.verbs.v1 (@canonmsg/agent-tools).
+        // 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(),
     ],
 }));

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, TurnLifecycleState, TurnOutputBlock } from '@canonmsg/core';
-import type { TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
+import type { DeliveryIntent, ModelOption, RuntimeStreamingPayload, TurnLifecycleState, TurnOutputBlock, TurnOutputSnapshot, TurnVerbosity } from '@canonmsg/core';
+import type { TurnArtifactRoutingDecision, TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
@@ -12,11 +12,26 @@ export interface ClaudeInputEnvelope {
     sourceMessageId: string | null;
     markAccepted: boolean;
     artifactRoutingMode: ClaudeArtifactRoutingMode;
+    /**
+     * How loud this turn is, resolved when the message arrived and carried here
+     * so the whole turn — including a resumed final delivery — runs under one
+     * answer. The session re-affirms it at `openTurn`, which is what corrects a
+     * session created while a conversation fetch was failing.
+     */
+    turnVerbosity: TurnVerbosity;
     artifactBaseline: TurnArtifactSnapshot | null;
     turnKey: string;
     isOwnerTurn: boolean;
     requestingUserId: string | null;
 }
+/**
+ * The per-turn modes an inbound message resolves from its participant context,
+ * grouped so they travel together from the enqueue site onto the envelope.
+ */
+export interface ClaudeTurnModes {
+    artifactRoutingMode?: ClaudeArtifactRoutingMode;
+    turnVerbosity?: TurnVerbosity;
+}
 export interface ClaudeRuntimeControlError {
     value: string;
     message: string;
@@ -83,6 +98,7 @@ export declare function createClaudeInputEnvelope(input: {
     sourceMessageId?: string | null;
     markAccepted?: boolean;
     artifactRoutingMode?: ClaudeArtifactRoutingMode;
+    turnVerbosity?: TurnVerbosity;
     artifactBaseline?: TurnArtifactSnapshot | null;
     isOwnerTurn?: boolean;
     requestingUserId?: string | null;
@@ -102,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`.
@@ -123,6 +156,7 @@ export declare function describeUndeliveredClaudeFinal(input: {
     turn: ClaudeInputEnvelope | null;
     finalizedTurnKeys: ReadonlySet<string>;
     interruptedTurnKeys: ReadonlySet<string>;
+    silencedTurnKeys?: ReadonlySet<string>;
 }): string;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
 export interface ClaudeTurnSlotState {
@@ -480,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.
@@ -550,6 +619,76 @@ export declare function claudeFinalWillChunk(finalText: string, maxTextBytes?: n
  * which keeps the common case byte-identical to before.
  */
 export declare function prepareTurnTrailForDelivery(trail: ReadonlyArray<TurnOutputBlock>, willChunk: boolean): TurnOutputBlock[];
+/**
+ * The trail to hang on this turn's final.
+ *
+ * The quiet gate lives HERE rather than in the controller because the two are
+ * genuinely separate decisions: a quiet turn runs its controller in `'status'`
+ * mode, which drops the live writes but keeps accumulating blocks in memory —
+ * so `getBlocks()` still returns a full trail for a turn the reader watched in
+ * silence. Forgetting this second gate is the one way quiet mode half-ships.
+ *
+ * Filtering runs BEFORE bounding, as it did inline: `buildBoundedTurnTrail`
+ * stops at the first block that would exceed its byte budget, and Claude's text
+ * blocks are the fattest entries — bounding first would spend the budget on
+ * blocks a chunked final then discards.
+ */
+export declare function claudeFinalTurnTrail(input: {
+    blocks: ReadonlyArray<TurnOutputBlock>;
+    turnId: string;
+    willChunk: boolean;
+    turnVerbosity: TurnVerbosity;
+}): TurnOutputBlock[];
+/**
+ * The turn state a quiet turn publishes to `/turn-state`.
+ *
+ * Current clients render "is thinking" for every open non-waiting state, so
+ * the chat header is unchanged. It exists for app binaries older than #602,
+ * whose `filterVisibleTypingUsers` suppressed an agent's typing dots whenever
+ * its turn state was `streaming` or `tool` — on the assumption that a live
+ * bubble was carrying the state instead. A quiet turn has no bubble, so such a
+ * binary would show nothing at all for the back half of the turn. Staying on
+ * `thinking` keeps its dots.
+ *
+ * One current consumer does read the difference: the direct-chat session strip
+ * (`buildAgentSessionPresentation`, which early-returns for group chats) labels
+ * turn state `streaming` "Streaming" / "Live preview" and `thinking`
+ * "Thinking". So a direct chat started with an explicit `--turn-verbosity
+ * quiet` reads "Thinking" for the whole turn — which is what a turn publishing
+ * no live preview actually is.
+ *
+ * `waiting_input` is deliberately NOT folded in: it is the one state that
+ * changes what the header says and how the clients treat the dots, and a turn
+ * blocked on a human is not thinking.
+ */
+export declare function publishedClaudeTurnState(state: TurnLifecycleState, turnVerbosity: TurnVerbosity): TurnLifecycleState;
+/**
+ * The `/streaming` write for one snapshot, or `null` for none.
+ *
+ * Extracted from the session's `writeSnapshot` so the quiet gate is a unit a
+ * test can hold rather than one inline comparison a refactor can drop in
+ * silence. The gate cannot live in the controller's `mode`: the controller is
+ * per-SESSION here while verbosity is per-TURN.
+ *
+ * A quiet turn publishes no node at all rather than a status-only one. Writing
+ * then deleting would hand `onStreamingCleared` something to salvage into a
+ * durable bubble the reader was never meant to see; never writing leaves the
+ * delete with nothing to fire on.
+ */
+export declare function planClaudeStreamingWrite(input: {
+    snapshot: TurnOutputSnapshot;
+    turnId: string;
+    turnVerbosity: TurnVerbosity;
+}): RuntimeStreamingPayload | null;
+/**
+ * When streamed text starts arriving, do the typing dots retire?
+ *
+ * In verbose they do, and should: the live bubble becomes the indicator, and
+ * two indicators for one turn is noise. A quiet turn has no bubble, so the
+ * dots are the only thing the reader has for the whole generation phase — the
+ * longest stretch of the turn. Spelled the same way on the Codex host.
+ */
+export declare function shouldStopTypingDotsOnStreamedText(turnVerbosity: TurnVerbosity): boolean;
 export declare const CLAUDE_FINAL_TRUNCATION_MARKER = "\n\n_[truncated \u2014 the full answer exceeded Canon's message size limit]_";
 /**
  * Last-resort degradation for a final Canon refuses to accept: keep as much of

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 { DEFAULT_CHUNKED_MESSAGE_TEXT_MAX_BYTES, isRetryableCanonDeliveryError, 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();
@@ -17,6 +17,10 @@ export function createClaudeInputEnvelope(input) {
         sourceMessageId,
         markAccepted: Boolean(input.markAccepted),
         artifactRoutingMode: input.artifactRoutingMode ?? 'disabled',
+        // Verbose is the safe default for an envelope nobody resolved (the internal
+        // `seed` kind, and any caller that predates the flag): quiet is a decision,
+        // never an accident.
+        turnVerbosity: input.turnVerbosity ?? 'verbose',
         artifactBaseline: input.artifactBaseline ?? null,
         isOwnerTurn: input.kind === 'canon'
             ? input.isOwnerTurn === true
@@ -56,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) {
@@ -101,6 +126,10 @@ export function claudeInputOwnsTurnSlot(input) {
 export function describeUndeliveredClaudeFinal(input) {
     if (!input.turn)
         return 'no Canon turn owns this result';
+    // Checked first: callers pass this set only when silence actually gated the
+    // turn, and when it did it IS the reason, whatever else is true of the turn.
+    if (input.silencedTurnKeys?.has(input.turn.turnKey))
+        return 'turn chose no_reply';
     if (input.turn.kind !== 'canon')
         return `owning turn is '${input.turn.kind}'`;
     if (input.interruptedTurnKeys.has(input.turn.turnKey))
@@ -769,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.
  *
@@ -865,6 +933,90 @@ export function prepareTurnTrailForDelivery(trail, willChunk) {
         return [...trail];
     return trail.filter((block) => block.kind !== 'text');
 }
+/**
+ * The trail to hang on this turn's final.
+ *
+ * The quiet gate lives HERE rather than in the controller because the two are
+ * genuinely separate decisions: a quiet turn runs its controller in `'status'`
+ * mode, which drops the live writes but keeps accumulating blocks in memory —
+ * so `getBlocks()` still returns a full trail for a turn the reader watched in
+ * silence. Forgetting this second gate is the one way quiet mode half-ships.
+ *
+ * Filtering runs BEFORE bounding, as it did inline: `buildBoundedTurnTrail`
+ * stops at the first block that would exceed its byte budget, and Claude's text
+ * blocks are the fattest entries — bounding first would spend the budget on
+ * blocks a chunked final then discards.
+ */
+export function claudeFinalTurnTrail(input) {
+    if (!shouldPublishTurnTrail(input.turnVerbosity))
+        return [];
+    const filtered = prepareTurnTrailForDelivery(input.blocks, input.willChunk);
+    return buildBoundedTurnTrail(filtered).map((block) => ({ ...block, turnId: input.turnId }));
+}
+/**
+ * The turn state a quiet turn publishes to `/turn-state`.
+ *
+ * Current clients render "is thinking" for every open non-waiting state, so
+ * the chat header is unchanged. It exists for app binaries older than #602,
+ * whose `filterVisibleTypingUsers` suppressed an agent's typing dots whenever
+ * its turn state was `streaming` or `tool` — on the assumption that a live
+ * bubble was carrying the state instead. A quiet turn has no bubble, so such a
+ * binary would show nothing at all for the back half of the turn. Staying on
+ * `thinking` keeps its dots.
+ *
+ * One current consumer does read the difference: the direct-chat session strip
+ * (`buildAgentSessionPresentation`, which early-returns for group chats) labels
+ * turn state `streaming` "Streaming" / "Live preview" and `thinking`
+ * "Thinking". So a direct chat started with an explicit `--turn-verbosity
+ * quiet` reads "Thinking" for the whole turn — which is what a turn publishing
+ * no live preview actually is.
+ *
+ * `waiting_input` is deliberately NOT folded in: it is the one state that
+ * changes what the header says and how the clients treat the dots, and a turn
+ * blocked on a human is not thinking.
+ */
+export function publishedClaudeTurnState(state, turnVerbosity) {
+    if (turnVerbosity !== 'quiet')
+        return state;
+    return state === 'streaming' || state === 'tool' ? 'thinking' : state;
+}
+/**
+ * The `/streaming` write for one snapshot, or `null` for none.
+ *
+ * Extracted from the session's `writeSnapshot` so the quiet gate is a unit a
+ * test can hold rather than one inline comparison a refactor can drop in
+ * silence. The gate cannot live in the controller's `mode`: the controller is
+ * per-SESSION here while verbosity is per-TURN.
+ *
+ * A quiet turn publishes no node at all rather than a status-only one. Writing
+ * then deleting would hand `onStreamingCleared` something to salvage into a
+ * durable bubble the reader was never meant to see; never writing leaves the
+ * delete with nothing to fire on.
+ */
+export function planClaudeStreamingWrite(input) {
+    if (input.turnVerbosity === 'quiet')
+        return null;
+    return {
+        text: input.snapshot.text,
+        status: input.snapshot.status,
+        messageId: input.turnId,
+        turnId: input.turnId,
+        ...(input.snapshot.blocks
+            ? { blocks: input.snapshot.blocks.map((block) => ({ ...block, turnId: input.turnId })) }
+            : {}),
+    };
+}
+/**
+ * When streamed text starts arriving, do the typing dots retire?
+ *
+ * In verbose they do, and should: the live bubble becomes the indicator, and
+ * two indicators for one turn is noise. A quiet turn has no bubble, so the
+ * dots are the only thing the reader has for the whole generation phase — the
+ * longest stretch of the turn. Spelled the same way on the Codex host.
+ */
+export function shouldStopTypingDotsOnStreamedText(turnVerbosity) {
+    return turnVerbosity !== 'quiet';
+}
 export const CLAUDE_FINAL_TRUNCATION_MARKER = "\n\n_[truncated — the full answer exceeded Canon's message size limit]_";
 /** How far back from the cut a paragraph break is still worth cutting at. */
 const CLAUDE_TRUNCATION_BOUNDARY_WINDOW_CHARS = 400;

package/dist/tool-policy.js

@@ -63,6 +63,9 @@ const CANON_HITL_OR_READ_VERBS = new Set([
     'list_contacts',
     'list_contact_requests',
     'list_conversations',
+    // Staying quiet posts nothing; an approval card asking permission for
+    // silence would gate a no-op behind a human decision.
+    'no_reply',
 ]);
 // Asking permission to create or poll an interaction would put the interaction
 // behind another interaction and can recurse indefinitely. Fail closed instead.
@@ -86,6 +89,9 @@ const CANON_NON_OWNER_ALLOWED_VERBS = new Set([
     'check_approval',
     'send_card',
     'request_card',
+    // The group turn is exactly where silence matters, and group turns are
+    // usually non-owner turns.
+    'no_reply',
 ]);
 export function canonVerbFromToolName(toolName) {
     const normalized = normalizeToolName(toolName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.29.4",
+  "version": "0.31.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.220",
-    "@canonmsg/agent-sdk": "^8.1.0",
-    "@canonmsg/agent-tools": "^0.3.4",
-    "@canonmsg/coding-agent-host": "^0.4.0",
-    "@canonmsg/core": "^9.2.0",
-    "@canonmsg/rich-cards": "^0.9.0",
+    "@canonmsg/agent-sdk": "^8.2.0",
+    "@canonmsg/agent-tools": "^0.4.0",
+    "@canonmsg/coding-agent-host": "^0.5.0",
+    "@canonmsg/core": "^10.1.0",
+    "@canonmsg/rich-cards": "^0.9.1",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {