@canonmsg/claude-code-plugin 0.25.2 → 0.25.3

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

package/dist/host.js

@@ -33,8 +33,8 @@ import { decideAutoReply, } from './inbound-policy.js';
 import { runCli } from './cli-entry.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { applyClaudeSessionControl, buildClaudeFinalMessageId, claudeModelInfoToOption, confirmClaudeInterrupt, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, mergeClaudeDiscoveredModelOptions, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
-import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, } from './user-dialog.js';
+import { applyClaudeSessionControl, buildClaudeFinalMessageId, claudeModelInfoToOption, confirmClaudeInterrupt, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, mergeClaudeDiscoveredModelOptions, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
 import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
@@ -738,7 +738,6 @@ async function buildCanonUserContent(input) {
 // ── Session factory ─────────────────────────────────────────────────
 function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
-    const cardResponseUserId = config.ownerId ?? undefined;
     // Per-session input stream with message queue
     let resolveInput = null;
     let inputDone = false;
@@ -796,23 +795,17 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     // eslint-disable-next-line prefer-const -- session must be declared before queryOptions but assigned after query()
     let session;
     const REPLY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-    const activeUserDialogs = new Map();
-    const completedUserDialogs = new Map();
+    const coordinateUserDialog = createClaudeUserDialogCoordinator();
     async function requestClaudeUserDialog(dialog, nativeRequestId, signal) {
         const questionId = /^[A-Za-z0-9_.:-]{1,160}$/.test(nativeRequestId)
             ? nativeRequestId
             : randomUUID();
-        const completed = completedUserDialogs.get(questionId);
-        if (completed)
-            return completed;
-        const existing = activeUserDialogs.get(questionId);
-        if (existing)
-            return existing;
-        const responseUserId = session.activeInput?.requestingUserId ?? undefined;
+        const responseRouting = resolveClaudeTurnResponseRouting(session.activeInput, config.ownerId, dialog.questions.some((question) => question.isSecret));
+        const responseUserId = responseRouting.responseUserId;
         if (!responseUserId) {
             return buildClaudeAskUserPermissionDenied('No eligible human participant can answer this question.');
         }
-        const run = (async () => {
+        return coordinateUserDialog(questionId, async () => {
             try {
                 const reply = await config.runtimeInputManager.request('input', conversationId, {
                     kind: 'clarify',
@@ -846,24 +839,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             catch {
                 return buildClaudeAskUserPermissionDenied(signal.aborted ? 'The question was interrupted.' : 'No reply received (timed out)');
             }
-        })();
-        activeUserDialogs.set(questionId, run);
-        try {
-            const result = await run;
-            completedUserDialogs.set(questionId, result);
-            while (completedUserDialogs.size > 64) {
-                const oldest = completedUserDialogs.keys().next().value;
-                if (oldest === undefined)
-                    break;
-                completedUserDialogs.delete(oldest);
-            }
-            return result;
-        }
-        finally {
-            activeUserDialogs.delete(questionId);
-        }
+        });
     }
-    function waitForReply(type, requestId) {
+    function waitForReply(type, requestId, responseUserId) {
         // Keep session alive while waiting for user input
         session.lastActivity = Date.now();
         return new Promise((resolve, reject) => {
@@ -874,6 +852,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             session.pendingReply = {
                 type,
                 requestId,
+                responseUserId,
                 resolve: (metadata) => {
                     clearTimeout(timer);
                     resolve(metadata);
@@ -916,7 +895,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             const dialog = parseClaudeAskUserDialog(request);
             if (!dialog)
                 return { behavior: 'cancelled' };
-            const nativeRequestId = dialog.requestId ?? request.toolUseID ?? randomUUID();
+            const nativeRequestId = resolveClaudeUserDialogRequestId(request, dialog) ?? randomUUID();
             const result = await requestClaudeUserDialog(dialog, nativeRequestId, signal);
             return signal.aborted ? { behavior: 'cancelled' } : { behavior: 'completed', result };
         },
@@ -927,7 +906,14 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     return buildClaudeAskUserPermissionDenied('Claude did not provide a valid question.');
                 return requestClaudeUserDialog(dialog, options.toolUseID, options.signal);
             }
+            const turnResponseRouting = resolveClaudeTurnResponseRouting(session.activeInput, config.ownerId);
             if (toolName === 'ExitPlanMode') {
+                if (!turnResponseRouting.responseUserId) {
+                    return {
+                        behavior: 'deny',
+                        message: 'No eligible human participant can review this plan.',
+                    };
+                }
                 try {
                     const planId = randomUUID();
                     const allowedPrompts = Array.isArray(input.allowedPrompts)
@@ -963,22 +949,21 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         title: 'Plan ready for review.',
                         summary: 'Claude has prepared a plan and is asking permission to continue.',
                         ...(planBody ? { body: planBody } : {}),
-                        ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
+                        responseUserId: turnResponseRouting.responseUserId,
                         ...(allowedPrompts.length > 0 ? { allowedPrompts } : {}),
                         ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                         expiresAt: Date.now() + REPLY_TIMEOUT_MS,
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
-                    const reply = await waitForReply('plan_approval_reply', planId);
+                    const reply = await waitForReply('plan_approval_reply', planId, turnResponseRouting.responseUserId);
                     if (reply.decision === 'approve') {
                         // Honor opt-in selective grants: when the card sent an explicit
                         // granted subset, pre-approve those tools as session rules so they
                         // do not re-prompt. Owner-turn only; absent grants preserve the
                         // legacy behavior (each tool still prompts individually).
-                        const isOwnerTurn = session.activeInput?.kind === 'canon'
-                            ? session.activeInput.isOwnerTurn === true
-                            : true;
-                        if (isOwnerTurn && config.approvalManager && Array.isArray(reply.grantedPrompts)) {
+                        if (turnResponseRouting.allowSessionRule
+                            && config.approvalManager
+                            && Array.isArray(reply.grantedPrompts)) {
                             // Only pre-approve tools the plan actually offered, and bound the
                             // count/length to match parseSessionRule's caps — grantedPrompts
                             // is untrusted wire metadata, not the validated approval path.
@@ -1038,9 +1023,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 conversationId,
                 runtimeId: config.runtimeId,
                 turnId: session.currentTurnId,
-                isOwnerTurn: session.activeInput?.kind === 'canon'
-                    ? session.activeInput.isOwnerTurn === true
-                    : true,
+                isOwnerTurn: turnResponseRouting.isOwnerTurn,
+                responseUserId: turnResponseRouting.responseUserId,
+                allowSessionRule: turnResponseRouting.allowSessionRule,
                 approvalManager: config.approvalManager,
                 canRequestApproval: config.canRequestApproval,
                 allowedNonOwnerTools: allowedNonOwnerClaudeTools,
@@ -2578,14 +2563,13 @@ export async function main() {
             return false;
         const existingSession = sessions.get(conversationId);
         const pendingReply = existingSession?.pendingReply;
-        const isOwnerReply = message.isOwner ?? (ownerId != null && message.senderId === ownerId);
         const replyRequestId = message.metadata.planId;
         if (!pendingReply) {
             console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring stale ${message.metadata.type} with no pending request`);
             return true;
         }
-        if (!isOwnerReply) {
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring ${message.metadata.type} from non-owner ${message.senderId}`);
+        if (message.senderId !== pendingReply.responseUserId) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring ${message.metadata.type} from unexpected responder ${message.senderId}`);
             return true;
         }
         if (pendingReply.type !== message.metadata.type || pendingReply.requestId !== replyRequestId) {

package/dist/session-state.d.ts

@@ -51,6 +51,11 @@ export declare function createClaudeInputEnvelope(input: {
     isOwnerTurn?: boolean;
     requestingUserId?: string | null;
 }): ClaudeInputEnvelope;
+export declare function resolveClaudeTurnResponseRouting(turn: Pick<ClaudeInputEnvelope, 'kind' | 'isOwnerTurn' | 'requestingUserId'> | null | undefined, ownerId: string | null | undefined, ownerOnly?: boolean): {
+    isOwnerTurn: boolean;
+    responseUserId?: string;
+    allowSessionRule: boolean;
+};
 export declare function buildClaudeFinalMessageId(input: {
     agentId: string;
     conversationId: string;

package/dist/session-state.js

@@ -21,6 +21,17 @@ export function createClaudeInputEnvelope(input) {
             : `${input.kind}:${fallbackId}`,
     };
 }
+export function resolveClaudeTurnResponseRouting(turn, ownerId, ownerOnly = false) {
+    const isOwnerTurn = turn?.kind === 'canon' ? turn.isOwnerTurn : true;
+    const responseUserId = ownerOnly
+        ? ownerId || undefined
+        : (turn?.requestingUserId ?? ownerId) || undefined;
+    return {
+        isOwnerTurn,
+        ...(responseUserId ? { responseUserId } : {}),
+        allowSessionRule: Boolean(responseUserId && ownerId && responseUserId === ownerId),
+    };
+}
 export function buildClaudeFinalMessageId(input) {
     const digest = createHash('sha256')
         .update(`${input.agentId}\n${input.conversationId}\n${input.turnKey}`)

package/dist/startup-recovery.js

@@ -50,7 +50,10 @@ export async function collectMissedInboundMessages(input) {
     const resolvedCursor = cursorSearchComplete()
         ? findNewestCursor(collected)
         : null;
-    const ascending = [...collected].sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')));
+    // Preserve the API's deterministic newest-first order. Timestamps are
+    // display data and may be equal or absent, so reversing wire order is the
+    // only lossless oldest-first replay sequence.
+    const ascending = [...collected].reverse();
     const completedSourceMessageIds = new Set(collected.flatMap((message) => {
         if (message.senderId !== input.agentId)
             return [];

package/dist/tool-policy.d.ts

@@ -24,12 +24,14 @@ export declare function decideClaudeToolPermissionForMode(input: {
     runtimeId?: string;
     turnId?: string | null;
     isOwnerTurn: boolean;
+    responseUserId?: string | null;
+    allowSessionRule?: boolean;
     approvalManager?: ApprovalManager | null;
     canRequestApproval?: () => Promise<boolean>;
     allowedNonOwnerTools?: Iterable<string>;
     /**
      * Lazy file-change preview for the approval card (Edit/Write-class tools).
-     * Invoked only once the call is headed for an owner approval; best-effort —
+     * Invoked only once the call is headed for a responder approval; best-effort —
      * a throw or undefined simply omits the diff, never blocks the approval.
      */
     buildApprovalDiff?: () => Promise<CanonUnifiedDiff | undefined>;

package/dist/tool-policy.js

@@ -1,6 +1,6 @@
 const NON_OWNER_DENY_MESSAGE = 'Only the agent owner can authorize runtime tool use in this chat.';
 const NATIVE_APPROVAL_UNAVAILABLE_MESSAGE = 'Runtime action approval is not available for this conversation.';
-const NATIVE_APPROVAL_DENIED_MESSAGE = 'The agent owner denied this action.';
+const NATIVE_APPROVAL_DENIED_MESSAGE = 'The user denied this action.';
 export const CLAUDE_NATIVE_APPROVAL_PERMISSION_MODE = 'default';
 const SENSITIVE_CLAUDE_TOOLS = new Set([
     'agent',
@@ -174,6 +174,12 @@ export async function decideClaudeToolPermissionForMode(input) {
             message: NATIVE_APPROVAL_UNAVAILABLE_MESSAGE,
         };
     }
+    if (!input.isOwnerTurn && !input.responseUserId) {
+        return {
+            behavior: 'deny',
+            message: NATIVE_APPROVAL_UNAVAILABLE_MESSAGE,
+        };
+    }
     let diff;
     if (input.buildApprovalDiff) {
         try {
@@ -186,6 +192,7 @@ export async function decideClaudeToolPermissionForMode(input) {
     let result;
     try {
         const risk = classifyClaudeApprovalRisk(input.toolName, input.toolInput);
+        const allowSessionRule = input.allowSessionRule ?? input.isOwnerTurn;
         result = await input.approvalManager.requestApproval(input.conversationId, input.toolName, input.toolInput, {
             category: classifyClaudeApprovalCategory(input.toolName),
             risk,
@@ -198,8 +205,9 @@ export async function decideClaudeToolPermissionForMode(input) {
             },
             details: buildClaudeApprovalDetails(input.toolName, input.toolInput),
             ...(diff ? { diff } : {}),
-            ignoreSessionRules: !input.isOwnerTurn,
-            allowSessionRule: input.isOwnerTurn,
+            ...(input.responseUserId ? { responseUserId: input.responseUserId } : {}),
+            ignoreSessionRules: !allowSessionRule,
+            allowSessionRule,
         });
     }
     catch {

package/dist/user-dialog.d.ts

@@ -8,6 +8,8 @@ export interface ClaudeAskUserDialog {
     updatedInput: Record<string, unknown>;
     requestId?: string;
 }
+export declare function resolveClaudeUserDialogRequestId(request: Pick<UserDialogRequest, 'toolUseID'>, dialog: Pick<ClaudeAskUserDialog, 'requestId'>): string | undefined;
+export declare function createClaudeUserDialogCoordinator<T>(maxCompleted?: number): (requestId: string, run: () => Promise<T>) => Promise<T>;
 export declare function parseClaudeAskUserDialog(request: UserDialogRequest): ClaudeAskUserDialog | null;
 export declare function parseClaudeAskUserToolInput(input: Record<string, unknown>, requestId: string): ClaudeAskUserDialog | null;
 export declare function buildClaudeAskUserPermissionResult(dialog: ClaudeAskUserDialog, response: {

package/dist/user-dialog.js

@@ -1,6 +1,40 @@
 import { resolveQuestionAllowOther, } from '@canonmsg/core';
 export const CLAUDE_ASK_USER_DIALOG_KIND = 'permission_ask_user_question';
 export const CLAUDE_SUPPORTED_DIALOG_KINDS = [CLAUDE_ASK_USER_DIALOG_KIND];
+export function resolveClaudeUserDialogRequestId(request, dialog) {
+    const toolUseId = typeof request.toolUseID === 'string' ? request.toolUseID.trim() : '';
+    if (toolUseId)
+        return toolUseId.slice(0, 160);
+    const payloadRequestId = dialog.requestId?.trim();
+    return payloadRequestId ? payloadRequestId.slice(0, 160) : undefined;
+}
+export function createClaudeUserDialogCoordinator(maxCompleted = 64) {
+    const active = new Map();
+    const completed = new Map();
+    return async (requestId, run) => {
+        if (completed.has(requestId))
+            return completed.get(requestId);
+        const activeResult = active.get(requestId);
+        if (activeResult)
+            return activeResult;
+        const pending = Promise.resolve().then(run);
+        active.set(requestId, pending);
+        try {
+            const result = await pending;
+            completed.set(requestId, result);
+            while (completed.size > maxCompleted) {
+                const oldest = completed.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                completed.delete(oldest);
+            }
+            return result;
+        }
+        finally {
+            active.delete(requestId);
+        }
+    };
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,9 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.204",
-    "@canonmsg/agent-sdk": "^5.1.0",
+    "@canonmsg/agent-sdk": "^5.1.1",
     "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^4.2.1",
+    "@canonmsg/core": "^4.2.2",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {