@canonmsg/claude-code-plugin 0.3.0

package/dist/host.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+import { setDefaultResultOrder } from 'node:dns';
+setDefaultResultOrder('ipv4first');
+/**
+ * Canon Agent SDK host wrapper — multi-session.
+ *
+ * Each Canon conversation gets its own Claude Code session (SDK Query subprocess).
+ * Sessions are created lazily on first inbound message and cleaned up after idle timeout.
+ *
+ * - Inbound Canon messages (SSE) → routed to per-conversation session
+ * - Claude responses (SDK iterator) → sendMessage() to the correct conversation
+ * - Live streaming → RTDB /streaming/{convoId}/{agentId}
+ * - Session state (model, mode, activity) → RTDB /session-state/{convoId}/{agentId}
+ * - Control signals (model switch, interrupt) ← RTDB /control/{convoId}/{agentId}
+ *
+ * Auth: uses forceLoginMethod: 'claudeai' — works with Max/Pro subscription.
+ *
+ * Usage:
+ *   canon-claude                       # auto-select agent profile
+ *   canon-claude --cwd /path/to/project # specify working directory
+ *   CANON_AGENT=mybot canon-claude     # use specific profile
+ *   CANON_API_KEY=agk_... canon-claude # use explicit key
+ */
+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, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, } from '@canonmsg/core';
+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,
+        label: model.displayName,
+    }));
+}
+async function publishAgentRuntime(agentId, runtime) {
+    await rtdbWrite(`/agent-runtime/${agentId}`, {
+        clientType: 'claude-code',
+        hostMode: true,
+        ...runtime,
+        updatedAt: { '.sv': 'timestamp' },
+    });
+}
+async function loadSessionConfig(conversationId, agentId) {
+    const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const data = raw;
+    const permissionMode = normalizeString(data.permissionMode);
+    return {
+        workspaceId: normalizeString(data.workspaceId),
+        legacyCwd: normalizeString(data.cwd),
+        model: normalizeString(data.model),
+        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 }));
+}
+async function detectRuntimeModels(cwd) {
+    const emptyPrompt = {
+        async *[Symbol.asyncIterator]() { },
+    };
+    const probe = query({
+        prompt: emptyPrompt,
+        options: {
+            systemPrompt: { type: 'preset', preset: 'claude_code' },
+            tools: { type: 'preset', preset: 'claude_code' },
+            permissionMode: 'default',
+            cwd,
+            settings: { forceLoginMethod: 'claudeai' },
+        },
+    });
+    try {
+        const init = await probe.initializationResult();
+        return toModelOptions(init.models);
+    }
+    finally {
+        try {
+            probe.close();
+        }
+        catch { }
+    }
+}
+// ── Constants ───────────────────────────────────────────────────────
+const MAX_SESSIONS = 5;
+const IDLE_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+const STREAMING_THROTTLE_MS = 250;
+const HEARTBEAT_MS = 30_000;
+const IDLE_CHECK_MS = 60_000;
+const CONTROL_POLL_MS = 2000;
+function buildCanonPrompt(input) {
+    const ownerLine = input.isOwner
+        ? 'The sender is the verified human owner of this Canon agent.'
+        : 'The sender is a Canon user in this conversation.';
+    return [
+        'You are connected to Canon messaging through a Claude Code host wrapper.',
+        'Reply naturally to the Canon user.',
+        '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.',
+        ownerLine,
+        `Conversation ID: ${input.conversationId}`,
+        `Sender: ${input.senderName}`,
+        '',
+        'New Canon message:',
+        input.content,
+    ].join('\n');
+}
+function renderInboundContent(message) {
+    let content = message.text || '';
+    if (message.contentType === 'audio' && message.audioUrl) {
+        const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
+            : `[Voice message${duration}: ${message.audioUrl}]`;
+    }
+    else if (message.contentType === 'image' && message.imageUrl) {
+        content = content
+            ? `[Image: ${message.imageUrl}]\n${content}`
+            : `[Image: ${message.imageUrl}]`;
+    }
+    return content || '[Empty message]';
+}
+// ── Session factory ─────────────────────────────────────────────────
+function createSession(conversationId, cwd, agentId, client, onSessionEnd, config, resumeSessionId) {
+    // Per-session input stream with message queue
+    let resolveInput = null;
+    let inputDone = false;
+    const messageQueue = [];
+    const sendInput = (msg) => {
+        if (resolveInput) {
+            const r = resolveInput;
+            resolveInput = null;
+            r(msg);
+        }
+        else {
+            // Queue if iterator isn't waiting yet (e.g., during init)
+            messageQueue.push(msg);
+        }
+    };
+    const inputStream = {
+        [Symbol.asyncIterator]() {
+            return {
+                next() {
+                    if (inputDone)
+                        return Promise.resolve({ done: true, value: undefined });
+                    // Drain queued messages first (sent before iterator was ready)
+                    if (messageQueue.length > 0) {
+                        return Promise.resolve({ done: false, value: messageQueue.shift() });
+                    }
+                    return new Promise((resolve) => {
+                        resolveInput = (msg) => resolve({ done: false, value: msg });
+                    });
+                },
+                return() {
+                    inputDone = true;
+                    return Promise.resolve({ done: true, value: undefined });
+                },
+            };
+        },
+    };
+    // Launch Claude Code subprocess
+    // eslint-disable-next-line prefer-const -- session must be declared before queryOptions but assigned after query()
+    let session;
+    const REPLY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+    function waitForReply() {
+        // Keep session alive while waiting for user input
+        session.lastActivity = Date.now();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                session.pendingReply = null;
+                reject(new Error('Timed out waiting for user reply'));
+            }, REPLY_TIMEOUT_MS);
+            session.pendingReply = {
+                resolve: (metadata) => {
+                    clearTimeout(timer);
+                    resolve(metadata);
+                },
+            };
+        });
+    }
+    const queryOptions = {
+        systemPrompt: { type: 'preset', preset: 'claude_code' },
+        tools: { type: 'preset', preset: 'claude_code' },
+        permissionMode: config.permissionMode,
+        cwd,
+        includePartialMessages: true,
+        maxTurns: 200,
+        settings: { forceLoginMethod: 'claudeai' },
+        canUseTool: async (toolName, input) => {
+            if (toolName === 'AskUserQuestion') {
+                try {
+                    const questionId = randomUUID();
+                    const questions = input.questions ?? [];
+                    await client.sendMessage(conversationId, '', {
+                        metadata: {
+                            type: 'claude_question',
+                            questionId,
+                            questions,
+                        },
+                    });
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Question sent (${questionId.slice(0, 8)})`);
+                    const reply = await waitForReply();
+                    return {
+                        behavior: 'allow',
+                        updatedInput: { ...input, answers: reply.answers },
+                    };
+                }
+                catch {
+                    return { behavior: 'deny', message: 'No reply received (timed out)' };
+                }
+            }
+            if (toolName === 'ExitPlanMode') {
+                try {
+                    const planId = randomUUID();
+                    await client.sendMessage(conversationId, 'Plan ready for review.', {
+                        metadata: { type: 'plan_approval', planId },
+                    });
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
+                    const reply = await waitForReply();
+                    if (reply.decision === 'approve') {
+                        return { behavior: 'allow' };
+                    }
+                    return {
+                        behavior: 'deny',
+                        message: reply.feedback || 'User requested changes',
+                    };
+                }
+                catch {
+                    return { behavior: 'deny', message: 'No reply received (timed out)' };
+                }
+            }
+            // Default: allow (permission mode handles restrictions)
+            return { behavior: 'allow' };
+        },
+    };
+    if (resumeSessionId) {
+        queryOptions.resume = resumeSessionId;
+    }
+    const q = query({
+        prompt: inputStream,
+        options: queryOptions,
+    });
+    session = {
+        conversationId,
+        cwd,
+        query: q,
+        sendInput,
+        state: {
+            model: config.model,
+            permissionMode: config.permissionMode,
+            state: 'idle',
+        },
+        availableModels: config.availableModels,
+        streamingText: '',
+        streamingTimer: null,
+        seedResponseHandled: !!resumeSessionId, // Resumed sessions don't need seed handling
+        lastActivity: Date.now(),
+        closed: false,
+        sdkSessionId: resumeSessionId || null,
+        pendingReply: null,
+    };
+    // ── Per-session streaming helpers ──
+    function flushStreaming() {
+        if (!session.streamingText)
+            return;
+        rtdbWrite(`/streaming/${conversationId}/${agentId}`, {
+            text: session.streamingText,
+            status: 'streaming',
+            updatedAt: { '.sv': 'timestamp' },
+        }).catch(() => { });
+    }
+    function onStreamDelta(text) {
+        session.streamingText += text;
+        if (!session.streamingTimer) {
+            session.streamingTimer = setTimeout(() => {
+                session.streamingTimer = null;
+                flushStreaming();
+            }, STREAMING_THROTTLE_MS);
+        }
+    }
+    function clearStreaming() {
+        if (session.streamingTimer) {
+            clearTimeout(session.streamingTimer);
+            session.streamingTimer = null;
+        }
+        session.streamingText = '';
+        rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
+    }
+    function writeState() {
+        writeSessionState(conversationId, agentId, {
+            ...session.state,
+            ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
+            cwd,
+            hostMode: true,
+            isActive: true,
+        }).catch(() => { });
+    }
+    // ── Process SDK output messages ──
+    const processMessages = async () => {
+        try {
+            for await (const msg of q) {
+                if (session.closed)
+                    break;
+                switch (msg.type) {
+                    case 'assistant': {
+                        // Capture SDK session ID
+                        const assistantSessionId = msg.session_id;
+                        if (assistantSessionId)
+                            session.sdkSessionId = assistantSessionId;
+                        if (!session.seedResponseHandled) {
+                            session.seedResponseHandled = true;
+                            break;
+                        }
+                        const textBlocks = (msg.message?.content ?? [])
+                            .filter((b) => b.type === 'text')
+                            .map((b) => b.text);
+                        const fullText = textBlocks.join('\n').trim();
+                        clearStreaming();
+                        if (fullText) {
+                            try {
+                                await client.sendMessage(conversationId, fullText);
+                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent reply (${fullText.length} chars)`);
+                            }
+                            catch (err) {
+                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send reply:`, err);
+                            }
+                        }
+                        break;
+                    }
+                    case 'stream_event': {
+                        const event = msg.event;
+                        if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                            onStreamDelta(event.delta.text);
+                        }
+                        break;
+                    }
+                    case 'system': {
+                        const subtype = msg.subtype;
+                        if (subtype === 'session_state_changed') {
+                            const state = msg.state;
+                            session.state.state = state;
+                            if (state === 'running') {
+                                client.setTyping(conversationId, true, 'thinking').catch(() => { });
+                            }
+                            else if (state === 'idle') {
+                                client.setTyping(conversationId, false).catch(() => { });
+                                clearStreaming();
+                            }
+                            else if (state === 'requires_action') {
+                                client.setTyping(conversationId, false).catch(() => { });
+                            }
+                            writeState();
+                        }
+                        break;
+                    }
+                    case 'result': {
+                        // Capture SDK session ID for resume support
+                        const resultSessionId = msg.session_id;
+                        if (resultSessionId)
+                            session.sdkSessionId = resultSessionId;
+                        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn complete (${msg.subtype})`);
+                        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(() => { });
+                        }
+                        catch {
+                            // Non-fatal
+                        }
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Query stream error:`, err);
+        }
+        // Only call onSessionEnd if not already closed (avoids double cleanup from closeSession)
+        if (!session.closed) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ended`);
+            onSessionEnd(conversationId, session.sdkSessionId);
+        }
+    };
+    // Start processing loop and initialize session
+    const init = async () => {
+        processMessages().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] processMessages crashed:`, err));
+        await q.initializationResult();
+        if (config.model) {
+            try {
+                await q.setModel(config.model);
+                session.state.model = config.model;
+            }
+            catch (err) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial model:`, err);
+            }
+        }
+        if (!resumeSessionId) {
+            // New session — send seed message to activate streaming input mode
+            sendInput({
+                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).',
+                },
+                parent_tool_use_id: null,
+            });
+        }
+        // Write available models to session state
+        try {
+            const models = await q.supportedModels();
+            const modelList = toModelOptions(models);
+            session.availableModels = modelList;
+            runtimeModels = modelList;
+            await publishAgentRuntime(agentId, {
+                defaultWorkspaceId: workspaceOptions[0]?.id,
+                defaultModel: session.state.model ?? modelList[0]?.value,
+                defaultPermissionMode: 'default',
+                availableModels: modelList,
+                availableWorkspaces: toPublicWorkspaceOptions(),
+            }).catch(() => { });
+            writeSessionState(conversationId, agentId, {
+                ...session.state,
+                availableModels: modelList,
+                cwd,
+                hostMode: true,
+                isActive: true,
+            }).catch(() => { });
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Models: ${models.map((m) => m.displayName).join(', ')}`);
+        }
+        catch {
+            writeState();
+        }
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${resumeSessionId ? 'resumed' : 'started'} (cwd: ${cwd})`);
+    };
+    init().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] Init failed:`, err));
+    return session;
+}
+// ── Main ────────────────────────────────────────────────────────────
+async function main() {
+    const { values: args } = parseArgs({
+        options: {
+            cwd: { type: 'string' },
+            workspace: { type: 'string', multiple: true },
+        },
+        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);
+    const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-host]' });
+    console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
+    // ── Canon API client + RTDB auth ──
+    const client = new CanonClient(apiKey);
+    initRTDBAuth(client);
+    let agentId;
+    let ownerId = null;
+    try {
+        const ctx = await client.getAgentMe();
+        agentId = ctx.agentId;
+        ownerId = ctx.ownerId;
+        console.error(`[canon-host] Connected as ${ctx.displayName || agentId}`);
+    }
+    catch {
+        if (profileAgentId) {
+            agentId = profileAgentId;
+        }
+        else {
+            const auth = await client.getAuthToken();
+            agentId = auth.agentId;
+        }
+        console.error(`[canon-host] Authenticated as ${agentId}`);
+    }
+    // ── Load conversations (informational — sessions created on demand) ──
+    try {
+        runtimeModels = await detectRuntimeModels(workingDir);
+        await publishAgentRuntime(agentId, {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            defaultModel: runtimeModels[0]?.value,
+            defaultPermissionMode: 'default',
+            availableModels: runtimeModels,
+            availableWorkspaces: toPublicWorkspaceOptions(),
+        });
+    }
+    catch (error) {
+        console.error('[canon-host] Failed to publish agent runtime:', error);
+    }
+    try {
+        const convos = await client.getConversations();
+        console.error(`[canon-host] ${convos.length} conversations`);
+    }
+    catch {
+        console.error('[canon-host] Could not load conversations');
+    }
+    // ── Session manager ──
+    const sessions = new Map();
+    const pendingSessionCreations = new Map();
+    /** Saved SDK session IDs for resume after idle eviction */
+    const savedSessionIds = new Map();
+    function closeSession(conversationId) {
+        const session = sessions.get(conversationId);
+        if (!session)
+            return;
+        session.closed = true;
+        // Save SDK session ID for future resume
+        if (session.sdkSessionId) {
+            savedSessionIds.set(conversationId, session.sdkSessionId);
+        }
+        if (session.streamingTimer)
+            clearTimeout(session.streamingTimer);
+        rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
+        clearSessionState(conversationId, agentId).catch(() => { });
+        client.setTyping(conversationId, false).catch(() => { });
+        try {
+            session.query.close();
+        }
+        catch { }
+        sessions.delete(conversationId);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session suspended (sessionId saved for resume)`);
+    }
+    function evictOldestIdle() {
+        let oldest = null;
+        for (const s of sessions.values()) {
+            if (s.state.state === 'running')
+                continue; // Don't evict running sessions
+            if (!oldest || s.lastActivity < oldest.lastActivity)
+                oldest = s;
+        }
+        if (oldest) {
+            console.error(`[canon-host] [${oldest.conversationId.slice(0, 8)}] Evicting idle session`);
+            closeSession(oldest.conversationId);
+        }
+    }
+    async function getOrCreateSession(conversationId) {
+        const existing = sessions.get(conversationId);
+        if (existing && !existing.closed) {
+            existing.lastActivity = Date.now();
+            return existing;
+        }
+        const pending = pendingSessionCreations.get(conversationId);
+        if (pending)
+            return pending;
+        // Evict if at capacity
+        if (sessions.size >= MAX_SESSIONS) {
+            evictOldestIdle();
+        }
+        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(() => { });
+            }, {
+                model: config?.model ?? runtimeModels[0]?.value,
+                permissionMode: config?.permissionMode ?? 'default',
+                availableModels: runtimeModels,
+            }, resumeId);
+            sessions.set(conversationId, session);
+            return session;
+        })();
+        pendingSessionCreations.set(conversationId, creation);
+        try {
+            return await creation;
+        }
+        finally {
+            pendingSessionCreations.delete(conversationId);
+        }
+    }
+    // ── Connect SSE stream for inbound Canon messages ──
+    const stream = new CanonStream({
+        apiKey,
+        agentId,
+        handler: {
+            onMessage: (payload) => {
+                const m = payload.message;
+                if (m.senderId === agentId)
+                    return;
+                const convoId = payload.conversationId;
+                // Check for metadata replies (question answers, plan approvals)
+                if (m.metadata?.type === 'question_reply' || m.metadata?.type === 'plan_approval_reply') {
+                    const existingSession = sessions.get(convoId);
+                    if (existingSession?.pendingReply) {
+                        const { resolve } = existingSession.pendingReply;
+                        existingSession.pendingReply = null;
+                        existingSession.lastActivity = Date.now();
+                        resolve(m.metadata);
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Reply received (${m.metadata.type})`);
+                        return;
+                    }
+                }
+                const sender = m.senderName || m.senderId;
+                const content = renderInboundContent(m);
+                const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}"`);
+                void (async () => {
+                    const session = await getOrCreateSession(convoId);
+                    session.sendInput({
+                        type: 'user',
+                        message: {
+                            role: 'user',
+                            content: buildCanonPrompt({
+                                content,
+                                conversationId: convoId,
+                                isOwner,
+                                senderName: sender,
+                            }),
+                        },
+                        parent_tool_use_id: null,
+                    });
+                })();
+            },
+            onConnected: () => console.error('[canon-host] SSE connected'),
+            onDisconnected: () => console.error('[canon-host] SSE disconnected'),
+            onError: (err) => console.error(`[canon-host] SSE error: ${err.message}`),
+        },
+    });
+    stream.start().catch((err) => {
+        console.error('[canon-host] SSE start error:', err instanceof Error ? err.message : err);
+    });
+    // ── Control signal watcher ──
+    let controlStopped = false;
+    const lastSeenControl = new Map();
+    const lastSeenSignal = new Map();
+    const pollControl = async () => {
+        while (!controlStopped) {
+            for (const convoId of [...sessions.keys()]) {
+                try {
+                    // Session control signals (model, mode)
+                    const data = await rtdbRead(`/control/${convoId}/${agentId}/session`);
+                    if (data && typeof data === 'object') {
+                        const ctrl = data;
+                        const ts = ctrl.updatedAt ?? 0;
+                        if (ts > (lastSeenControl.get(convoId) ?? 0)) {
+                            lastSeenControl.set(convoId, ts);
+                            const session = sessions.get(convoId);
+                            if (session && !session.closed) {
+                                console.error(`[canon-host] [${convoId.slice(0, 8)}] Control:`, ctrl);
+                                if (ctrl.model && ctrl.model !== session.state.model) {
+                                    try {
+                                        await session.query.setModel(ctrl.model);
+                                        session.state.model = ctrl.model;
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Model → ${ctrl.model}`);
+                                    }
+                                    catch (err) {
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set model:`, err);
+                                    }
+                                }
+                                if (ctrl.permissionMode && ctrl.permissionMode !== session.state.permissionMode) {
+                                    try {
+                                        await session.query.setPermissionMode(ctrl.permissionMode);
+                                        session.state.permissionMode = ctrl.permissionMode;
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Mode → ${ctrl.permissionMode}`);
+                                    }
+                                    catch (err) {
+                                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set mode:`, err);
+                                    }
+                                }
+                                if (ctrl.effort && ctrl.effort !== session.state.effort) {
+                                    session.state.effort = ctrl.effort;
+                                    session.query.applyFlagSettings({
+                                        effortLevel: ctrl.effort,
+                                    }).catch((err) => console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to set effort:`, err));
+                                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Effort → ${ctrl.effort}`);
+                                }
+                                writeSessionState(convoId, agentId, {
+                                    ...session.state,
+                                    ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
+                                    cwd: session.cwd,
+                                    hostMode: true,
+                                    isActive: true,
+                                }).catch(() => { });
+                            }
+                        }
+                    }
+                    // Interrupt signal
+                    const sig = await rtdbRead(`/control/${convoId}/${agentId}/signal`);
+                    if (sig && typeof sig === 'object') {
+                        const s = sig;
+                        const ts = s.updatedAt ?? 0;
+                        if (s.type === 'interrupt' && ts > (lastSeenSignal.get(convoId) ?? 0)) {
+                            lastSeenSignal.set(convoId, ts);
+                            const session = sessions.get(convoId);
+                            if (session && !session.closed) {
+                                console.error(`[canon-host] [${convoId.slice(0, 8)}] Interrupt signal`);
+                                try {
+                                    await session.query.interrupt();
+                                    if (session.streamingTimer) {
+                                        clearTimeout(session.streamingTimer);
+                                        session.streamingTimer = null;
+                                    }
+                                    session.streamingText = '';
+                                    rtdbWrite(`/streaming/${convoId}/${agentId}`, null).catch(() => { });
+                                    client.setTyping(convoId, false).catch(() => { });
+                                }
+                                catch (err) {
+                                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Interrupt failed:`, err);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Transient RTDB errors — ignore and retry next cycle
+                }
+            }
+            await new Promise((r) => setTimeout(r, CONTROL_POLL_MS));
+        }
+    };
+    pollControl().catch((err) => console.error('[canon-host] Control poll crashed:', err));
+    // ── Heartbeat (per-session) ──
+    const heartbeat = setInterval(() => {
+        for (const session of sessions.values()) {
+            writeSessionState(session.conversationId, agentId, {
+                ...session.state,
+                ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
+                cwd: session.cwd,
+                hostMode: true,
+                isActive: true,
+            }).catch(() => { });
+        }
+    }, HEARTBEAT_MS);
+    // ── Idle session cleanup ──
+    const idleCheck = setInterval(() => {
+        const now = Date.now();
+        for (const convoId of [...sessions.keys()]) {
+            const session = sessions.get(convoId);
+            if (!session || session.state.state === 'running')
+                continue;
+            if (now - session.lastActivity > IDLE_TIMEOUT_MS) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Idle timeout`);
+                closeSession(convoId);
+            }
+        }
+    }, IDLE_CHECK_MS);
+    // ── Graceful shutdown ──
+    const shutdown = async () => {
+        console.error('[canon-host] Shutting down...');
+        controlStopped = true;
+        clearInterval(heartbeat);
+        clearInterval(idleCheck);
+        stream.stop();
+        for (const convoId of [...sessions.keys()]) {
+            closeSession(convoId);
+        }
+        const ap = getActiveProfile();
+        if (ap)
+            releaseLock(ap);
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    console.error('[canon-host] Ready — sessions created on demand');
+    // Keep alive
+    await new Promise(() => { });
+}
+// ── Entry ───────────────────────────────────────────────────────────
+main().catch((err) => {
+    console.error('[canon-host] Fatal error:', err);
+    const ap = getActiveProfile();
+    if (ap)
+        releaseLock(ap);
+    process.exit(1);
+});