@canonmsg/claude-code-plugin 0.12.8 → 0.13.1

package/README.md

@@ -66,9 +66,19 @@ CANON_AGENT=frontend canon-claude --cwd ~/projects/frontend
 
 ## Channel mode (alternative)
 
-For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. See [full setup guide](../../docs/claude-code-setup.md#channel-mode-alternative).
+For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. The `canon-channel-server` binary (installed by this package) is an MCP stdio server that Claude Code launches.
 
-Channel mode is embedded inside Claude Code and is shown as non-revivable by `canon-necromance`. Use `canon-claude` host mode when you want phone-controlled runtime sessions.
+Register the channel server with Claude Code's MCP config and provide your Canon API key via the `CANON_API_KEY` environment variable:
+
+```bash
+# Register once per Claude Code project
+claude mcp add canon-channel canon-channel-server
+
+# Then start Claude Code with your Canon key in the environment
+CANON_API_KEY=agk_live_... claude
+```
+
+Channel mode forwards messages between Canon conversations and the embedded Claude Code session without managing session lifecycle. It is shown as non-revivable by `canon-necromance`. Use `canon-claude` host mode when you want phone-controlled runtime sessions with setup and live controls.
 
 ## Development
 

package/dist/host.js

@@ -26,11 +26,11 @@ import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { CLAUDE_PERMISSION_MODE_OPTIONS, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, createConversationMetadataLoader, createRuntimeStatePublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, rtdbRead, rtdbWrite, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, createConversationMetadataLoader, createRuntimeStatePublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, rtdbRead, rtdbWrite, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { createStreamingBuffer } from './streaming-buffer.js';
 import { runCli } from './cli-entry.js';
-import { buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, shouldDeliverClaudeFinal, } from './session-state.js';
+import { buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
 const HELP = `canon-claude — run a local Claude Code agent host for Canon
 
 USAGE
@@ -154,26 +154,9 @@ function buildClaudeRuntimeDescriptor(input) {
                 availability: ['always'],
                 dispatch: { kind: 'open_details', target: 'effort' },
             },
-            {
-                id: 'stop',
-                label: 'Stop',
-                description: 'Interrupt the current Claude turn.',
-                aliases: ['stop'],
-                category: 'turn',
-                placements: ['composer_slash', 'command_palette'],
-                availability: ['busy'],
-                dispatch: { kind: 'signal', signal: 'interrupt' },
-            },
-            {
-                id: 'stop-and-clear-queue',
-                label: 'Stop & clear queue',
-                description: 'Interrupt the current Claude turn and drop queued Canon messages.',
-                aliases: ['stop-clear', 'clear-queue'],
-                category: 'turn',
-                placements: ['composer_slash', 'command_palette', 'session_strip'],
-                availability: ['busy_with_queue'],
-                dispatch: { kind: 'signal', signal: 'stop_and_drop' },
-            },
+            RUNTIME_STOP_ACTION,
+            RUNTIME_STOP_AND_DROP_ACTION,
+            RUNTIME_NEW_SESSION_ACTION,
         ],
     });
 }
@@ -802,6 +785,10 @@ function createSession(conversationId, environment, agentId, client, runtimeStat
     function onStreamDelta(text) {
         streamingBuffer.append(text);
     }
+    function isActiveTurnInterrupted() {
+        const turnKey = session.activeInput?.turnKey;
+        return Boolean(turnKey && session.interruptedTurnKeys.has(turnKey));
+    }
     function clearStreaming() {
         streamingBuffer.clear();
         runtimeState.clearStreaming(conversationId).catch(() => { });
@@ -822,15 +809,9 @@ function createSession(conversationId, environment, agentId, client, runtimeStat
         if (session.closed)
             return;
         clearFinalDeliveryTimer();
-        session.currentTurnId = null;
-        session.currentTurnOpenedAt = null;
-        session.lastAcceptedIntent = null;
-        session.pendingFinalText = null;
-        session.pendingFinalDelivery = null;
-        session.activeInput = null;
-        session.toolInProgress = false;
-        session.turnState = 'idle';
+        resetClaudeCompletedTurnState(session);
         stopVisibleWorkSignal();
+        writeState();
         writeTurn();
         drainPendingInput();
     }
@@ -1100,6 +1081,11 @@ function createSession(conversationId, environment, agentId, client, runtimeStat
                     }
                     case 'stream_event': {
                         const event = msg.event;
+                        if (isActiveTurnInterrupted()) {
+                            stopVisibleWorkSignal();
+                            client.setTyping(conversationId, false).catch(() => { });
+                            break;
+                        }
                         if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
                             session.toolInProgress = true;
                             session.turnState = 'tool';
@@ -1570,19 +1556,20 @@ export async function main() {
             isOwner: input.isOwner,
         });
     }
-    function closeSession(conversationId) {
+    function closeSession(conversationId, options = {}) {
         const session = sessions.get(conversationId);
         if (!session)
             return;
+        const saveResume = options.saveResume !== false;
         session.closed = true;
         if (session.typingKeepaliveTimer) {
             clearInterval(session.typingKeepaliveTimer);
             session.typingKeepaliveTimer = null;
         }
         releaseConversationEnvironment(session.environment);
-        // Save SDK session ID for future resume
-        if (session.sdkSessionId) {
-            savedSessionIds.set(buildConversationEnvironmentKey(conversationId, session.environment.baseCwd), session.sdkSessionId);
+        const resumeKey = buildConversationEnvironmentKey(conversationId, session.environment.baseCwd);
+        if (saveResume && session.sdkSessionId) {
+            savedSessionIds.set(resumeKey, session.sdkSessionId);
             saveRuntimeSessionState(runtimeId, {
                 conversationId,
                 baseCwd: session.environment.baseCwd,
@@ -1590,6 +1577,27 @@ export async function main() {
                 claudeSessionId: session.sdkSessionId,
             });
         }
+        else {
+            const existingState = loadRuntimeSessionState(runtimeId, {
+                conversationId,
+                baseCwd: session.environment.baseCwd,
+                executionMode: session.environment.mode,
+            });
+            savedSessionIds.delete(resumeKey);
+            clearRuntimeSessionState(runtimeId, {
+                conversationId,
+                baseCwd: session.environment.baseCwd,
+                executionMode: session.environment.mode,
+            });
+            if (existingState?.lastInboundMessageId) {
+                saveRuntimeSessionState(runtimeId, {
+                    conversationId,
+                    baseCwd: session.environment.baseCwd,
+                    executionMode: session.environment.mode,
+                    lastInboundMessageId: existingState.lastInboundMessageId,
+                });
+            }
+        }
         if (session.streamingTimer)
             clearTimeout(session.streamingTimer);
         session.streamingText = '';
@@ -1610,7 +1618,22 @@ export async function main() {
         }
         catch { }
         sessions.delete(conversationId);
-        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session suspended (sessionId saved for resume)`);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${options.reason ?? (saveResume ? 'suspended (sessionId saved for resume)' : 'cleared')}`);
+    }
+    async function resetRuntimeSession(session) {
+        const conversationId = session.conversationId;
+        const droppedInputs = session.pendingInputs.splice(0);
+        await markSessionPendingInputsRejected(conversationId, droppedInputs);
+        if (session.activeInput) {
+            session.interruptedTurnKeys.add(session.activeInput.turnKey);
+        }
+        session.pendingFinalText = null;
+        session.pendingFinalDelivery = null;
+        session.turnState = 'interrupted';
+        if (session.state.state === 'running') {
+            await session.query.interrupt().catch(() => { });
+        }
+        closeSession(conversationId, { saveResume: false, reason: 'reset for new Canon session' });
     }
     async function markSessionPendingInputsRejected(conversationId, inputs) {
         await Promise.all(inputs.map((input) => {
@@ -2054,10 +2077,17 @@ export async function main() {
                     if (sig && typeof sig === 'object') {
                         const s = sig;
                         const ts = s.updatedAt ?? 0;
-                        if ((s.type === 'interrupt' || s.type === 'stop_and_drop') && ts > (lastSeenSignal.get(convoId) ?? 0)) {
+                        if ((s.type === 'interrupt' || s.type === 'stop_and_drop' || s.type === 'new_session')
+                            && ts > (lastSeenSignal.get(convoId) ?? 0)) {
                             lastSeenSignal.set(convoId, ts);
                             const session = sessions.get(convoId);
                             if (session && !session.closed) {
+                                if (s.type === 'new_session') {
+                                    console.error(`[canon-host] [${convoId.slice(0, 8)}] new_session signal`);
+                                    await resetRuntimeSession(session);
+                                    await rtdbWrite(`/control/${convoId}/${agentId}/signal`, null).catch(() => { });
+                                    continue;
+                                }
                                 const isActive = session.state.state === 'running';
                                 if (!isActive && (s.type !== 'stop_and_drop' || session.pendingInputs.length === 0)) {
                                     await rtdbWrite(`/control/${convoId}/${agentId}/signal`, null).catch(() => { });

package/dist/session-state.d.ts

@@ -1,5 +1,5 @@
 import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
-import type { DeliveryIntent, ModelOption } from '@canonmsg/core';
+import type { DeliveryIntent, ModelOption, TurnLifecycleState } from '@canonmsg/core';
 export type ClaudeInputKind = 'seed' | 'canon';
 export interface ClaudeInputEnvelope {
     kind: ClaudeInputKind;
@@ -19,6 +19,19 @@ export interface ClaudePendingFinalDelivery {
     text: string;
     messageId: string;
 }
+export interface ClaudeCompletedTurnState {
+    state: {
+        state?: 'idle' | 'running' | 'requires_action';
+    };
+    pendingFinalText: string | null;
+    pendingFinalDelivery: ClaudePendingFinalDelivery | null;
+    activeInput: ClaudeInputEnvelope | null;
+    toolInProgress: boolean;
+    turnState: TurnLifecycleState;
+    currentTurnId: string | null;
+    currentTurnOpenedAt: number | null;
+    lastAcceptedIntent: DeliveryIntent | null;
+}
 export declare function createClaudeInputEnvelope(input: {
     kind: ClaudeInputKind;
     msg: SDKUserMessage;
@@ -36,6 +49,7 @@ export declare function shouldDeliverClaudeFinal(input: {
     finalizedTurnKeys: ReadonlySet<string>;
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
+export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
 export declare function mergeClaudeModelOptions(input: {
     previous: ReadonlyArray<ModelOption>;
     next: ReadonlyArray<ModelOption>;

package/dist/session-state.js

@@ -29,6 +29,17 @@ export function shouldDeliverClaudeFinal(input) {
         return false;
     return true;
 }
+export function resetClaudeCompletedTurnState(session) {
+    session.state.state = 'idle';
+    session.currentTurnId = null;
+    session.currentTurnOpenedAt = null;
+    session.lastAcceptedIntent = null;
+    session.pendingFinalText = null;
+    session.pendingFinalDelivery = null;
+    session.activeInput = null;
+    session.toolInProgress = false;
+    session.turnState = 'idle';
+}
 export function mergeClaudeModelOptions(input) {
     const byValue = new Map();
     for (const option of input.previous) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.12.8",
+  "version": "0.13.1",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.101",
-    "@canonmsg/agent-sdk": "^1.1.4",
-    "@canonmsg/core": "^0.15.4",
+    "@canonmsg/agent-sdk": "^1.2.1",
+    "@canonmsg/core": "^0.16.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {