@canonmsg/claude-code-plugin 0.4.0 → 0.6.0

package/dist/host.js

@@ -23,33 +23,12 @@ setDefaultResultOrder('ipv4first');
  */
 import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
-import { basename, resolve } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { CanonClient, CanonStream, clearTurnState, DEFAULT_RUNTIME_CAPABILITIES, normalizeTurnMetadata, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, } from '@canonmsg/core';
+import { buildParticipationHistorySnapshot, buildBehaviorPolicyLines, buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildPublicWorkspaceOptions, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, CanonClient, CanonStream, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, releaseConversationEnvironment, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let runtimeModels = [];
-function normalizeString(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-}
-function buildWorkspaceOptions(primaryCwd, configured) {
-    const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
-    const seenLabels = new Map();
-    return uniqueDirs.map((cwd, index) => {
-        const baseLabel = basename(cwd) || cwd;
-        const seenCount = (seenLabels.get(baseLabel) ?? 0) + 1;
-        seenLabels.set(baseLabel, seenCount);
-        return {
-            id: index === 0 ? 'default' : `workspace-${index + 1}`,
-            label: seenCount === 1 ? baseLabel : `${baseLabel} (${seenCount})`,
-            cwd,
-        };
-    });
-}
 function toModelOptions(models) {
     return models.map((model) => ({
         value: model.value,
@@ -66,32 +45,22 @@ async function publishAgentRuntime(agentId, runtime) {
 }
 async function loadSessionConfig(conversationId, agentId) {
     const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
+    const baseConfig = readSessionWorkspaceConfig(raw);
     if (!raw || typeof raw !== 'object')
-        return null;
+        return baseConfig;
     const data = raw;
-    const permissionMode = normalizeString(data.permissionMode);
+    const permissionMode = normalizeOptionalString(data.permissionMode);
     return {
-        workspaceId: normalizeString(data.workspaceId),
-        legacyCwd: normalizeString(data.cwd),
-        model: normalizeString(data.model),
+        ...baseConfig,
         permissionMode: permissionMode,
     };
 }
 function resolveWorkspaceCwd(config) {
-    if (config?.workspaceId) {
-        const workspace = workspaceOptions.find((option) => option.id === config.workspaceId);
-        if (workspace)
-            return workspace.cwd;
-    }
-    if (config?.legacyCwd) {
-        const workspace = workspaceOptions.find((option) => option.cwd === config.legacyCwd);
-        if (workspace)
-            return workspace.cwd;
-    }
-    return workspaceOptions[0]?.cwd ?? workingDir;
-}
-function toPublicWorkspaceOptions() {
-    return workspaceOptions.map(({ id, label }) => ({ id, label }));
+    return resolveConfiguredWorkspaceCwd({
+        workspaceOptions,
+        config,
+        defaultCwd: workingDir,
+    });
 }
 async function detectRuntimeModels(cwd) {
     const emptyPrompt = {
@@ -125,24 +94,24 @@ const STREAMING_THROTTLE_MS = 250;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2000;
-const COMPLETED_STATE_HOLD_MS = 750;
+const FINAL_DELIVERY_RETRY_MS = 2_000;
 const CLAUDE_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
     supportsQueue: true,
     supportsInterleave: true,
     supportsRequiresAction: true,
-    supportsNonFinalPermanentMessages: true,
+    supportsNonFinalPermanentMessages: false,
 };
 function buildCanonPrompt(input) {
     return [
         'You are connected to Canon messaging through a Claude Code host wrapper.',
-        'Reply naturally to Canon participants.',
         'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
         'Short intermediate assistant messages may be shown as ephemeral status while you work.',
         ...buildInboundContextLines(input.participantContext),
+        ...buildBehaviorPolicyLines(input.behavior),
         'Canon participants may be humans or AI agents.',
-        'If the latest message came from another AI agent, avoid agent-only ping-pong and only reply when directly addressed, when a human is clearly steering, or when a reply is genuinely necessary.',
+        'Honor the Canon behavior policy above when deciding how proactively to participate.',
         `Conversation ID: ${input.conversationId}`,
         '',
         'New Canon message:',
@@ -183,7 +152,8 @@ function renderInboundContent(message) {
     return content || '[Empty message]';
 }
 // ── Session factory ─────────────────────────────────────────────────
-function createSession(conversationId, cwd, agentId, client, onSessionEnd, config, resumeSessionId) {
+function createSession(conversationId, environment, agentId, client, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
+    const { cwd } = environment;
     // Per-session input stream with message queue
     let resolveInput = null;
     let inputDone = false;
@@ -315,6 +285,7 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
     session = {
         conversationId,
         cwd,
+        environment,
         query: q,
         sendInput,
         enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted),
@@ -327,9 +298,11 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         streamingText: '',
         streamingTimer: null,
         idleResetTimer: null,
+        finalDeliveryTimer: null,
         seedResponseHandled: !!resumeSessionId, // Resumed sessions don't need seed handling
         pendingInputs: [],
         pendingFinalText: null,
+        pendingFinalDeliveryText: null,
         toolInProgress: false,
         turnState: 'idle',
         currentTurnId: null,
@@ -373,30 +346,92 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         clearTimeout(session.idleResetTimer);
         session.idleResetTimer = null;
     }
+    function clearFinalDeliveryTimer() {
+        if (!session.finalDeliveryTimer)
+            return;
+        clearTimeout(session.finalDeliveryTimer);
+        session.finalDeliveryTimer = null;
+    }
     function resetTurnToIdle() {
         if (session.closed)
             return;
+        clearFinalDeliveryTimer();
         session.currentTurnId = null;
         session.currentTurnOpenedAt = null;
         session.lastAcceptedIntent = null;
         session.pendingFinalText = null;
+        session.pendingFinalDeliveryText = null;
         session.toolInProgress = false;
         session.turnState = 'idle';
         writeTurn();
         drainPendingInput();
     }
-    function scheduleIdleTurnReset() {
+    function scheduleFinalHandoffReset() {
         clearIdleResetTimer();
         session.idleResetTimer = setTimeout(() => {
             session.idleResetTimer = null;
+            client.setTyping(conversationId, false).catch(() => { });
+            clearStreaming();
             resetTurnToIdle();
-        }, COMPLETED_STATE_HOLD_MS);
+        }, FINAL_MESSAGE_HANDOFF_MS);
+    }
+    function markPendingFinalDelivery(finalText) {
+        clearIdleResetTimer();
+        session.pendingFinalText = finalText;
+        session.pendingFinalDeliveryText = finalText;
+        session.state.state = 'running';
+        session.turnState = 'streaming';
+        session.streamingText = finalText;
+        flushStreaming();
+        writeState();
+        writeTurn();
+        client.setTyping(conversationId, true, 'typing').catch(() => { });
+    }
+    async function deliverFinalReply(finalText) {
+        try {
+            await client.sendMessage(conversationId, finalText, {
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            });
+            session.state.state = 'idle';
+            session.pendingFinalDeliveryText = null;
+            clearFinalDeliveryTimer();
+            writeState();
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars)`);
+            return true;
+        }
+        catch (err) {
+            markPendingFinalDelivery(finalText);
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send final reply:`, err);
+            return false;
+        }
+    }
+    function scheduleFinalDeliveryRetry(finalText) {
+        if (session.closed || session.pendingFinalDeliveryText !== finalText)
+            return;
+        clearFinalDeliveryTimer();
+        session.finalDeliveryTimer = setTimeout(() => {
+            session.finalDeliveryTimer = null;
+            void deliverFinalReply(finalText).then((sent) => {
+                if (sent) {
+                    scheduleFinalHandoffReset();
+                    return;
+                }
+                scheduleFinalDeliveryRetry(finalText);
+            });
+        }, FINAL_DELIVERY_RETRY_MS);
     }
     function writeState() {
         writeSessionState(conversationId, agentId, {
             ...session.state,
             ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
             cwd,
+            executionMode: session.environment.mode,
+            ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
             hostMode: true,
             isActive: true,
         }).catch(() => { });
@@ -433,6 +468,11 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
     }
     enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false) => {
         session.lastActivity = Date.now();
+        if (session.pendingFinalDeliveryText) {
+            session.pendingInputs.push({ msg, intent, sourceMessageId, markAccepted });
+            writeTurn();
+            return;
+        }
         if (session.state.state === 'running' && intent !== 'interrupt') {
             session.pendingInputs.push({ msg, intent, sourceMessageId, markAccepted });
             writeTurn();
@@ -471,7 +511,6 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             .filter((b) => b.type === 'text')
                             .map((b) => b.text);
                         const fullText = textBlocks.join('\n').trim();
-                        clearStreaming();
                         if (fullText) {
                             session.pendingFinalText = fullText;
                         }
@@ -510,18 +549,14 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                                     session.currentTurnId = randomUUID();
                                     session.currentTurnOpenedAt = Date.now();
                                 }
+                                session.state.contextUsage = undefined;
                                 session.pendingFinalText = null;
                                 session.toolInProgress = false;
                                 session.turnState = 'thinking';
                                 client.setTyping(conversationId, true, 'thinking').catch(() => { });
                             }
                             else if (state === 'idle') {
-                                clearIdleResetTimer();
-                                session.turnState = 'completed';
                                 client.setTyping(conversationId, false).catch(() => { });
-                                clearStreaming();
-                                writeTurn();
-                                scheduleIdleTurnReset();
                             }
                             else if (state === 'requires_action') {
                                 clearIdleResetTimer();
@@ -548,42 +583,25 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             ? msg.result.trim()
                             : '';
                         const finalText = resultText || session.pendingFinalText?.trim() || null;
-                        if (finalText) {
-                            try {
-                                await client.sendMessage(conversationId, finalText, {
-                                    metadata: {
-                                        turnId: session.currentTurnId,
-                                        turnSemantics: 'turn_complete',
-                                        turnComplete: true,
-                                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                                    },
-                                });
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars)`);
-                            }
-                            catch (err) {
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send final reply:`, err);
-                            }
-                        }
+                        const finalDelivered = finalText ? await deliverFinalReply(finalText) : true;
                         try {
                             const usage = await q.getContextUsage();
-                            writeSessionState(conversationId, agentId, {
-                                ...session.state,
-                                state: 'idle',
-                                contextUsage: {
-                                    percentage: usage.percentage,
-                                    totalTokens: usage.totalTokens,
-                                    maxTokens: usage.maxTokens,
-                                },
-                                cwd,
-                                hostMode: true,
-                                isActive: true,
-                            }).catch(() => { });
+                            session.state.contextUsage = {
+                                percentage: usage.percentage,
+                                totalTokens: usage.totalTokens,
+                                maxTokens: usage.maxTokens,
+                            };
+                            session.state.state = finalDelivered ? 'idle' : session.state.state;
+                            writeState();
                         }
                         catch {
                             // Non-fatal
                         }
-                        if (session.state.state !== 'running' && !session.idleResetTimer) {
-                            drainPendingInput();
+                        if (finalDelivered) {
+                            scheduleFinalHandoffReset();
+                        }
+                        else if (finalText) {
+                            scheduleFinalDeliveryRetry(finalText);
                         }
                         break;
                     }
@@ -620,7 +638,7 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                 type: 'user',
                 message: {
                     role: 'user',
-                    content: 'You are connected to Canon messaging. Messages from users will arrive as follow-up messages. Respond naturally — your text responses will be sent back to the conversation. You have full Claude Code capabilities (file read/write, bash, etc).',
+                    content: 'You are connected to Canon messaging. Follow-up messages in this session come from Canon participants, and your text responses will be sent back to the conversation. You have full Claude Code capabilities (file read/write, bash, etc).',
                 },
                 parent_tool_use_id: null,
             });
@@ -631,17 +649,19 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
             const modelList = toModelOptions(models);
             session.availableModels = modelList;
             runtimeModels = modelList;
-            await publishAgentRuntime(agentId, {
+            onRuntimeDescriptorUpdate({
                 defaultWorkspaceId: workspaceOptions[0]?.id,
                 defaultModel: session.state.model ?? modelList[0]?.value,
                 defaultPermissionMode: 'default',
                 availableModels: modelList,
-                availableWorkspaces: toPublicWorkspaceOptions(),
-            }).catch(() => { });
+                availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+            });
             writeSessionState(conversationId, agentId, {
                 ...session.state,
                 availableModels: modelList,
                 cwd,
+                executionMode: session.environment.mode,
+                ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
@@ -650,7 +670,8 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         catch {
             writeState();
         }
-        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${resumeSessionId ? 'resumed' : 'started'} (cwd: ${cwd})`);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${resumeSessionId ? 'resumed' : 'started'} `
+            + `(mode: ${environment.mode}, cwd: ${cwd})`);
     };
     init().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] Init failed:`, err));
     return session;
@@ -661,12 +682,17 @@ async function main() {
         options: {
             cwd: { type: 'string' },
             workspace: { type: 'string', multiple: true },
+            'enable-worktrees': { type: 'boolean' },
         },
         strict: false,
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const configuredWorkspaces = (args.workspace ?? []).filter((value) => typeof value === 'string');
-    workspaceOptions = buildWorkspaceOptions(workingDir, configuredWorkspaces);
+    workspaceOptions = buildConfiguredWorkspaceOptions(workingDir, configuredWorkspaces);
+    const allowWorktrees = isEnabledFlag(args['enable-worktrees'] ?? process.env.CANON_ENABLE_WORKTREES);
+    if (!allowWorktrees) {
+        console.error('[canon-host] Worktree isolation is disabled; sessions will lock their selected workspace unless explicitly enabled.');
+    }
     const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-host]' });
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     // ── Canon API client + RTDB auth ──
@@ -690,19 +716,36 @@ async function main() {
         }
         console.error(`[canon-host] Authenticated as ${agentId}`);
     }
+    let streamConnected = false;
+    let runtimeDescriptor = {
+        defaultWorkspaceId: workspaceOptions[0]?.id,
+        defaultPermissionMode: 'default',
+        availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+    };
+    const publishRuntimeHeartbeat = async () => {
+        if (!streamConnected)
+            return;
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+            console.error('[canon-host] Failed to publish agent runtime:', error);
+        });
+    };
     // ── Load conversations (informational — sessions created on demand) ──
     try {
         runtimeModels = await detectRuntimeModels(workingDir);
-        await publishAgentRuntime(agentId, {
+        runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availableModels: runtimeModels,
-            availableWorkspaces: toPublicWorkspaceOptions(),
-        });
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
-    catch (error) {
-        console.error('[canon-host] Failed to publish agent runtime:', error);
+    catch {
+        runtimeDescriptor = {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            defaultPermissionMode: 'default',
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
     try {
         const convos = await client.getConversations();
@@ -714,7 +757,7 @@ async function main() {
     // ── Session manager ──
     const sessions = new Map();
     const pendingSessionCreations = new Map();
-    /** Saved SDK session IDs for resume after idle eviction */
+    /** Saved SDK session IDs for resume after idle eviction, keyed by conversation + workspace */
     const savedSessionIds = new Map();
     const conversationCache = new Map();
     let conversationCacheLoadedAt = 0;
@@ -745,17 +788,9 @@ async function main() {
     async function loadParticipantContext(input) {
         const [conversation, recentMessages] = await Promise.all([
             getConversationMeta(input.conversationId),
-            client.getMessages(input.conversationId, 6).catch(() => []),
+            client.getMessages(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => []),
         ]);
-        const recentSenderTypes = recentMessages
-            .filter((message) => message.senderId !== agentId)
-            .map((message) => message.senderType);
-        let consecutiveAgentTurns = 0;
-        for (const senderType of recentSenderTypes) {
-            if (senderType !== 'ai_agent')
-                break;
-            consecutiveAgentTurns += 1;
-        }
+        const history = buildParticipationHistorySnapshot(recentMessages, agentId);
         return {
             conversationType: conversation?.type ?? 'unknown',
             memberCount: conversation?.memberIds?.length ?? null,
@@ -763,10 +798,11 @@ async function main() {
             senderName: input.senderName,
             isOwner: input.isOwner,
             mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
-            recentSenderTypes,
-            recentHumanCount: recentSenderTypes.filter((senderType) => senderType === 'human').length,
-            recentAgentCount: recentSenderTypes.filter((senderType) => senderType === 'ai_agent').length,
-            consecutiveAgentTurns,
+            recentSenderTypes: history.recentSenderTypes,
+            recentHumanCount: history.recentHumanCount,
+            recentAgentCount: history.recentAgentCount,
+            consecutiveAgentTurns: history.consecutiveAgentTurns,
+            currentAgentStreakStartedByHuman: history.currentAgentStreakStartedByHuman,
         };
     }
     function closeSession(conversationId) {
@@ -774,9 +810,10 @@ async function main() {
         if (!session)
             return;
         session.closed = true;
+        releaseConversationEnvironment(session.environment);
         // Save SDK session ID for future resume
         if (session.sdkSessionId) {
-            savedSessionIds.set(conversationId, session.sdkSessionId);
+            savedSessionIds.set(buildConversationEnvironmentKey(conversationId, session.environment.baseCwd), session.sdkSessionId);
         }
         if (session.streamingTimer)
             clearTimeout(session.streamingTimer);
@@ -784,6 +821,10 @@ async function main() {
             clearTimeout(session.idleResetTimer);
             session.idleResetTimer = null;
         }
+        if (session.finalDeliveryTimer) {
+            clearTimeout(session.finalDeliveryTimer);
+            session.finalDeliveryTimer = null;
+        }
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
         clearSessionState(conversationId, agentId).catch(() => { });
         clearTurnState(conversationId, agentId).catch(() => { });
@@ -823,21 +864,43 @@ async function main() {
         }
         const creation = (async () => {
             const config = await loadSessionConfig(conversationId, agentId);
-            const resumeId = savedSessionIds.get(conversationId);
-            const session = createSession(conversationId, resolveWorkspaceCwd(config), agentId, client, (convoId, sdkSessionId) => {
-                // Called when session processing loop ends — save session ID for resume
-                if (sdkSessionId)
-                    savedSessionIds.set(convoId, sdkSessionId);
-                sessions.delete(convoId);
-                clearSessionState(convoId, agentId).catch(() => { });
-                clearTurnState(convoId, agentId).catch(() => { });
-            }, {
-                model: config?.model ?? runtimeModels[0]?.value,
-                permissionMode: config?.permissionMode ?? 'default',
-                availableModels: runtimeModels,
-            }, resumeId);
-            sessions.set(conversationId, session);
-            return session;
+            const workspaceCwd = resolveWorkspaceCwd(config);
+            const environment = prepareConversationEnvironment({
+                agentId,
+                conversationId,
+                workspaceCwd,
+                allowWorktrees,
+            });
+            try {
+                const resumeKey = buildConversationEnvironmentKey(conversationId, environment.baseCwd);
+                const resumeId = savedSessionIds.get(resumeKey);
+                const session = createSession(conversationId, environment, agentId, client, (convoId, sdkSessionId) => {
+                    // Called when session processing loop ends — save session ID for resume
+                    const existing = sessions.get(convoId);
+                    if (existing) {
+                        releaseConversationEnvironment(existing.environment);
+                        if (sdkSessionId) {
+                            savedSessionIds.set(buildConversationEnvironmentKey(convoId, existing.environment.baseCwd), sdkSessionId);
+                        }
+                    }
+                    sessions.delete(convoId);
+                    clearSessionState(convoId, agentId).catch(() => { });
+                    clearTurnState(convoId, agentId).catch(() => { });
+                }, (descriptor) => {
+                    runtimeDescriptor = descriptor;
+                    void publishRuntimeHeartbeat();
+                }, {
+                    model: config?.model ?? runtimeModels[0]?.value,
+                    permissionMode: config?.permissionMode ?? 'default',
+                    availableModels: runtimeModels,
+                }, resumeId);
+                sessions.set(conversationId, session);
+                return session;
+            }
+            catch (error) {
+                releaseConversationEnvironment(environment);
+                throw error;
+            }
         })();
         pendingSessionCreations.set(conversationId, creation);
         try {
@@ -873,19 +936,31 @@ async function main() {
                 const content = renderInboundContent(m);
                 const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
                 void (async () => {
+                    const conversation = await getConversationMeta(convoId);
+                    const behavior = payload.behavior ?? conversation?.behavior;
                     const participantContext = await loadParticipantContext({
                         conversationId: convoId,
                         message: m,
                         senderName: sender,
                         isOwner,
                     });
-                    const autoReply = decideAutoReply(participantContext);
+                    const autoReply = decideAutoReply(participantContext, behavior);
                     if (!autoReply.allow) {
                         console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
                         return;
                     }
                     console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
-                    const session = await getOrCreateSession(convoId);
+                    let session;
+                    try {
+                        session = await getOrCreateSession(convoId);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to create session: ${message}`);
+                        await client.sendMessage(convoId, `I couldn't start a coding session for this workspace: ${userMessage}`).catch(() => { });
+                        return;
+                    }
                     const turnMetadata = normalizeTurnMetadata(m.metadata);
                     const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
                     const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
@@ -897,14 +972,23 @@ async function main() {
                                 content,
                                 conversationId: convoId,
                                 participantContext,
+                                behavior,
                             }),
                         },
                         parent_tool_use_id: null,
                     }, deliveryIntent, m.id ?? null, shouldMarkAccepted);
                 })();
             },
-            onConnected: () => console.error('[canon-host] SSE connected'),
-            onDisconnected: () => console.error('[canon-host] SSE disconnected'),
+            onConnected: () => {
+                streamConnected = true;
+                void publishRuntimeHeartbeat();
+                console.error('[canon-host] SSE connected');
+            },
+            onDisconnected: () => {
+                streamConnected = false;
+                rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+                console.error('[canon-host] SSE disconnected');
+            },
             onError: (err) => console.error(`[canon-host] SSE error: ${err.message}`),
         },
     });
@@ -960,6 +1044,8 @@ async function main() {
                                     ...session.state,
                                     ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
                                     cwd: session.cwd,
+                                    executionMode: session.environment.mode,
+                                    ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                                     hostMode: true,
                                     isActive: true,
                                 }).catch(() => { });
@@ -1019,6 +1105,8 @@ async function main() {
                 ...session.state,
                 ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
                 cwd: session.cwd,
+                executionMode: session.environment.mode,
+                ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
@@ -1035,6 +1123,7 @@ async function main() {
                     : {}),
             }).catch(() => { });
         }
+        void publishRuntimeHeartbeat();
     }, HEARTBEAT_MS);
     // ── Idle session cleanup ──
     const idleCheck = setInterval(() => {
@@ -1056,6 +1145,7 @@ async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
+        await rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
         for (const convoId of [...sessions.keys()]) {
             closeSession(convoId);
         }

package/dist/inbound-policy.d.ts

@@ -1,4 +1,4 @@
-import type { CanonConversation } from '@canonmsg/core';
+import { type CanonConversation, type ResolvedAgentBehaviorPolicy } from '@canonmsg/core';
 export interface InboundParticipantContext {
     conversationType: CanonConversation['type'] | 'unknown';
     memberCount: number | null;
@@ -10,10 +10,11 @@ export interface InboundParticipantContext {
     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): AutoReplyDecision;
+export declare function decideAutoReply(context: InboundParticipantContext, behavior?: ResolvedAgentBehaviorPolicy | null): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -1,3 +1,4 @@
+import { evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
 function formatRecentSenders(senderTypes) {
     if (senderTypes.length === 0)
         return 'none';
@@ -22,29 +23,21 @@ export function buildInboundContextLines(context) {
         `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) {
-    if (context.senderType !== 'ai_agent') {
-        return { allow: true, reason: 'latest sender is human' };
-    }
-    if (context.isOwner) {
-        return { allow: true, reason: 'owner messages always pass through' };
-    }
-    if (context.mentionedAgent) {
-        return { allow: true, reason: 'another agent explicitly addressed this agent' };
-    }
-    if (context.conversationType === 'group') {
-        return {
-            allow: false,
-            reason: 'suppressing group agent auto-reply without a direct mention',
-        };
-    }
-    if (context.consecutiveAgentTurns >= 2 && context.recentHumanCount === 0) {
-        return {
-            allow: false,
-            reason: 'suppressing likely agent-only loop in a direct conversation',
-        };
-    }
-    return { allow: true, reason: 'direct agent message allowed' };
+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/register.js

@@ -33,6 +33,14 @@ if (!values.name || !values.description || !values.phone) {
 }
 // Default profile name: sanitized agent name
 const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+let existingAgentId;
+try {
+    const profiles = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+    existingAgentId = profiles[profileName]?.agentId;
+}
+catch {
+    // File doesn't exist yet
+}
 console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
 const result = await registerAndWaitForApproval({
     name: values.name,
@@ -41,6 +49,7 @@ const result = await registerAndWaitForApproval({
     developerInfo: 'Claude Code plugin',
     clientType: 'claude-code',
     baseUrl: values['base-url'],
+    requestedAgentId: existingAgentId,
 }, {
     onSubmitted: (requestId) => {
         console.log(`Registration submitted (request ID: ${requestId}).`);

package/dist/server.js

@@ -325,6 +325,18 @@ async function handleInboundMessage(payload) {
         content_type: m.contentType || 'text',
         ts: new Date().toISOString(),
     };
+    if (payload.behavior) {
+        meta.behavior_style = payload.behavior.participation.style;
+        meta.behavior_allow_agent_to_agent = String(payload.behavior.participation.allowAgentToAgent);
+        meta.behavior_allow_long_running = String(payload.behavior.participation.allowLongRunningCollaboration);
+        meta.behavior_require_group_mention = String(payload.behavior.participation.requireMentionForGroupReplies);
+        if (payload.behavior.participation.maxConsecutiveAgentTurns != null) {
+            meta.behavior_max_consecutive_agent_turns = String(payload.behavior.participation.maxConsecutiveAgentTurns);
+        }
+        if (payload.behavior.instructions.length > 0) {
+            meta.behavior_instructions = payload.behavior.instructions.join('\n\n');
+        }
+    }
     const primaryAttachment = getPrimaryAttachment(m);
     if (m.imageUrl)
         meta.image_url = m.imageUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/server.js",
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.101",
-    "@canonmsg/core": "^0.3.0",
+    "@canonmsg/core": "^0.5.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {