@canonmsg/claude-code-plugin 0.36.1 → 0.36.2

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

package/README.md

@@ -4,7 +4,7 @@ Connect Claude Code to [Canon](https://canonmail.com/agents) — a messaging app
 
 ## Quick start
 
-The package includes a compatible Claude Code runtime. If `claude` is installed on `PATH`, or selected with `CANON_CLAUDE_CLI_PATH`, use Claude Code 2.1.220 or newer — the model picker lists whatever the CLI reports, so an older binary hides newer model families. Either source below that minimum is logged and skipped in favour of the bundled runtime, so a stale install costs model options rather than taking the host down.
+The package includes a compatible Claude Code runtime. If `claude` is installed on `PATH`, or selected with `CANON_CLAUDE_CLI_PATH`, use Claude Code 2.1.278 or newer. The bundled Claude Agent SDK is pinned to 0.3.278; Canon relies on its explicit input/result attribution for merged messages and native errors. An external binary below that minimum is logged and skipped in favour of the bundled runtime.
 
 ```bash
 # Install

package/dist/host.js

@@ -35,7 +35,7 @@ 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 { 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 { 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, claudeCompletedSourceMessageIds, shouldFailClaudeSessionForUnattributedResult, 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';
 import { isProactiveCommunicationEnabled } from './communication-policy.js';
 function parseRuntimeVisibilityPreset(value) {
@@ -1059,9 +1059,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         return streamingOutput.clear().catch(() => { });
     }
     function markInputCompleted(input) {
-        if (input?.kind !== 'canon' || !input.sourceMessageId)
-            return;
-        config.onInputCompleted?.(input.sourceMessageId);
+        for (const sourceMessageId of claudeCompletedSourceMessageIds(input)) {
+            config.onInputCompleted?.(sourceMessageId);
+        }
     }
     /**
      * The turn trail to attach to the final send. Empty on a quiet turn — see
@@ -1120,6 +1120,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         drainPendingInput();
     }
     function scheduleFinalHandoffReset() {
+        if (session.closed)
+            return;
         clearIdleResetTimer();
         session.idleResetTimer = setTimeout(() => {
             session.idleResetTimer = null;
@@ -1177,8 +1179,10 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         session.finalizedTurnKeys.add(turn.turnKey);
         markInputCompleted(turn);
         releaseTurnSlotFor(turn);
-        session.pendingFinalDelivery = null;
-        clearFinalDeliveryTimer();
+        if (session.pendingFinalDelivery?.turnKey === turn.turnKey) {
+            session.pendingFinalDelivery = null;
+            clearFinalDeliveryTimer();
+        }
         writeState();
     }
     /**
@@ -1461,6 +1465,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         }, FINAL_DELIVERY_RETRY_MS);
     }
     function writeState() {
+        if (session.closed)
+            return;
         runtimeState.writeSessionState(conversationId, {
             contextUsage: session.state.contextUsage,
             hostMode: true,
@@ -1487,6 +1493,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         writeState();
     }
     function writeTurn() {
+        if (session.closed)
+            return;
         const isOpenTurn = isOpenClaudeTurnState(session.turnState);
         if (isOpenTurn) {
             session.currentTurnUpdatedAt = Date.now();
@@ -1780,6 +1788,29 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         applyTrailCommands(planClaudeToolResults(session.turnActivity, content));
     }
     // ── Process SDK output messages ──
+    function finishSession() {
+        if (session.closed)
+            return;
+        session.closed = true;
+        inputDone = true;
+        clearIdleResetTimer();
+        clearFinalDeliveryTimer();
+        stopVisibleWorkSignal();
+        try {
+            q.close();
+        }
+        catch { }
+        // A native failure cannot prove whether dispatched work ran. Release local
+        // in-flight claims without completing endpoint receipts or replaying work.
+        const unfinishedIds = new Set([
+            session.activeInput, session.dispatchingInput,
+            ...session.pendingInputs, ...dispatchedInputs.values(),
+        ].flatMap(claudeCompletedSourceMessageIds));
+        for (const sourceMessageId of unfinishedIds)
+            config.onInputDeferred?.(sourceMessageId);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ended`);
+        onSessionEnd(conversationId, session.sdkSessionId);
+    }
     const processMessages = async () => {
         try {
             for await (const msg of q) {
@@ -1988,10 +2019,17 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         const resultSessionId = msg.session_id;
                         if (resultSessionId)
                             session.sdkSessionId = resultSessionId;
-                        // Match the result to the envelope that produced it. Falling back to
-                        // the slot only when the SDK reports no uuid keeps older runtimes
-                        // working, at their existing accuracy.
-                        const completedInput = takeClaudeResultOwner(dispatchedInputs, msg.user_message_uuid) ?? session.activeInput;
+                        // A result may acknowledge several coalesced inputs, but never a
+                        // queued input absent from its UUID list. Native background/resume
+                        // results with no known UUID do not belong to the active Canon turn.
+                        const completedInput = takeClaudeResultOwner(dispatchedInputs, msg.user_message_uuid, msg.user_message_uuids);
+                        if (!completedInput) {
+                            if (shouldFailClaudeSessionForUnattributedResult(msg, Boolean(session.activeInput || session.dispatchingInput || session.pendingInputs.length))) {
+                                throw new Error('Claude returned an unattributed result; native session closed with unfinished inputs preserved.');
+                            }
+                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring result without a known input UUID`);
+                            break;
+                        }
                         console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn complete (${msg.subtype})`);
                         const resultText = typeof msg.result === 'string'
                             ? msg.result.trim()
@@ -2014,7 +2052,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         // the artifacts still POST first, ahead of the reply they belong to.
                         const turnFinal = composeClaudeTurnFinal({
                             resultText,
-                            streamedText: session.pendingFinalText,
+                            streamedText: completedInput.turnKey === session.activeInput?.turnKey
+                                ? session.pendingFinalText : null,
                             failureNotice,
                             silenced,
                         });
@@ -2077,6 +2116,14 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             if (!finalText || !shouldDeliverFinal) {
                                 markInputCompleted(completedInput);
                             }
+                            // Sending the final and fetching usage both await. A newer turn
+                            // may now own the live text, pending delivery and handoff timer.
+                            if (!shouldReleaseClaudeTurnSlot({
+                                dispatching: session.dispatchingInput !== null,
+                                activeTurnKey: session.activeInput?.turnKey ?? null,
+                                completedTurnKey: completedInput.turnKey,
+                            }))
+                                break;
                             if (completedInput?.turnKey === session.activeInput?.turnKey) {
                                 session.activeInput = null;
                             }
@@ -2118,16 +2165,14 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         catch (err) {
             console.error(`[canon-host] [${conversationId.slice(0, 8)}] Query stream error:`, err);
         }
-        // Only call onSessionEnd if not already closed (avoids double cleanup from closeSession)
-        if (!session.closed) {
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ended`);
-            onSessionEnd(conversationId, session.sdkSessionId);
-        }
+        finishSession();
     };
     // Start processing loop and initialize session
     const init = async () => {
         processMessages().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] processMessages crashed:`, err));
         await q.initializationResult();
+        if (session.closed)
+            return;
         if (config.model) {
             try {
                 await q.setModel(config.model);
@@ -2160,6 +2205,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             const models = await q.supportedModels();
             const discoveredOptions = toModelOptions(models);
             const supplemental = await detectSupplementalRuntimeModels(cwd, deriveClaudeSupplementalModelProbes(discoveredOptions));
+            if (session.closed)
+                return;
             const modelList = resolveClaudeModelOptions({
                 discovered: mergeClaudeDiscoveredModelOptions(discoveredOptions, ...supplemental),
                 selectedModel: session.state.model,
@@ -2194,10 +2241,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     };
     init().catch((err) => {
         console.error(`[canon-host] [${conversationId.slice(0, 8)}] Init failed:`, err);
-        if (resumeSessionId) {
+        if (resumeSessionId)
             session.sdkSessionId = null;
-            onSessionEnd(conversationId, null);
-        }
+        finishSession();
     });
     return session;
 }

package/dist/session-state.d.ts

@@ -1,4 +1,4 @@
-import type { SDKMessageOrigin, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { SDKMessageOrigin, SDKResultMessage, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { DeliveryIntent, ModelOption, RuntimeStreamingPayload, TurnLifecycleState, TurnOutputBlock, TurnOutputSnapshot, TurnVerbosity } from '@canonmsg/core';
 import type { AgentReplyAuthorityV1 } from '@canonmsg/backend-contracts';
 import type { TurnArtifactRoutingDecision, TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
@@ -7,8 +7,10 @@ export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
     commandContext?: string;
     kind: ClaudeInputKind;
-    /** Correlates this envelope with its turn result's `user_message_uuid`. */
+    /** Correlates this envelope with its turn result's user-message UUIDs. */
     messageUuid: string;
+    /** Other Canon inputs acknowledged by the same result; settle with its final. */
+    resultSourceMessageIds?: string[];
     msg: SDKUserMessage;
     intent: DeliveryIntent;
     sourceMessageId: string | null;
@@ -150,15 +152,24 @@ export declare function shouldRouteClaudeTurnArtifacts(input: {
 }): TurnArtifactRoutingDecision;
 export declare function rememberDispatchedClaudeInput(dispatched: Map<string, ClaudeInputEnvelope>, input: ClaudeInputEnvelope): void;
 /**
- * The envelope a turn result belongs to, matched by `user_message_uuid`.
- *
- * The SDK coalesces queued inputs — three rapid messages can produce two turns —
- * and reports the LAST message of a coalesced batch, which is the correct owner
- * of the reply. Entries up to and including the match are consumed, so messages
- * folded into that batch do not linger. Returns null when the result carries no
- * usable uuid, leaving the caller to fall back.
+ * Match only the inputs the SDK explicitly acknowledges. Its plural list is in
+ * consumption order and can include messages folded in after the first reply.
+ * The last known Canon input owns the final; internal seeds cannot displace it.
+ * A singular UUID acknowledges only itself, never everything earlier in our map.
+ * Missing/unknown attribution must not fall back to an unrelated active turn.
+ */
+export declare function takeClaudeResultOwner(dispatched: Map<string, ClaudeInputEnvelope>, userMessageUuid: unknown, userMessageUuids?: unknown): ClaudeInputEnvelope | null;
+/** Keep coalesced inputs pending until their shared final is delivered or retired. */
+export declare function claudeCompletedSourceMessageIds(input: ClaudeInputEnvelope | null | undefined): string[];
+/**
+ * A zeroed/session error may have no input UUID. Treat it as a session failure,
+ * never as successful completion of whichever Canon input happens to be active.
+ * An unattributed success while foreground work is outstanding is ambiguous too:
+ * waiting for an idle echo would wedge that input, because its slot rejects idle
+ * until completion. Close the native session and preserve the unsettled input.
+ * Explicit foreign/replayed UUIDs remain unrelated results and are ignored.
  */
-export declare function takeClaudeResultOwner(dispatched: Map<string, ClaudeInputEnvelope>, userMessageUuid: unknown): ClaudeInputEnvelope | null;
+export declare function shouldFailClaudeSessionForUnattributedResult(result: Pick<SDKResultMessage, 'subtype' | 'is_error' | 'user_message_uuid' | 'user_message_uuids'>, hasForegroundWork: boolean): boolean;
 /**
  * Whether an envelope owns the session's active-turn slot. Only Canon turns do;
  * any future internal envelope must remain invisible to user-facing turn state.

package/dist/session-state.js

@@ -99,28 +99,54 @@ export function rememberDispatchedClaudeInput(dispatched, input) {
     }
 }
 /**
- * The envelope a turn result belongs to, matched by `user_message_uuid`.
- *
- * The SDK coalesces queued inputs — three rapid messages can produce two turns —
- * and reports the LAST message of a coalesced batch, which is the correct owner
- * of the reply. Entries up to and including the match are consumed, so messages
- * folded into that batch do not linger. Returns null when the result carries no
- * usable uuid, leaving the caller to fall back.
+ * Match only the inputs the SDK explicitly acknowledges. Its plural list is in
+ * consumption order and can include messages folded in after the first reply.
+ * The last known Canon input owns the final; internal seeds cannot displace it.
+ * A singular UUID acknowledges only itself, never everything earlier in our map.
+ * Missing/unknown attribution must not fall back to an unrelated active turn.
  */
-export function takeClaudeResultOwner(dispatched, userMessageUuid) {
-    if (typeof userMessageUuid !== 'string' || !dispatched.has(userMessageUuid)) {
-        return null;
-    }
-    let owner = null;
-    for (const [key, envelope] of dispatched) {
-        dispatched.delete(key);
-        if (key === userMessageUuid) {
-            owner = envelope;
-            break;
-        }
+export function takeClaudeResultOwner(dispatched, userMessageUuid, userMessageUuids) {
+    const uuids = Array.isArray(userMessageUuids)
+        ? userMessageUuids.filter((uuid) => typeof uuid === 'string' && uuid.length > 0)
+        : [];
+    if (typeof userMessageUuid === 'string' && !uuids.includes(userMessageUuid)) {
+        uuids.push(userMessageUuid);
     }
+    const inputs = [...new Set(uuids)].flatMap((uuid) => {
+        const input = dispatched.get(uuid);
+        return input ? [input] : [];
+    });
+    const owner = [...inputs].reverse().find((input) => input.kind === 'canon') ?? inputs.at(-1) ?? null;
+    if (!owner)
+        return null;
+    owner.resultSourceMessageIds = [...new Set(inputs.flatMap(claudeCompletedSourceMessageIds))];
+    for (const input of inputs)
+        dispatched.delete(input.messageUuid);
     return owner;
 }
+/** Keep coalesced inputs pending until their shared final is delivered or retired. */
+export function claudeCompletedSourceMessageIds(input) {
+    if (input?.kind !== 'canon')
+        return [];
+    return [...new Set([
+            ...(input.sourceMessageId ? [input.sourceMessageId] : []),
+            ...(input.resultSourceMessageIds ?? []),
+        ])];
+}
+/**
+ * A zeroed/session error may have no input UUID. Treat it as a session failure,
+ * never as successful completion of whichever Canon input happens to be active.
+ * An unattributed success while foreground work is outstanding is ambiguous too:
+ * waiting for an idle echo would wedge that input, because its slot rejects idle
+ * until completion. Close the native session and preserve the unsettled input.
+ * Explicit foreign/replayed UUIDs remain unrelated results and are ignored.
+ */
+export function shouldFailClaudeSessionForUnattributedResult(result, hasForegroundWork) {
+    const hasUuid = (typeof result.user_message_uuid === 'string' && result.user_message_uuid.length > 0)
+        || (Array.isArray(result.user_message_uuids)
+            && result.user_message_uuids.some((uuid) => typeof uuid === 'string' && uuid.length > 0));
+    return !hasUuid && (hasForegroundWork || result.is_error || result.subtype !== 'success');
+}
 /**
  * Whether an envelope owns the session's active-turn slot. Only Canon turns do;
  * any future internal envelope must remain invisible to user-facing turn state.
@@ -1188,12 +1214,9 @@ export async function runClaudeExhaustedFinalDelivery(session, pending, deps) {
     }
     deps.retireTurn();
 }
-// Model options are discovery-driven: the host publishes whatever the Claude
-// Code CLI it spawns reports. A CLI older than this predates whole model
-// families (2.1.220 is the first to know Opus 5), so an old binary silently
-// shortens the picker instead of failing. Keep this at or above the CLI the
-// pinned SDK bundles, so the bundled fallback always satisfies it.
-export const MINIMUM_CLAUDE_CLI_VERSION = [2, 1, 220];
+// External CLIs must support the same input/result attribution contract as the
+// pinned SDK. Older binaries fall back to the bundled, audited runtime.
+export const MINIMUM_CLAUDE_CLI_VERSION = [2, 1, 278];
 export function parseClaudeCliVersion(output) {
     const match = output.trim().match(/^(\d+)\.(\d+)\.(\d+)/);
     return match ? match.slice(1, 4).map(Number) : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.228",
+    "@anthropic-ai/claude-agent-sdk": "0.3.278",
     "@canonmsg/agent-sdk": "^11.0.1",
     "@canonmsg/agent-tools": "^0.11.0",
     "@canonmsg/coding-agent-host": "^0.9.0",