@canonmsg/claude-code-plugin 0.31.2 → 0.31.4

package/.claude-plugin/plugin.json

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

package/README.md

@@ -63,6 +63,8 @@ canon-claude --cwd ~/dev --workspace-root ~/dev
 
 `--cwd` is the default workspace. Each `--workspace-root` value is an approved local root; the host discovers immediate child projects with common markers such as `.git`, `package.json`, `pyproject.toml`, `Cargo.toml`, or `go.mod` and publishes them as selectable projects during session creation. Use repeated `--workspace /path/to/project` entries to advertise specific projects outside those roots. Worktree mode creates a best-effort per-conversation git worktree under `~/.canon/conversation-worktrees`; shared-project mode runs directly in the selected directory.
 
+Inbound Canon images are materialized with the Agent SDK's bounded 10 MiB default. The host sends supported images to the direct Anthropic transport as native base64 blocks only when each raw file is at most 7 MiB and the exact encoded content array plus prompt text fit the aggregate request budget with reserved framing headroom. Seven MiB is derived specifically from the direct transport's 10 MB encoded-image limit; it is not a portable default for Bedrock or Vertex. Materialized images omitted from native blocks remain available by local path. Images over the 10 MiB automatic-download limit instead receive a validated HTTPS link in the Claude prompt; materialized images never receive a duplicate link.
+
 Current Canon truth for Claude host mode:
 
 - model is live-editable
@@ -87,6 +89,11 @@ canon-claude --cwd /path/to/project --turn-verbosity quiet
 | `verbose` | Live streaming text plus the margin activity rows on the final, everywhere |
 | `quiet` | The thinking indicator and the answer, nothing in between, everywhere |
 
+In verbose mode, authored text remains continual across tool use: text before a
+tool stays as its own speech bubble, the tool appears in the activity margin,
+and text after the result resumes in a new bubble. These are ephemeral streaming
+updates; only the final durable `turn_complete` message is notification-eligible.
+
 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.

package/dist/canon-user-content.d.ts

@@ -0,0 +1,22 @@
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { type AnthropicImageBudgetOptions, type MaterializedCanonAttachment } from '@canonmsg/agent-sdk';
+import { renderCanonHostInboundContent, type CanonReplyContext } from '@canonmsg/core';
+type ClaudeRenderableInboundMessage = Parameters<typeof renderCanonHostInboundContent>[0];
+/**
+ * Claude-only rendering policy for Canon media. Core deliberately omits all
+ * URLs globally. This wrapper restores validated HTTPS links only for images
+ * that the bounded runtime did not materialize, while materialized images keep
+ * their local-path placeholder without a duplicate link.
+ */
+export declare function renderClaudeInboundContent(message: ClaudeRenderableInboundMessage, materialized?: ReadonlyArray<MaterializedCanonAttachment>): string;
+export declare function withClaudeReplyContextMediaReferences(replyContext: CanonReplyContext | null, materialized: ReadonlyArray<MaterializedCanonAttachment>): CanonReplyContext | null;
+/**
+ * Build the Claude Code SDK's multimodal user content without allowing native
+ * image blocks to consume the whole request. The prompt text is preserved
+ * verbatim, including local paths for images omitted from native blocks.
+ */
+export declare function buildCanonUserContent(input: {
+    promptText: string;
+    materialized: ReadonlyArray<MaterializedCanonAttachment>;
+}, budget?: Omit<AnthropicImageBudgetOptions, 'promptText'>): Promise<string | SDKUserMessage['message']['content']>;
+export {};

package/dist/canon-user-content.js

@@ -0,0 +1,72 @@
+import { toAnthropicImageBlocksWithinBudget, } from '@canonmsg/agent-sdk';
+import { renderCanonHostInboundContent, } from '@canonmsg/core';
+const MAX_PROMPT_ATTACHMENT_URL_LENGTH = 8_192;
+function validatedPromptAttachmentUrl(value) {
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.length > MAX_PROMPT_ATTACHMENT_URL_LENGTH
+        || /[\u0000-\u0020\u007f]/.test(value)) {
+        return null;
+    }
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol !== 'https:'
+            || parsed.hostname.length === 0
+            || parsed.username.length > 0
+            || parsed.password.length > 0) {
+            return null;
+        }
+        return parsed.href;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Claude-only rendering policy for Canon media. Core deliberately omits all
+ * URLs globally. This wrapper restores validated HTTPS links only for images
+ * that the bounded runtime did not materialize, while materialized images keep
+ * their local-path placeholder without a duplicate link.
+ */
+export function renderClaudeInboundContent(message, materialized = []) {
+    const rendered = renderCanonHostInboundContent(message, materialized);
+    const materializedIndexes = new Set(materialized.map((attachment) => attachment.index));
+    const imageLinks = (message.attachments ?? []).flatMap((attachment, index) => {
+        if (attachment.kind !== 'image' || materializedIndexes.has(index))
+            return [];
+        const url = validatedPromptAttachmentUrl(attachment.url);
+        return url ? [`[Image ${index + 1} link: ${url}]`] : [];
+    });
+    return imageLinks.length > 0 ? `${rendered}\n${imageLinks.join('\n')}` : rendered;
+}
+export function withClaudeReplyContextMediaReferences(replyContext, materialized) {
+    if (!replyContext?.found)
+        return replyContext;
+    return {
+        ...replyContext,
+        body: renderClaudeInboundContent({
+            text: replyContext.text,
+            contentType: replyContext.contentType,
+            attachments: replyContext.attachments,
+            contactCard: replyContext.contactCard,
+            senderType: replyContext.senderType ?? undefined,
+        }, materialized),
+    };
+}
+/**
+ * Build the Claude Code SDK's multimodal user content without allowing native
+ * image blocks to consume the whole request. The prompt text is preserved
+ * verbatim, including local paths for images omitted from native blocks.
+ */
+export async function buildCanonUserContent(input, budget) {
+    const imageBlocks = await toAnthropicImageBlocksWithinBudget(input.materialized, {
+        promptText: input.promptText,
+        ...budget,
+    });
+    if (imageBlocks.length === 0)
+        return input.promptText;
+    return [
+        { type: 'text', text: input.promptText },
+        ...imageBlocks,
+    ];
+}

package/dist/host.js

@@ -26,14 +26,15 @@ import { execFileSync } from 'node:child_process';
 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 { materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
-import { 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 { buildCanonUserContent, renderClaudeInboundContent, withClaudeReplyContextMediaReferences, } from './canon-user-content.js';
+import { EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { runCli } from '@canonmsg/core';
 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, 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 { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, beginClaudeAssistantResponse, claimClaudeTextSegmentId, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, endClaudeAssistantResponse, 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;
@@ -781,43 +782,30 @@ function resolveClaudeTurnModes(participantContext) {
     };
 }
 function renderInboundContent(message, materialized) {
-    return renderCanonHostInboundContent(message, materialized);
+    return renderClaudeInboundContent(message, materialized);
 }
 async function materializePromptReplyContext(input) {
     if (!input.replyContext?.found || !input.replyContext.attachments?.length) {
         return { replyContext: input.replyContext, materialized: [] };
     }
     try {
-        return await materializeReplyContextMedia(input.replyContext, {
+        const result = await materializeReplyContextMedia(input.replyContext, {
             agentId: input.agentId,
             conversationId: input.conversationId,
         });
+        return {
+            ...result,
+            replyContext: withClaudeReplyContextMediaReferences(result.replyContext, result.materialized),
+        };
     }
     catch (error) {
         console.error(`${input.logPrefix} Failed to materialize replied-to media:`, error instanceof Error ? error.message : error);
-        return { replyContext: input.replyContext, materialized: [] };
+        return {
+            replyContext: withClaudeReplyContextMediaReferences(input.replyContext, []),
+            materialized: [],
+        };
     }
 }
-/**
- * Build the multimodal `content` payload handed to the Claude Code SDK.
- *
- * Images are delivered as native Anthropic `image` blocks (base64) so the
- * vision model sees pixels, not a text reference to a URL. Non-image
- * attachments (audio, files) are referenced by their local path inside the
- * text prompt — see `renderCanonHostInboundContent` — so the agent can
- * Read them on demand.
- */
-async function buildCanonUserContent(input) {
-    const imageAttachments = input.materialized.filter(isAnthropicImageAttachment);
-    if (imageAttachments.length === 0) {
-        return input.promptText;
-    }
-    const imageBlocks = await Promise.all(imageAttachments.map((attachment) => toAnthropicImageBlock(attachment)));
-    return [
-        { type: 'text', text: input.promptText },
-        ...imageBlocks,
-    ];
-}
 // ── Session factory ─────────────────────────────────────────────────
 function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
@@ -2078,7 +2066,17 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         // being written.
                         if (!isClaudeMainTurnMessage(msg.parent_tool_use_id))
                             break;
-                        if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                        if (event?.type === 'message_start') {
+                            beginClaudeAssistantResponse(session.turnActivity);
+                        }
+                        else if (event?.type === 'message_stop') {
+                            endClaudeAssistantResponse(session.turnActivity);
+                        }
+                        else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                            // A tool is also a response boundary for speech. This fallback
+                            // keeps continual streaming correct on SDK streams that omit raw
+                            // message_start/message_stop events.
+                            endClaudeAssistantResponse(session.turnActivity);
                             // Claimed per CALL, keyed by the SDK's tool_use id. The old id was
                             // the turn id, so every call in a turn wrote over the same row.
                             const commands = planClaudeToolCallStart(session.turnActivity, {
@@ -2116,8 +2114,10 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                                 stopVisibleWorkSignal();
                             }
                             writeTurn();
-                            const blockIndex = typeof event.index === 'number' ? event.index : 'latest';
-                            onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${blockIndex}`);
+                            onStreamDelta(event.delta.text, claimClaudeTextSegmentId(session.turnActivity, {
+                                turnId: session.currentTurnId ?? conversationId,
+                                index: event.index,
+                            }));
                         }
                         break;
                     }

package/dist/server.js

@@ -10,9 +10,10 @@ import { setDefaultResultOrder } from 'node:dns';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, verifyResolvedAgentEnvironment, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, verifyResolvedAgentEnvironment, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, } from '@canonmsg/core';
 import { materializeMessageMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { ApprovalHttpServer } from './approval-server.js';
+import { renderClaudeInboundContent } from './canon-user-content.js';
 import { runCli } from '@canonmsg/core';
 import { parseReplyArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
 import { canonVerbToolDefinitions, executeCanonVerbTool, isCanonToolVerb, stampSendToTurnComplete, } from '@canonmsg/agent-tools';
@@ -55,7 +56,7 @@ function getPrimaryAttachment(message) {
     return null;
 }
 function renderInboundContent(message, materialized) {
-    return renderCanonHostInboundContent(message, materialized);
+    return renderClaudeInboundContent(message, materialized);
 }
 function toolArgumentError(error) {
     return {

package/dist/session-state.d.ts

@@ -356,6 +356,10 @@ export interface ClaudeTurnActivityState {
     blockIdByToolUseId: Map<string, string>;
     /** This turn's plan block, once TodoWrite has produced one. */
     planBlockId: string | null;
+    /** Monotonic identity for assistant responses inside this turn. */
+    assistantResponseCount: number;
+    /** The response whose text deltas are currently being streamed. */
+    activeAssistantResponseKey: string | null;
 }
 /**
  * Whether an SDK message describes the agent's OWN work rather than a
@@ -367,6 +371,22 @@ export interface ClaudeTurnActivityState {
 export declare function isClaudeMainTurnMessage(parentToolUseId: unknown): boolean;
 export declare function createClaudeTurnActivityState(): ClaudeTurnActivityState;
 export declare function resetClaudeTurnActivityState(state: ClaudeTurnActivityState): void;
+/** Open a fresh assistant response, whose content-block indexes start at zero. */
+export declare function beginClaudeAssistantResponse(state: ClaudeTurnActivityState): string;
+/** Close the response so a later text delta cannot reuse its block identity. */
+export declare function endClaudeAssistantResponse(state: ClaudeTurnActivityState): void;
+/**
+ * Stable id for one text block inside one assistant response.
+ *
+ * Anthropic restarts `content_block.index` for every assistant response. The
+ * response key is therefore required to distinguish text before a tool from
+ * text emitted after its result. Lazily opening a response keeps older SDK
+ * streams that omit `message_start` safe as well.
+ */
+export declare function claimClaudeTextSegmentId(state: ClaudeTurnActivityState, input: {
+    turnId?: string | null;
+    index?: unknown;
+}): string;
 export declare function claudeToolBlockId(toolUseId: string): string;
 export declare function claudePlanBlockId(turnId: string | null | undefined): string;
 /**

package/dist/session-state.js

@@ -376,12 +376,42 @@ export function createClaudeTurnActivityState() {
         blockIdByIndex: new Map(),
         blockIdByToolUseId: new Map(),
         planBlockId: null,
+        assistantResponseCount: 0,
+        activeAssistantResponseKey: null,
     };
 }
 export function resetClaudeTurnActivityState(state) {
     state.blockIdByIndex.clear();
     state.blockIdByToolUseId.clear();
     state.planBlockId = null;
+    state.assistantResponseCount = 0;
+    state.activeAssistantResponseKey = null;
+}
+/** Open a fresh assistant response, whose content-block indexes start at zero. */
+export function beginClaudeAssistantResponse(state) {
+    state.assistantResponseCount += 1;
+    state.activeAssistantResponseKey = `response-${state.assistantResponseCount}`;
+    return state.activeAssistantResponseKey;
+}
+/** Close the response so a later text delta cannot reuse its block identity. */
+export function endClaudeAssistantResponse(state) {
+    state.activeAssistantResponseKey = null;
+}
+/**
+ * Stable id for one text block inside one assistant response.
+ *
+ * Anthropic restarts `content_block.index` for every assistant response. The
+ * response key is therefore required to distinguish text before a tool from
+ * text emitted after its result. Lazily opening a response keeps older SDK
+ * streams that omit `message_start` safe as well.
+ */
+export function claimClaudeTextSegmentId(state, input) {
+    const responseKey = state.activeAssistantResponseKey
+        ?? beginClaudeAssistantResponse(state);
+    const index = typeof input.index === 'number' && Number.isInteger(input.index)
+        ? input.index
+        : 'latest';
+    return buildTrailBlockId('text', input.turnId ?? 'turn', responseKey, index);
 }
 export function claudeToolBlockId(toolUseId) {
     return buildTrailBlockId('tool', toolUseId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.31.2",
+  "version": "0.31.4",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -30,13 +30,13 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.220",
-    "@canonmsg/agent-sdk": "^8.3.0",
-    "@canonmsg/agent-tools": "^0.5.2",
+    "@anthropic-ai/claude-agent-sdk": "0.3.228",
+    "@canonmsg/agent-sdk": "^8.6.0",
+    "@canonmsg/agent-tools": "^0.5.3",
     "@canonmsg/coding-agent-host": "^0.5.0",
-    "@canonmsg/core": "^10.3.1",
-    "@canonmsg/rich-cards": "^0.10.0",
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@canonmsg/core": "^10.4.0",
+    "@canonmsg/rich-cards": "^0.10.2",
+    "@modelcontextprotocol/sdk": "^1.30.0"
   },
   "engines": {
     "node": ">=18.0.0"