@canonmsg/claude-code-plugin 0.29.1 → 0.29.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.29.1",
+  "version": "0.29.2",
   "channels": [
     {
       "server": "canon-channel",

package/dist/approval-server.d.ts

@@ -29,5 +29,4 @@ export declare class ApprovalHttpServer {
     private hasValidToken;
     private handleApproval;
     private sendHookResponse;
-    private classifyRisk;
 }

package/dist/approval-server.js

@@ -131,8 +131,9 @@ export class ApprovalHttpServer {
         }
         const toolName = payload.tool_name ?? 'Unknown';
         const toolInput = payload.tool_input ?? {};
-        // Determine risk level
-        const riskLevel = this.classifyRisk(toolName, toolInput);
+        // Single source of truth for risk, shared with host mode (tool-policy.ts).
+        const risk = classifyClaudeApprovalRisk(toolName, toolInput);
+        const riskLevel = risk === 'destructive' ? 'destructive' : 'normal';
         const isOwnerTurn = this.getIsOwnerTurn();
         // Find the conversation to send the approval to.
         const conversationId = this.getConversationId();
@@ -154,7 +155,7 @@ export class ApprovalHttpServer {
         try {
             const result = await this.manager.requestApproval(conversationId, toolName, toolInput, {
                 riskLevel,
-                risk: classifyClaudeApprovalRisk(toolName, toolInput),
+                risk,
                 category: classifyClaudeApprovalCategory(toolName),
                 native: {
                     runtime: 'claude-code',
@@ -182,19 +183,4 @@ export class ApprovalHttpServer {
             },
         }));
     }
-    classifyRisk(toolName, toolInput) {
-        if (toolName !== 'Bash')
-            return 'normal';
-        const cmd = typeof toolInput.command === 'string' ? toolInput.command : '';
-        const destructivePatterns = [
-            /\brm\s+(-rf?|--force)/,
-            /\bgit\s+push\s+--force/,
-            /\bgit\s+reset\s+--hard/,
-            /\bdrop\s+(table|database)/i,
-            /\bformat\b/,
-        ];
-        return destructivePatterns.some((p) => p.test(cmd))
-            ? 'destructive'
-            : 'normal';
-    }
 }

package/dist/host.js

@@ -27,16 +27,14 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, } from '@canonmsg/coding-agent-host';
-import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, buildBoundedTurnTrail, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, readLocalRuntimeEntry, resolveCanonAgent, verifyResolvedAgentEnvironment, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
-import { decideAutoReply, } from './inbound-policy.js';
-import { runCli } from './cli-entry.js';
+import { captureTurnArtifactSnapshot, collectTurnArtifacts, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
+import { EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, buildBoundedTurnTrail, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { runCli } from '@canonmsg/core';
 import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer } from '@canonmsg/agent-tools';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
 import { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, prepareTurnTrailForDelivery, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeFinalText, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
 import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
-import { collectMissedInboundMessages, createReconnectRecoveryGate, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -194,7 +192,7 @@ function buildClaudeRuntimeDescriptor(input) {
                     label: 'Level',
                     kind: 'enum',
                     required: true,
-                    choices: [...CLAUDE_EFFORT_OPTIONS],
+                    choices: [...EFFORT_OPTIONS],
                 }],
             dispatch: {
                 kind: 'control',
@@ -237,7 +235,7 @@ function buildClaudeRuntimeDescriptor(input) {
         executionModes: input.executionModes,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
-        effortOptions: [...CLAUDE_EFFORT_OPTIONS],
+        effortOptions: [...EFFORT_OPTIONS],
         extraRuntimeControls: [{
                 id: 'ultracode',
                 label: 'Ultracode',
@@ -272,7 +270,7 @@ function buildClaudeRuntimeDescriptor(input) {
         commands,
     });
 }
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_OPTIONS.map((option) => option.value));
+const CLAUDE_EFFORT_VALUES = new Set(EFFORT_OPTIONS.map((option) => option.value));
 function parseClaudePermissionMode(value) {
     if (value === 'acceptEdits'
         || value === 'auto'
@@ -376,13 +374,14 @@ function acceptClaudeCli(source, cliPath) {
 function toModelOptions(models) {
     return models.map(claudeModelInfoToOption);
 }
-async function publishAgentRuntime(agentId, runtime) {
-    await publishHostAgentRuntime(agentId, 'claude-code', runtime);
+async function publishAgentRuntime(agentId, runtime, rtdb) {
+    await publishHostAgentRuntime(agentId, 'claude-code', runtime, rtdb);
 }
-async function loadSessionConfig(conversationId, agentId) {
+async function loadSessionConfig(conversationId, agentId, rtdb) {
     const config = await loadHostSessionConfig({
         conversationId,
         agentId,
+        rtdb,
         extraStringFields: ['permissionMode', 'effort'],
     });
     return {
@@ -2415,6 +2414,7 @@ export async function main() {
         agentId,
         clientType: 'claude-code',
         hostMode: true,
+        rtdb,
     });
     let streamConnected = false;
     const hostAvailableExecutionModes = [
@@ -2455,6 +2455,7 @@ export async function main() {
         await publishHostSessionSnapshots({
             conversationIds,
             agentId,
+            rtdb,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
             workspaceOptions,
@@ -2499,7 +2500,7 @@ export async function main() {
             console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
             return runtimeMetadata;
         });
-        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+        await publishAgentRuntime(agentId, runtimeDescriptor, rtdb).catch((error) => {
             console.error('[canon-host] Failed to publish agent runtime:', error);
         });
         await publishSessionSnapshots(Array.from(knownConversationIds));
@@ -2860,7 +2861,7 @@ export async function main() {
             evictOldestIdle();
         }
         const creation = (async () => {
-            const config = await loadSessionConfig(conversationId, agentId);
+            const config = await loadSessionConfig(conversationId, agentId, rtdb);
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -3114,40 +3115,21 @@ export async function main() {
         }
         return consumed;
     }
-    function persistedConversationCursors(conversationId) {
-        const canonicalCursor = loadRuntimeSessionState(runtimeId, {
+    function persistedConversationCursor(conversationId) {
+        return loadRuntimeSessionState(runtimeId, {
             conversationId,
             baseCwd: workingDir,
             workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
         })?.lastInboundMessageId ?? null;
-        if (canonicalCursor)
-            return { canonicalCursor, legacyCursors: [] };
-        const legacyCursors = Object.values(readLocalRuntimeEntry(runtimeId)?.sessions ?? {})
-            .filter((state) => state.conversationId === conversationId)
-            .map((state) => state.lastInboundMessageId)
-            .filter((messageId) => Boolean(messageId));
-        return { canonicalCursor: null, legacyCursors: [...new Set(legacyCursors)] };
     }
     async function performMissedInboundRecovery() {
         for (const conversationId of knownConversationIds) {
             try {
-                const cursors = persistedConversationCursors(conversationId);
                 const recovered = await collectMissedInboundMessages({
                     fetchPage: (before) => client.getMessagesPage(conversationId, STARTUP_RECOVERY_PAGE_SIZE, before),
-                    cursor: cursors.canonicalCursor,
-                    cursorCandidates: cursors.legacyCursors,
+                    cursor: persistedConversationCursor(conversationId),
                     agentId,
                 });
-                if (!cursors.canonicalCursor
-                    && recovered.cursor
-                    && recovered.messages.length === 0) {
-                    saveRuntimeSessionState(runtimeId, {
-                        conversationId,
-                        baseCwd: workingDir,
-                        workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
-                        lastInboundMessageId: recovered.cursor,
-                    });
-                }
                 if (recovered.mode === 'truncated-window') {
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovery cursor was not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; replaying the bounded recent window`);
                 }

package/dist/register.d.ts

@@ -1,2 +1,11 @@
 #!/usr/bin/env node
+/**
+ * CLI script for Canon agent registration.
+ * Invoked by the /canon-register skill.
+ *
+ * Usage:
+ *   node register.js --name "My Agent" --description "What it does" --phone "+15551234567" [--profile "my-agent"]
+ *
+ * On approval, saves the agent to ~/.canon/agents.json under the profile name.
+ */
 export declare function main(): Promise<void>;

package/dist/register.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { setDefaultResultOrder } from 'node:dns';
 /**
  * CLI script for Canon agent registration.
  * Invoked by the /canon-register skill.
@@ -9,9 +8,7 @@ import { setDefaultResultOrder } from 'node:dns';
  *
  * On approval, saves the agent to ~/.canon/agents.json under the profile name.
  */
-import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, loadProfiles, registerAndWaitForApproval, resolveCanonRuntimeConnection, updatePendingRegistration, upsertAgentProfile, verifyCanonRuntimeConnection, } from '@canonmsg/core';
-import { parseArgs } from 'node:util';
-import { runCli } from './cli-entry.js';
+import { registerRegistrationCli, runRegistrationCli, } from '@canonmsg/core';
 const HELP = `canon-register — register or reconnect a Claude Code agent in Canon
 
 USAGE
@@ -37,114 +34,17 @@ EXAMPLES
   canon-register --name "Frontend" --description "React work" --phone "+15551234567" --profile frontend
 
 After approval, start it with CANON_AGENT=<profile> canon-claude --cwd /path/to/project.`;
+const OPTIONS = {
+    moduleUrl: import.meta.url,
+    clientType: 'claude-code',
+    cliName: 'canon-register',
+    hostBinName: 'canon-claude',
+    developerInfo: 'Claude Code plugin',
+    registeringLabel: 'agent',
+    usage: 'Usage: node register.js --name "Agent Name" --description "Description" --phone "+15551234567" [--profile "my-agent"]',
+    help: HELP,
+};
 export async function main() {
-    setDefaultResultOrder('ipv4first');
-    const { values } = parseArgs({
-        options: {
-            name: { type: 'string' },
-            description: { type: 'string' },
-            phone: { type: 'string' },
-            profile: { type: 'string' },
-            environment: { type: 'string' },
-            'base-url': { type: 'string' },
-            'stream-url': { type: 'string' },
-            'rtdb-url': { type: 'string' },
-            'firebase-api-key': { type: 'string' },
-        },
-        strict: true,
-    });
-    if (!values.name || !values.description || !values.phone) {
-        console.error('Usage: node register.js --name "Agent Name" --description "Description" --phone "+15551234567" [--profile "my-agent"]');
-        process.exit(1);
-    }
-    // Default profile name: sanitized agent name
-    const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
-    const environmentId = values.environment || process.env.CANON_ENVIRONMENT_ID;
-    if (!environmentId) {
-        throw new Error('--environment or CANON_ENVIRONMENT_ID is required');
-    }
-    const connection = resolveCanonRuntimeConnection({
-        environmentId,
-        apiBaseUrl: values['base-url'],
-        streamUrl: values['stream-url'],
-        rtdbUrl: values['rtdb-url'],
-        firebaseWebApiKey: values['firebase-api-key'],
-    });
-    await verifyCanonRuntimeConnection(connection);
-    const existingProfile = loadProfiles()[profileName];
-    const existingAgentId = existingProfile?.environmentId === connection.environmentId
-        ? existingProfile.agentId
-        : undefined;
-    console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
-    const pending = getOrCreatePendingRegistration(profileName, 'claude-code', connection);
-    const result = await registerAndWaitForApproval({
-        name: values.name,
-        description: values.description,
-        ownerPhone: values.phone,
-        developerInfo: 'Claude Code plugin',
-        clientType: 'claude-code',
-        baseUrl: connection.apiBaseUrl,
-        requestedAgentId: existingAgentId,
-        localRegistrationId: pending.localRegistrationId,
-    }, {
-        onSubmitted: (requestId, pollToken) => {
-            updatePendingRegistration(profileName, {
-                requestId,
-                pollToken,
-                clientType: 'claude-code',
-            });
-            console.log(`Registration submitted (request ID: ${requestId}).`);
-            console.log('Waiting for approval in Canon app...');
-        },
-        onPollUpdate: () => {
-            process.stdout.write('.');
-        },
-    });
-    console.log(''); // newline after dots
-    switch (result.status) {
-        case 'approved': {
-            if (!result.apiKey || !result.agentId || !result.agentName) {
-                console.error('Approval completed but Canon did not return a usable API key. Run this command again to resume key pickup.');
-                process.exit(1);
-            }
-            upsertAgentProfile(profileName, {
-                apiKey: result.apiKey,
-                agentId: result.agentId,
-                agentName: result.agentName,
-                registeredAt: new Date().toISOString(),
-                environmentId: connection.environmentId,
-                baseUrl: connection.apiBaseUrl,
-                streamUrl: connection.streamUrl,
-                rtdbUrl: connection.rtdbUrl,
-                firebaseApiKey: connection.firebaseWebApiKey,
-                clientType: 'claude-code',
-            });
-            if (result.requestId) {
-                await ackRegistrationApproval(connection.apiBaseUrl, result.requestId, result.pollToken);
-            }
-            clearPendingRegistration(profileName);
-            console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
-            console.log(`Saved as profile "${profileName}" in ~/.canon/agents.json`);
-            console.log('Start it with: CANON_AGENT=' + profileName + ' canon-claude --cwd /path/to/project');
-            console.log('Keep that terminal open while you want Canon to reach the agent.');
-            console.log('Closing it, logging out, rebooting, or sleeping long enough to stop the process takes this local agent offline until you revive it.');
-            console.log('Docs: https://canonmail.com/agents/integrations');
-            break;
-        }
-        case 'rejected':
-            console.log('Registration was rejected.');
-            process.exit(1);
-            break;
-        case 'timeout':
-            console.log('Registration timed out (5 minutes). Try again later.');
-            process.exit(1);
-            break;
-    }
+    await runRegistrationCli(OPTIONS);
 }
-runCli(import.meta.url, main, (error) => {
-    console.error('[canon-register] Fatal error:', error);
-    process.exit(1);
-}, {
-    name: 'canon-register',
-    help: HELP,
-});
+registerRegistrationCli(OPTIONS);

package/dist/server.js

@@ -10,10 +10,10 @@ import { setDefaultResultOrder } from 'node:dns';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, verifyResolvedAgentEnvironment, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, writeSessionState, clearSessionState, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, verifyResolvedAgentEnvironment, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, renderCanonHostInboundContent, } from '@canonmsg/core';
 import { materializeMessageMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { ApprovalHttpServer } from './approval-server.js';
-import { runCli } from './cli-entry.js';
+import { runCli } from '@canonmsg/core';
 import { parseReplyArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
 import { canonVerbToolDefinitions, executeCanonVerbTool, isCanonToolVerb, stampSendToTurnComplete, } from '@canonmsg/agent-tools';
 const HELP = `canon-channel-server — Claude Code MCP channel server for Canon
@@ -39,6 +39,7 @@ let stream = null;
 let agentContext = null;
 let approvalManager = null;
 let approvalServer = null;
+let rtdb = null;
 const conversationCache = new Map();
 const TURN_COMPLETE_METADATA = {
     turnSemantics: 'turn_complete',
@@ -486,7 +487,7 @@ async function startChannel() {
         }
     }
     // Initialize RTDB auth for session state reporting
-    initRTDBAuth(client, {
+    rtdb = initRTDBAuth(client, {
         rtdbUrl: resolvedRuntime.rtdbUrl,
         firebaseApiKey: resolvedRuntime.firebaseApiKey,
     });
@@ -524,7 +525,7 @@ async function startChannel() {
     // Write initial session state
     const initialState = { cwd: process.cwd(), isActive: true };
     for (const convoId of conversationCache.keys()) {
-        writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
+        rtdb?.writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
     }
     // Start SSE stream
     stream = new CanonStream({
@@ -580,7 +581,7 @@ export async function main() {
         // Mark all conversations as inactive
         if (agentContext) {
             for (const convoId of conversationCache.keys()) {
-                clearSessionState(convoId, agentContext.agentId).catch(() => { });
+                rtdb?.clearSessionState(convoId, agentContext.agentId).catch(() => { });
             }
         }
         approvalManager?.dispose();

package/dist/setup.js

@@ -9,7 +9,7 @@
 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';
+import { runCli } from '@canonmsg/core';
 const HELP = `canon-setup — install Claude Code Canon skills and print MCP setup
 
 USAGE
@@ -47,23 +47,21 @@ function installSkills() {
 }
 // ── 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}"]
+      "command": "canon-channel-server"
     }
   }
 }
 
 Then start Claude Code with:
 
-  claude --dangerously-load-development-channels server:canon-channel
+  CANON_API_KEY=agk_live_... CANON_ENVIRONMENT_ID=canon-prod-v1 \
+    claude --dangerously-load-development-channels server:canon-channel
 `);
 }
 // ── Main ───────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.29.1",
+  "version": "0.29.2",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.220",
-    "@canonmsg/agent-sdk": "^7.1.3",
-    "@canonmsg/agent-tools": "^0.3.2",
-    "@canonmsg/coding-agent-host": "^0.3.1",
-    "@canonmsg/core": "^8.2.0",
-    "@canonmsg/rich-cards": "^0.8.6",
+    "@canonmsg/agent-sdk": "^8.0.0",
+    "@canonmsg/agent-tools": "^0.3.3",
+    "@canonmsg/coding-agent-host": "^0.4.0",
+    "@canonmsg/core": "^9.0.0",
+    "@canonmsg/rich-cards": "^0.8.7",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {

package/dist/cli-entry.d.ts

@@ -1,2 +0,0 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';
-export type { CliMetadata, RunCliMetadataOptions, } from '@canonmsg/core';

package/dist/cli-entry.js

@@ -1 +0,0 @@
-export { handleCliMetadataRequest, isDirectExecution, readCliPackageVersion, runCli, } from '@canonmsg/core';

package/dist/inbound-policy.d.ts

@@ -1,22 +0,0 @@
-import { type CanonGroupContext, type CanonGroupContextMode, type CanonConversation, type ResolvedAgentBehaviorPolicy } from '@canonmsg/core';
-export interface InboundParticipantContext {
-    conversationType: CanonConversation['type'] | 'unknown';
-    memberCount: number | null;
-    senderType: 'human' | 'ai_agent';
-    senderName: string;
-    isOwner: boolean;
-    mentionedAgent: boolean;
-    groupContext?: CanonGroupContext;
-    groupContextMode?: CanonGroupContextMode;
-    recentSenderTypes: Array<'human' | 'ai_agent'>;
-    recentHumanCount: number;
-    recentAgentCount: number;
-    consecutiveAgentTurns: number;
-    currentAgentStreakStartedByHuman: boolean;
-}
-export interface AutoReplyDecision {
-    allow: boolean;
-    reason: string;
-}
-export declare function buildInboundContextLines(context: InboundParticipantContext): string[];
-export declare function decideAutoReply(context: InboundParticipantContext, behavior?: ResolvedAgentBehaviorPolicy | null): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -1,46 +0,0 @@
-import { buildCompactGroupContextLines, evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
-function formatRecentSenders(senderTypes) {
-    if (senderTypes.length === 0)
-        return 'none';
-    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
-}
-export function buildInboundContextLines(context) {
-    const conversationTypeLabel = context.conversationType === 'unknown'
-        ? 'unknown'
-        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
-    const senderRole = context.isOwner
-        ? 'The latest sender is the verified human owner of this Canon agent.'
-        : context.senderType === 'ai_agent'
-            ? 'The latest sender is another AI agent in Canon.'
-            : 'The latest sender is a human Canon participant.';
-    return [
-        senderRole,
-        `Latest sender name: ${context.senderName}`,
-        `Latest sender type: ${context.senderType}`,
-        `Conversation type: ${conversationTypeLabel}`,
-        ...(context.groupContext && context.groupContextMode
-            ? buildCompactGroupContextLines(context.groupContext, context.groupContextMode)
-            : []),
-        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
-        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
-        `Recent human messages: ${context.recentHumanCount}`,
-        `Recent agent messages: ${context.recentAgentCount}`,
-        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
-        `Current agent streak started after a human message: ${context.currentAgentStreakStartedByHuman ? 'yes' : 'no'}`,
-    ];
-}
-export function decideAutoReply(context, behavior) {
-    const decision = evaluateParticipationPolicy(behavior ?? resolveAgentBehaviorPolicy(), {
-        conversationType: context.conversationType,
-        senderType: context.senderType,
-        isOwner: context.isOwner,
-        mentionedAgent: context.mentionedAgent,
-        recentHumanCount: context.recentHumanCount,
-        consecutiveAgentTurns: context.consecutiveAgentTurns,
-        currentAgentStreakStartedByHuman: context.currentAgentStreakStartedByHuman,
-    });
-    return {
-        allow: decision.allow,
-        reason: decision.reason,
-    };
-}

package/dist/startup-recovery.d.ts

@@ -1,54 +0,0 @@
-/**
- * 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.
- *
- * 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;
-export interface StartupRecoveryMessage {
-    id: string;
-    senderId: string;
-    createdAt?: string;
-    metadata?: Record<string, unknown>;
-}
-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;
-    /** 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. */
-    newestPage: TPage;
-}
-/**
- * Startup recovery runs before the stream starts. The first SSE connection
- * therefore needs no second pass, while later reconnects still need catch-up.
- */
-export declare function createReconnectRecoveryGate(): () => boolean;
-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

@@ -1,102 +0,0 @@
-/**
- * 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.
- *
- * 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;
-/**
- * Startup recovery runs before the stream starts. The first SSE connection
- * therefore needs no second pass, while later reconnects still need catch-up.
- */
-export function createReconnectRecoveryGate() {
-    let hasConnected = false;
-    return () => {
-        const shouldRecover = hasConnected;
-        hasConnected = true;
-        return shouldRecover;
-    };
-}
-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 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)
-                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);
-            recordFoundCursors(fresh);
-        }
-    }
-    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 (resolvedCursor) {
-        const cursorIndex = ascending.findIndex((message) => message.id === resolvedCursor);
-        mode = 'after-cursor';
-        missed = inboundOnly(ascending.slice(cursorIndex + 1));
-    }
-    else if (candidateCursorIds.size > 0 && 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,
-        cursor: resolvedCursor,
-        messages: missed,
-        newestPage,
-    };
-}

package/dist/streaming-buffer.d.ts

@@ -1,16 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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);
-            }
-        },
-    };
-}