@canonmsg/claude-code-plugin 0.22.0 → 0.23.0

package/dist/session-state.d.ts

@@ -1,8 +1,6 @@
-import type { Query, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core/contract';
-import type { TurnArtifactSnapshot } from '@canonmsg/agent-host';
-import { type ClaudeEffortLevel } from './session-defaults.js';
-export type { ClaudeEffortLevel } from './session-defaults.js';
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core';
+import type { TurnArtifactSnapshot } from '@canonmsg/coding-agent-host';
 export type ClaudeInputKind = 'seed' | 'canon';
 export type ClaudeArtifactRoutingMode = 'workspace-generated' | 'disabled';
 export interface ClaudeInputEnvelope {
@@ -21,46 +19,6 @@ export interface ClaudeRuntimeControlError {
     message: string;
     updatedAt: number;
 }
-export type ClaudePermissionMode = Parameters<Query['setPermissionMode']>[0];
-export interface ClaudeSessionControl {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    runtimeControlValues?: Record<string, string>;
-    updatedAt?: number;
-    updatedBy?: string;
-}
-export interface ClaudeHostSessionState {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    fallbackModel?: string;
-    runtimeControlValues?: Record<string, string>;
-    state?: 'idle' | 'running' | 'requires_action';
-    contextUsage?: {
-        percentage: number;
-        totalTokens: number;
-        maxTokens: number;
-    };
-}
-export declare function parseClaudePermissionMode(value: unknown): ClaudePermissionMode | null;
-export declare function normalizeClaudeEffortLevel(value: unknown): ClaudeEffortLevel | undefined;
-export declare function buildClaudeInitialSessionState(input: {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    fallbackModel?: string;
-    runtimeControlValues?: Record<string, string>;
-}): ClaudeHostSessionState;
-export interface ClaudeSessionControlTarget {
-    state: ClaudeHostSessionState;
-    closed: boolean;
-    query: Pick<Query, 'setModel' | 'setPermissionMode' | 'applyFlagSettings'>;
-    writeState: () => void;
-    setRuntimeControlError: (controlId: string, value: string, error: unknown) => void;
-    clearRuntimeControlError: (controlId: string) => void;
-}
-export declare function applyClaudeSessionControl(target: ClaudeSessionControlTarget, ctrl: ClaudeSessionControl): void;
 export interface ClaudePendingFinalDelivery {
     turnKey: string;
     text: string;
@@ -102,15 +60,9 @@ export declare function shouldDeliverClaudeFinal(input: {
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
-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 resolveClaudeModelOptions(input: {
-    discovered: ReadonlyArray<ModelOption>;
+export declare function mergeClaudeModelOptions(input: {
+    previous: ReadonlyArray<ModelOption>;
+    next: ReadonlyArray<ModelOption>;
     selectedModel?: string | null;
 }): ModelOption[];
 export declare function formatClaudeControlError(error: unknown): string;

package/dist/session-state.js

@@ -1,140 +1,4 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { CLAUDE_EFFORT_LEVELS, claudeThinkingToFlagValue, parseClaudeThinkingMode, parseClaudeUltracodeMode, } from './session-defaults.js';
-const CLAUDE_PERMISSION_MODE_VALUES = new Set([
-    'acceptEdits',
-    'auto',
-    'bypassPermissions',
-    'default',
-    'dontAsk',
-    'plan',
-]);
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
-export function parseClaudePermissionMode(value) {
-    return typeof value === 'string' && CLAUDE_PERMISSION_MODE_VALUES.has(value)
-        ? value
-        : null;
-}
-export function normalizeClaudeEffortLevel(value) {
-    return typeof value === 'string' && CLAUDE_EFFORT_VALUES.has(value)
-        ? value
-        : undefined;
-}
-export function buildClaudeInitialSessionState(input) {
-    return {
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
-        ...(input.effort ? { effort: input.effort } : {}),
-        ...(input.fallbackModel ? { fallbackModel: input.fallbackModel } : {}),
-        ...(input.runtimeControlValues ? { runtimeControlValues: input.runtimeControlValues } : {}),
-        state: 'idle',
-    };
-}
-/**
- * Apply a control to the Claude SDK. W2-A2 deleted the seq-guarded optimistic
- * revert machinery (commit c356bdf8) that masked the 2–11s control poll: the
- * bridge is event-push now (~100ms), so the state is already published by the
- * caller's writeState() and the SDK apply is fired without a revert dance. A
- * failed apply surfaces as a runtime-control error (the display truth the app
- * reads) — the same shape codex uses. `value` is the requested value for the
- * error record; `controlId` scopes the error.
- */
-function applyControl(input) {
-    // Fire the SDK apply SYNCHRONOUSLY (an async setter may still resolve later);
-    // wrap so a synchronous throw is caught in the same rejection path.
-    void (async () => input.apply())().catch((error) => {
-        if (input.target.closed)
-            return;
-        input.target.setRuntimeControlError(input.controlId, input.value, error);
-        input.target.writeState();
-    });
-}
-function setRuntimeControlValue(state, controlId, value) {
-    state.runtimeControlValues = {
-        ...(state.runtimeControlValues ?? {}),
-        [controlId]: value,
-    };
-}
-export function applyClaudeSessionControl(target, ctrl) {
-    const nextModel = typeof ctrl.model === 'string' && ctrl.model.trim() ? ctrl.model.trim() : null;
-    if (ctrl.model !== undefined && !nextModel) {
-        target.setRuntimeControlError('model', String(ctrl.model), new Error('Unsupported Claude model.'));
-    }
-    else if (nextModel && nextModel !== target.state.model) {
-        target.state.model = nextModel;
-        target.clearRuntimeControlError('model');
-        applyControl({
-            target,
-            controlId: 'model',
-            value: nextModel,
-            apply: () => target.query.setModel(nextModel),
-        });
-    }
-    const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
-    if (ctrl.permissionMode !== undefined && !nextPermissionMode) {
-        target.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
-    }
-    else if (nextPermissionMode && nextPermissionMode !== target.state.permissionMode) {
-        // Claude Code applies permission-mode changes asynchronously; publish the
-        // requested value immediately (writeState below) and surface an error if the
-        // apply fails.
-        target.state.permissionMode = nextPermissionMode;
-        target.clearRuntimeControlError('permissionMode');
-        applyControl({
-            target,
-            controlId: 'permissionMode',
-            value: nextPermissionMode,
-            apply: () => target.query.setPermissionMode(nextPermissionMode),
-        });
-    }
-    const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
-    if (nextEffort && nextEffort !== target.state.effort) {
-        target.state.effort = nextEffort;
-        target.clearRuntimeControlError('effort');
-        applyControl({
-            target,
-            controlId: 'effort',
-            value: nextEffort,
-            apply: () => target.query.applyFlagSettings({ effortLevel: nextEffort }),
-        });
-    }
-    else if (ctrl.effort !== undefined && !nextEffort) {
-        target.setRuntimeControlError('effort', String(ctrl.effort), new Error('Unsupported Claude thinking level.'));
-    }
-    const runtimeControlValues = ctrl.runtimeControlValues ?? {};
-    if ('thinking' in runtimeControlValues) {
-        const nextThinking = parseClaudeThinkingMode(runtimeControlValues.thinking);
-        if (!nextThinking) {
-            target.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
-        }
-        else if (nextThinking !== target.state.runtimeControlValues?.thinking) {
-            setRuntimeControlValue(target.state, 'thinking', nextThinking);
-            target.clearRuntimeControlError('thinking');
-            applyControl({
-                target,
-                controlId: 'thinking',
-                value: nextThinking,
-                apply: () => target.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) }),
-            });
-        }
-    }
-    if ('ultracode' in runtimeControlValues) {
-        const nextUltracode = parseClaudeUltracodeMode(runtimeControlValues.ultracode);
-        if (!nextUltracode) {
-            target.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
-        }
-        else if (nextUltracode !== target.state.runtimeControlValues?.ultracode) {
-            setRuntimeControlValue(target.state, 'ultracode', nextUltracode);
-            target.clearRuntimeControlError('ultracode');
-            applyControl({
-                target,
-                controlId: 'ultracode',
-                value: nextUltracode,
-                apply: () => target.query.applyFlagSettings({ ultracode: nextUltracode === 'on' }),
-            });
-        }
-    }
-    target.writeState();
-}
 export function createClaudeInputEnvelope(input) {
     const sourceMessageId = input.sourceMessageId ?? null;
     const fallbackId = randomUUID();
@@ -182,45 +46,32 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
-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) {
-    return {
-        value: model.value,
-        label: displayLabelWithClaudeVersion(model),
-        ...(normalizeModelDescription(model.description) ? { description: normalizeModelDescription(model.description) } : {}),
-    };
-}
-export function isClaudeCustomModelOption(option) {
-    return option?.description?.trim().toLowerCase() === 'custom model';
-}
-export function resolveClaudeModelOptions(input) {
+export function mergeClaudeModelOptions(input) {
     const byValue = new Map();
-    for (const option of input.discovered) {
+    for (const option of input.previous) {
+        byValue.set(option.value, { ...option });
+    }
+    for (const option of input.next) {
         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 Claude model discovery.',
+            description: 'Selected for this Canon session but not returned by the latest Claude model probe.',
         });
     }
-    return [...byValue.values()];
+    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.',
+        };
+    });
 }
 export function formatClaudeControlError(error) {
     if (error instanceof Error && error.message.trim()) {

package/dist/setup.d.ts

@@ -2,7 +2,8 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
- * /canon-register and /canon-configure skills.
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
+ * 1. Install the /canon-register and /canon-configure skills
+ * 2. Show the user how to add the MCP server to their .mcp.json
  */
 export declare function main(): void;

package/dist/setup.js

@@ -2,14 +2,15 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
- * /canon-register and /canon-configure skills.
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
+ * 1. Install the /canon-register and /canon-configure skills
+ * 2. Show the user how to add the MCP server to their .mcp.json
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runCli } from './cli-entry.js';
-const HELP = `canon-setup — install Claude Code Canon skills
+const HELP = `canon-setup — install Claude Code Canon skills and print MCP setup
 
 USAGE
   canon-setup
@@ -18,7 +19,8 @@ FLAGS
   --help, -h       Show this help
   --version, -V    Show package version
 
-This command writes Canon Claude Code skill files under ~/.claude/skills.`;
+This command writes Canon Claude Code skill files under ~/.claude/skills and
+prints the MCP server configuration for Claude Code channel mode.`;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const home = process.env.HOME || process.env.USERPROFILE || '';
 const skillsDir = join(home, '.claude', 'skills');
@@ -43,6 +45,27 @@ function installSkills() {
         console.log(`  Installed /canon-${skill}`);
     }
 }
+// ── Show MCP config instructions ───────────────────────────────────────
+function showMcpInstructions() {
+    // Find the installed server.js path
+    const serverPath = join(__dirname, 'server.js');
+    console.log(`
+Add this to your project's .mcp.json (or ~/.mcp.json for global):
+
+{
+  "mcpServers": {
+    "canon-channel": {
+      "command": "node",
+      "args": ["${serverPath}"]
+    }
+  }
+}
+
+Then start Claude Code with:
+
+  claude --dangerously-load-development-channels server:canon-channel
+`);
+}
 // ── Main ───────────────────────────────────────────────────────────────
 export function main() {
     console.log('Canon Claude Code Plugin Setup');
@@ -52,7 +75,8 @@ export function main() {
     console.log('\nRegistering your agent...');
     console.log('  Run /canon-register in Claude Code to register a new agent');
     console.log('  Run /canon-configure if you already have an API key\n');
-    console.log('Run `canon-claude` to connect this agent to Canon.');
+    console.log('MCP server configuration:');
+    showMcpInstructions();
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-setup] Fatal error:', error);

package/dist/startup-recovery.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * 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).
+ */
+export declare const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export declare const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export interface StartupRecoveryMessage {
+    id: string;
+    senderId: string;
+    createdAt?: string;
+}
+export interface StartupRecoveryPage {
+    messages: StartupRecoveryMessage[];
+}
+export type StartupRecoveryMode = 
+/** Cursor found — `messages` is everything strictly after it. */
+'after-cursor'
+/** Cursor present but not found within the bound — `messages` is the bounded recent window. */
+ | 'truncated-window'
+/**
+ * No usable cursor (fresh runtime file, or the cursor message no longer
+ * exists in history) — only the newest inbound message is recovered, since
+ * a full-history replay could fire mass duplicate turns.
+ */
+ | 'latest-only';
+export interface StartupRecoveryResult<TPage extends StartupRecoveryPage> {
+    mode: StartupRecoveryMode;
+    /** Missed inbound messages (own messages excluded), oldest first. */
+    messages: TPage['messages'];
+    /** First page fetched — reusable as hydration context for recovered turns. */
+    newestPage: TPage;
+}
+export declare function collectMissedInboundMessages<TPage extends StartupRecoveryPage>(input: {
+    fetchPage: (before?: string) => Promise<TPage>;
+    cursor: string | null | undefined;
+    agentId: string;
+    maxMessages?: number;
+}): Promise<StartupRecoveryResult<TPage>>;

package/dist/startup-recovery.js

@@ -0,0 +1,59 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * 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).
+ */
+export const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export async function collectMissedInboundMessages(input) {
+    const maxMessages = input.maxMessages ?? STARTUP_RECOVERY_MAX_MESSAGES;
+    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) {
+            // Pages are newest-first, so the last collected message is the oldest.
+            const before = collected[collected.length - 1]?.id;
+            if (!before)
+                break;
+            const page = await input.fetchPage(before);
+            const fresh = page.messages.filter((message) => !seenIds.has(message.id));
+            // No pagination progress (history exhausted, or the server ignored the
+            // `before` cursor because that message was hard-deleted) — stop here.
+            if (fresh.length === 0)
+                break;
+            for (const message of fresh)
+                seenIds.add(message.id);
+            collected.push(...fresh);
+            cursorFound = hasCursor(fresh);
+        }
+    }
+    const ascending = [...collected].sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')));
+    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId);
+    let mode;
+    let missed;
+    if (cursorFound) {
+        const cursorIndex = ascending.findIndex((message) => message.id === input.cursor);
+        mode = 'after-cursor';
+        missed = inboundOnly(ascending.slice(cursorIndex + 1));
+    }
+    else if (input.cursor != null && collected.length >= maxMessages) {
+        mode = 'truncated-window';
+        missed = inboundOnly(ascending.slice(-maxMessages));
+    }
+    else {
+        mode = 'latest-only';
+        missed = inboundOnly(ascending).slice(-1);
+    }
+    // Safe: `missed` only holds elements of pages returned by `fetchPage`.
+    return { mode, messages: missed, newestPage };
+}

package/dist/streaming-buffer.d.ts

@@ -0,0 +1,16 @@
+export interface StreamingBufferOptions {
+    throttleMs: number;
+    getText: () => string;
+    setText: (text: string) => void;
+    getTimer: () => ReturnType<typeof setTimeout> | null;
+    setTimer: (timer: ReturnType<typeof setTimeout> | null) => void;
+    onWrite: (text: string) => void;
+    schedule?: typeof setTimeout;
+    cancel?: typeof clearTimeout;
+}
+export declare function createStreamingBuffer(options: StreamingBufferOptions): {
+    append(delta: string): void;
+    flush: () => void;
+    clear(): void;
+    replace(text: string): void;
+};

package/dist/streaming-buffer.js

@@ -0,0 +1,52 @@
+export function createStreamingBuffer(options) {
+    const schedule = options.schedule ?? setTimeout;
+    const cancel = options.cancel ?? clearTimeout;
+    const flush = () => {
+        const timer = options.getTimer();
+        if (timer) {
+            cancel(timer);
+            options.setTimer(null);
+        }
+        const text = options.getText();
+        if (text) {
+            options.onWrite(text);
+        }
+    };
+    return {
+        append(delta) {
+            if (!delta)
+                return;
+            options.setText(`${options.getText()}${delta}`);
+            if (options.getTimer())
+                return;
+            const timer = schedule(() => {
+                options.setTimer(null);
+                const text = options.getText();
+                if (text) {
+                    options.onWrite(text);
+                }
+            }, options.throttleMs);
+            options.setTimer(timer);
+        },
+        flush,
+        clear() {
+            const timer = options.getTimer();
+            if (timer) {
+                cancel(timer);
+                options.setTimer(null);
+            }
+            options.setText('');
+        },
+        replace(text) {
+            const timer = options.getTimer();
+            if (timer) {
+                cancel(timer);
+                options.setTimer(null);
+            }
+            options.setText(text);
+            if (text) {
+                options.onWrite(text);
+            }
+        },
+    };
+}

package/dist/tool-policy.d.ts

@@ -1,5 +1,4 @@
-import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core/contract';
-import type { ApprovalManager } from '@canonmsg/core/host';
+import type { ApprovalManager, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core';
 export type ClaudeToolPolicyDecision = {
     behavior: 'allow';
 } | {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.22.0",
-  "description": "Canon host for Claude Code — messaging where AI agents are first-class citizens",
+  "version": "0.23.0",
+  "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,28 +12,28 @@
     }
   },
   "bin": {
+    "canon-channel-server": "dist/server.js",
     "canon-claude": "dist/host.js",
     "canon-register": "dist/register.js",
     "canon-setup": "dist/setup.js"
   },
   "files": [
     "dist",
-    "skills"
+    "skills",
+    ".claude-plugin"
   ],
   "scripts": {
-    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
+    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk ../coding-agent-host",
     "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "npm run prepare:workspace-deps && tsc --watch",
     "prepack": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-host": "^0.5.0",
-    "@canonmsg/agent-sdk": "^4.0.0",
-    "@canonmsg/bridge": "^0.3.0",
-    "@canonmsg/core": "^3.3.0",
-    "@canonmsg/framework": "^0.3.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
+    "@canonmsg/agent-sdk": "^5.0.0",
+    "@canonmsg/coding-agent-host": "^0.2.2",
+    "@canonmsg/core": "^4.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {
@@ -50,9 +50,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/HeyBobChan/canon",
-    "directory": "adapters/claude-code-plugin"
+    "directory": "packages/claude-code-plugin"
   },
-  "homepage": "https://github.com/HeyBobChan/canon/tree/main/adapters/claude-code-plugin",
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/claude-code-plugin",
   "publishConfig": {
     "access": "public"
   },

package/skills/configure/SKILL.md

@@ -36,9 +36,15 @@ Add an existing Canon agent API key as a named profile.
 
 5. Write the updated profiles to `~/.canon/agents.json`.
 
-6. Tell the user: **"API key saved as profile '<profile>'. Run `canon-claude` to connect."**
+6. Tell the user: **"API key saved as profile '<profile>'. Restart Claude Code to connect."**
 
-   If they have multiple agents and want to pin one, start the host with the profile name:
-   ```bash
-   CANON_AGENT=<profile> canon-claude
+   If they have multiple agents and want to pin one, add to `.mcp.json`:
+   ```json
+   {
+     "mcpServers": {
+       "canon-channel": {
+         "env": { "CANON_AGENT": "<profile>" }
+       }
+     }
+   }
    ```

package/dist/bridge-bin.d.ts

@@ -1,14 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-export declare function resolvePackagedBridgeBin(env?: NodeJS.ProcessEnv): string | undefined;

package/dist/bridge-bin.js

@@ -1,27 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-import { createRequire } from 'node:module';
-import { dirname, join as joinPath } from 'node:path';
-export function resolvePackagedBridgeBin(env = process.env) {
-    if (env.CANON_BRIDGE_BIN)
-        return undefined;
-    try {
-        const require = createRequire(import.meta.url);
-        const manifestPath = require.resolve('@canonmsg/bridge/package.json');
-        return joinPath(dirname(manifestPath), 'dist', 'main.js');
-    }
-    catch {
-        return undefined;
-    }
-}