@canonmsg/claude-code-plugin 0.25.0 → 0.25.3

package/dist/session-state.d.ts

@@ -13,6 +13,7 @@ export interface ClaudeInputEnvelope {
     artifactBaseline: TurnArtifactSnapshot | null;
     turnKey: string;
     isOwnerTurn: boolean;
+    requestingUserId: string | null;
 }
 export interface ClaudeRuntimeControlError {
     value: string;
@@ -48,7 +49,13 @@ export declare function createClaudeInputEnvelope(input: {
     artifactRoutingMode?: ClaudeArtifactRoutingMode;
     artifactBaseline?: TurnArtifactSnapshot | null;
     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;
@@ -60,12 +67,23 @@ export declare function shouldDeliverClaudeFinal(input: {
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
-export declare function mergeClaudeModelOptions(input: {
-    previous: ReadonlyArray<ModelOption>;
-    next: ReadonlyArray<ModelOption>;
+export interface ClaudeModelInfoLike {
+    value: string;
+    displayName: string;
+    description?: string;
+}
+export declare function claudeModelInfoToOption(model: ClaudeModelInfoLike): ModelOption;
+export declare function isClaudeCustomModelOption(option: ModelOption | null | undefined): boolean;
+export declare function mergeClaudeDiscoveredModelOptions(...groups: ReadonlyArray<ReadonlyArray<ModelOption>>): ModelOption[];
+export declare function resolveClaudeModelOptions(input: {
+    discovered: ReadonlyArray<ModelOption>;
     selectedModel?: string | null;
 }): ModelOption[];
 export declare function formatClaudeControlError(error: unknown): string;
+export declare function confirmClaudeInterrupt(input: {
+    active: boolean;
+    interrupt: () => Promise<void>;
+}): Promise<'confirmed' | 'defer'>;
 /** Requested session-control values from the control plane (raw, pre-validation). */
 export interface ClaudeSessionControlInput {
     model?: string;

package/dist/session-state.js

@@ -13,11 +13,25 @@ export function createClaudeInputEnvelope(input) {
         isOwnerTurn: input.kind === 'canon'
             ? input.isOwnerTurn === true
             : input.isOwnerTurn !== false,
+        requestingUserId: input.kind === 'canon' && input.requestingUserId
+            ? input.requestingUserId
+            : null,
         turnKey: input.kind === 'canon' && sourceMessageId
             ? `canon:${sourceMessageId}`
             : `${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}`)
@@ -46,32 +60,68 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
-export function mergeClaudeModelOptions(input) {
+function normalizeModelDescription(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function displayLabelWithClaudeVersion(input) {
+    const label = input.displayName.trim() || input.value;
+    const description = normalizeModelDescription(input.description);
+    if (!description || label.includes('(') || /\d/.test(label))
+        return label;
+    const [summary] = description.split('·');
+    const versionedLabel = summary?.trim();
+    return versionedLabel
+        && versionedLabel.toLowerCase().startsWith(label.toLowerCase())
+        && /\d/.test(versionedLabel)
+        ? versionedLabel
+        : label;
+}
+export function claudeModelInfoToOption(model) {
+    const description = normalizeModelDescription(model.description);
+    return {
+        value: model.value,
+        label: displayLabelWithClaudeVersion(model),
+        ...(description ? { description } : {}),
+    };
+}
+export function isClaudeCustomModelOption(option) {
+    return option?.description?.trim().toLowerCase() === 'custom model';
+}
+export function mergeClaudeDiscoveredModelOptions(...groups) {
     const byValue = new Map();
-    for (const option of input.previous) {
-        byValue.set(option.value, { ...option });
+    const valueByLabel = new Map();
+    const labelByValue = new Map();
+    for (const group of groups) {
+        for (const option of group) {
+            const previousLabel = labelByValue.get(option.value);
+            if (previousLabel && valueByLabel.get(previousLabel) === option.value) {
+                valueByLabel.delete(previousLabel);
+            }
+            const duplicateValue = valueByLabel.get(option.label);
+            if (duplicateValue && duplicateValue !== option.value && duplicateValue !== 'default') {
+                byValue.delete(duplicateValue);
+                labelByValue.delete(duplicateValue);
+            }
+            byValue.set(option.value, option);
+            valueByLabel.set(option.label, option.value);
+            labelByValue.set(option.value, option.label);
+        }
     }
-    for (const option of input.next) {
+    return [...byValue.values()];
+}
+export function resolveClaudeModelOptions(input) {
+    const byValue = new Map();
+    for (const option of input.discovered) {
         byValue.set(option.value, { ...option });
     }
     if (input.selectedModel && !byValue.has(input.selectedModel)) {
         byValue.set(input.selectedModel, {
             value: input.selectedModel,
             label: input.selectedModel,
-            description: 'Selected for this Canon session but not returned by the latest Claude model probe.',
+            description: 'Selected for this Canon session but not returned by Claude model discovery.',
         });
     }
-    const nextValues = new Set(input.next.map((option) => option.value));
-    return [...byValue.values()].map((option) => {
-        if (nextValues.has(option.value))
-            return option;
-        return {
-            ...option,
-            description: option.description
-                ? `${option.description} Previously advertised; not returned by the latest Claude model probe.`
-                : 'Previously advertised; not returned by the latest Claude model probe.',
-        };
-    });
+    return [...byValue.values()];
 }
 export function formatClaudeControlError(error) {
     if (error instanceof Error && error.message.trim()) {
@@ -82,6 +132,17 @@ export function formatClaudeControlError(error) {
     }
     return 'Claude Code did not apply that control.';
 }
+export async function confirmClaudeInterrupt(input) {
+    if (!input.active)
+        return 'confirmed';
+    try {
+        await input.interrupt();
+        return 'confirmed';
+    }
+    catch {
+        return 'defer';
+    }
+}
 /**
  * Apply a session-control request to the live Claude session. Mirrors the host's
  * control semantics (validation, only-if-different checks, error recording,

package/dist/startup-recovery.d.ts

@@ -6,9 +6,8 @@
  * its `before` message-id parameter) until the cursor is found or a hard
  * per-conversation bound is hit, then replay everything after the cursor.
  *
- * This module is intentionally identical in packages/claude-code-plugin and
- * packages/codex-plugin — keep both copies in sync (future consolidation
- * candidate).
+ * Claude also accepts legacy cursor candidates so it can migrate old
+ * execution-mode-scoped state into one conversation-level recovery cursor.
  */
 export declare const STARTUP_RECOVERY_PAGE_SIZE = 25;
 export declare const STARTUP_RECOVERY_MAX_MESSAGES = 500;
@@ -16,6 +15,7 @@ export interface StartupRecoveryMessage {
     id: string;
     senderId: string;
     createdAt?: string;
+    metadata?: Record<string, unknown>;
 }
 export interface StartupRecoveryPage {
     messages: StartupRecoveryMessage[];
@@ -33,6 +33,8 @@ export type StartupRecoveryMode =
  | 'latest-only';
 export interface StartupRecoveryResult<TPage extends StartupRecoveryPage> {
     mode: StartupRecoveryMode;
+    /** Cursor found in history and used for this recovery pass. */
+    cursor: string | null;
     /** Missed inbound messages (own messages excluded), oldest first. */
     messages: TPage['messages'];
     /** First page fetched — reusable as hydration context for recovered turns. */
@@ -41,6 +43,7 @@ export interface StartupRecoveryResult<TPage extends StartupRecoveryPage> {
 export declare function collectMissedInboundMessages<TPage extends StartupRecoveryPage>(input: {
     fetchPage: (before?: string) => Promise<TPage>;
     cursor: string | null | undefined;
+    cursorCandidates?: readonly string[];
     agentId: string;
     maxMessages?: number;
 }): Promise<StartupRecoveryResult<TPage>>;

package/dist/startup-recovery.js

@@ -6,9 +6,8 @@
  * its `before` message-id parameter) until the cursor is found or a hard
  * per-conversation bound is hit, then replay everything after the cursor.
  *
- * This module is intentionally identical in packages/claude-code-plugin and
- * packages/codex-plugin — keep both copies in sync (future consolidation
- * candidate).
+ * Claude also accepts legacy cursor candidates so it can migrate old
+ * execution-mode-scoped state into one conversation-level recovery cursor.
  */
 export const STARTUP_RECOVERY_PAGE_SIZE = 25;
 export const STARTUP_RECOVERY_MAX_MESSAGES = 500;
@@ -17,10 +16,21 @@ export async function collectMissedInboundMessages(input) {
     const newestPage = await input.fetchPage();
     const collected = [...newestPage.messages];
     const seenIds = new Set(collected.map((message) => message.id));
-    const hasCursor = (messages) => input.cursor != null && messages.some((message) => message.id === input.cursor);
-    let cursorFound = hasCursor(collected);
-    if (input.cursor != null) {
-        while (!cursorFound && collected.length < maxMessages) {
+    const candidateCursorIds = new Set(input.cursor
+        ? [input.cursor]
+        : (input.cursorCandidates ?? []).filter(Boolean));
+    const foundCursorIds = new Set();
+    const recordFoundCursors = (messages) => {
+        for (const message of messages) {
+            if (candidateCursorIds.has(message.id))
+                foundCursorIds.add(message.id);
+        }
+    };
+    const cursorSearchComplete = () => foundCursorIds.size > 0;
+    const findNewestCursor = (messages) => messages.find((message) => candidateCursorIds.has(message.id))?.id ?? null;
+    recordFoundCursors(collected);
+    if (candidateCursorIds.size > 0) {
+        while (!cursorSearchComplete() && collected.length < maxMessages) {
             // Pages are newest-first, so the last collected message is the oldest.
             const before = collected[collected.length - 1]?.id;
             if (!before)
@@ -34,19 +44,35 @@ export async function collectMissedInboundMessages(input) {
             for (const message of fresh)
                 seenIds.add(message.id);
             collected.push(...fresh);
-            cursorFound = hasCursor(fresh);
+            recordFoundCursors(fresh);
         }
     }
-    const ascending = [...collected].sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')));
-    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId);
+    const resolvedCursor = cursorSearchComplete()
+        ? findNewestCursor(collected)
+        : null;
+    // 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 [];
+        const metadata = message.metadata;
+        if (metadata?.turnSemantics !== 'turn_complete')
+            return [];
+        return typeof metadata.sourceMessageId === 'string'
+            ? [metadata.sourceMessageId]
+            : [];
+    }));
+    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId && !completedSourceMessageIds.has(message.id));
     let mode;
     let missed;
-    if (cursorFound) {
-        const cursorIndex = ascending.findIndex((message) => message.id === input.cursor);
+    if (resolvedCursor) {
+        const cursorIndex = ascending.findIndex((message) => message.id === resolvedCursor);
         mode = 'after-cursor';
         missed = inboundOnly(ascending.slice(cursorIndex + 1));
     }
-    else if (input.cursor != null && collected.length >= maxMessages) {
+    else if (candidateCursorIds.size > 0 && collected.length >= maxMessages) {
         mode = 'truncated-window';
         missed = inboundOnly(ascending.slice(-maxMessages));
     }
@@ -55,5 +81,10 @@ export async function collectMissedInboundMessages(input) {
         missed = inboundOnly(ascending).slice(-1);
     }
     // Safe: `missed` only holds elements of pages returned by `fetchPage`.
-    return { mode, messages: missed, newestPage };
+    return {
+        mode,
+        cursor: resolvedCursor,
+        messages: missed,
+        newestPage,
+    };
 }

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

@@ -0,0 +1,19 @@
+import type { PermissionResult, UserDialogRequest } from '@anthropic-ai/claude-agent-sdk';
+import { type RuntimeInputAnswers, type RuntimeInputQuestion } from '@canonmsg/core';
+export declare const CLAUDE_ASK_USER_DIALOG_KIND = "permission_ask_user_question";
+export declare const CLAUDE_SUPPORTED_DIALOG_KINDS: string[];
+export interface ClaudeAskUserDialog {
+    questions: RuntimeInputQuestion[];
+    rawQuestions: Array<Record<string, unknown>>;
+    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: {
+    value?: string;
+    answers?: RuntimeInputAnswers;
+}): PermissionResult;
+export declare function buildClaudeAskUserPermissionDenied(message: string): PermissionResult;

package/dist/user-dialog.js

@@ -0,0 +1,151 @@
+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);
+}
+export function parseClaudeAskUserDialog(request) {
+    if (request.dialogKind !== CLAUDE_ASK_USER_DIALOG_KIND)
+        return null;
+    const rawQuestions = Array.isArray(request.payload.questions)
+        ? request.payload.questions.filter(isRecord).slice(0, 12)
+        : [];
+    if (rawQuestions.length === 0)
+        return null;
+    const questions = rawQuestions.flatMap((record, index) => {
+        const question = typeof record.question === 'string' && record.question.trim()
+            ? record.question.trim().slice(0, 1000)
+            : null;
+        if (!question)
+            return [];
+        const slug = question.slice(0, 72).replace(/[^A-Za-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '');
+        const id = `q-${index + 1}${slug ? `-${slug}` : ''}`.slice(0, 120);
+        const header = typeof record.header === 'string' && record.header.trim()
+            ? record.header.trim().slice(0, 120)
+            : undefined;
+        const choices = (Array.isArray(record.options) ? record.options : [])
+            .filter(isRecord)
+            .slice(0, 12)
+            .flatMap((option) => {
+            const label = typeof option.label === 'string' && option.label.trim()
+                ? option.label.trim().slice(0, 120)
+                : typeof option.value === 'string' && option.value.trim()
+                    ? option.value.trim().slice(0, 120)
+                    : null;
+            if (!label)
+                return [];
+            const value = typeof option.value === 'string' && option.value.trim()
+                ? option.value.trim().slice(0, 120)
+                : label;
+            const description = typeof option.description === 'string' && option.description.trim()
+                ? option.description.trim().slice(0, 240)
+                : undefined;
+            const preview = typeof option.preview === 'string' && option.preview.trim()
+                ? option.preview.trim().slice(0, 4000)
+                : undefined;
+            return [{
+                    label,
+                    value,
+                    ...(description ? { description } : {}),
+                    ...(preview ? { preview } : {}),
+                }];
+        });
+        return [{
+                id,
+                question,
+                ...(header ? { header } : {}),
+                ...(choices.length > 0 ? { choices } : {}),
+                ...(resolveQuestionAllowOther(choices.length > 0, record.allowOther ?? record.isOther)
+                    ? { allowOther: true }
+                    : {}),
+                ...(record.isSecret === true ? { isSecret: true } : {}),
+                ...(record.multiSelect === true ? { multiSelect: true } : {}),
+            }];
+    });
+    if (questions.length === 0)
+        return null;
+    const permissionResult = isRecord(request.payload.permissionResult)
+        ? request.payload.permissionResult
+        : null;
+    const updatedInput = isRecord(request.payload.input)
+        ? request.payload.input
+        : permissionResult && isRecord(permissionResult.updatedInput)
+            ? permissionResult.updatedInput
+            : { questions: rawQuestions };
+    const metadataSource = typeof request.payload.metadataSource === 'string'
+        ? request.payload.metadataSource.trim()
+        : '';
+    const inputWithMetadata = metadataSource && !isRecord(updatedInput.metadata)
+        ? { ...updatedInput, metadata: { source: metadataSource } }
+        : updatedInput;
+    const requestId = typeof request.payload.requestId === 'string' && request.payload.requestId.trim()
+        ? request.payload.requestId.trim().slice(0, 160)
+        : undefined;
+    return { questions, rawQuestions, updatedInput: inputWithMetadata, ...(requestId ? { requestId } : {}) };
+}
+export function parseClaudeAskUserToolInput(input, requestId) {
+    return parseClaudeAskUserDialog({
+        dialogKind: CLAUDE_ASK_USER_DIALOG_KIND,
+        payload: { requestId, questions: input.questions, input },
+        toolUseID: requestId,
+    });
+}
+export function buildClaudeAskUserPermissionResult(dialog, response) {
+    const answers = {};
+    dialog.questions.forEach((question, index) => {
+        const answer = response.answers?.[question.id]?.answers.join(', ').trim();
+        const fallback = dialog.questions.length === 1 ? response.value?.trim() : undefined;
+        if (answer || fallback) {
+            const rawQuestion = dialog.rawQuestions[index]?.question;
+            const key = typeof rawQuestion === 'string' && rawQuestion.trim()
+                ? rawQuestion
+                : question.question;
+            answers[key] = answer || fallback || '';
+        }
+    });
+    return {
+        behavior: 'allow',
+        updatedInput: {
+            ...dialog.updatedInput,
+            questions: dialog.rawQuestions,
+            answers,
+        },
+    };
+}
+export function buildClaudeAskUserPermissionDenied(message) {
+    return { behavior: 'deny', message };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.25.0",
+  "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",
@@ -30,10 +30,10 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-sdk": "^5.1.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.204",
+    "@canonmsg/agent-sdk": "^5.1.1",
     "@canonmsg/coding-agent-host": "^0.2.2",
-    "@canonmsg/core": "^4.2.0",
+    "@canonmsg/core": "^4.2.2",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {