@canonmsg/claude-code-plugin 0.19.6 → 0.20.0

package/dist/host.js

@@ -26,12 +26,14 @@ import { execFileSync } from 'node:child_process';
 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, } 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, buildPlanApprovalRequest, resolveQuestionAllowOther, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
-import { decideAutoReply, } from './inbound-policy.js';
+import { inferUploadMimeType, isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
+import { resolvePackagedBridgeBin } from './bridge-bin.js';
+import { connectBridge } from '@canonmsg/framework';
+import { STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, attachHostControlNotifications, captureTurnArtifactSnapshot, collectMissedInboundMessages, collectTurnArtifacts, createBufferedNotificationSource, createConversationDirectory, createFinalDelivery, createHitlWaiters, createPortApprovalClient, createPortTypingSignals, createRuntimeSignalHandler, createRuntimeWriters, createSessionLifecycle, createTurnQueue, decideAutoReply, } from '@canonmsg/agent-host';
+import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildFirstPartyCodingRuntimeDescriptor, buildPlanApprovalRequest, resolveQuestionAllowOther, buildRuntimePresentationPolicy, normalizeRuntimeCommandDescriptors, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, EXECUTION_ENVIRONMENT_MODES, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, normalizeTurnMetadata, renderCanonHostInboundContent, renderCodingHostInboundPrompt, } from '@canonmsg/core/contract';
+import { ExecutionEnvironmentError, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildLocalRuntimeId, buildPublicWorkspaceOptions, buildPublicWorkspaceRoots, clearRuntimeSessionState, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, prepareConversationEnvironment, releaseConversationEnvironment, resolveCanonAgent, saveRuntimeSessionState, upsertLocalRuntimeEntry, } from '@canonmsg/core/local';
+import { ApprovalManager, readHostSessionConfig, resolveHostWorkspaceCwd, } from '@canonmsg/core/host';
 import { runCli } from './cli-entry.js';
-import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
 import { buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
@@ -73,6 +75,11 @@ Keep this terminal open while you want Canon to reach the agent. Closing it,
 logging out, rebooting, or sleeping long enough to stop the process takes the
 local agent offline until you revive it. Docs:
 https://canonmail.com/agents/integrations`;
+// This host process resolves and locks exactly one agent profile. The lock
+// handle returned by resolveCanonAgent is held here so the top-level runCli
+// error handler (outside main's scope) can release it on a failed start —
+// there is no core module-global profile-lock to fall back on.
+let activeLockHandle = null;
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let workspaceRoots = [];
@@ -300,15 +307,15 @@ function toModelOptions(models) {
         label: model.displayName,
     }));
 }
-async function publishAgentRuntime(agentId, runtime) {
-    await publishHostAgentRuntime(agentId, 'claude-code', runtime);
-}
-async function loadSessionConfig(conversationId, agentId) {
-    const config = await loadHostSessionConfig({
-        conversationId,
-        agentId,
-        extraStringFields: ['permissionMode', 'effort'],
+async function publishAgentRuntime(port, runtime) {
+    await port.publishHostAgentRuntime({
+        clientType: 'claude-code',
+        runtime: runtime,
     });
+}
+async function loadSessionConfig(port, conversationId) {
+    const raw = await port.getSessionConfig({ conversationId });
+    const config = readHostSessionConfig(raw, ['permissionMode', 'effort']);
     return {
         ...config,
         permissionMode: config?.permissionMode
@@ -423,9 +430,6 @@ async function refreshClaudeRuntimeMetadata(input) {
     });
     return runtimeMetadataRefresh;
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 function mapClaudeQuestions(value) {
     if (!Array.isArray(value))
         return undefined;
@@ -656,9 +660,6 @@ 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;
-const IDLE_CONTROL_POLL_MS = 10_000;
-const CONTROL_POLL_JITTER_MS = 1_000;
 const FINAL_DELIVERY_RETRY_MS = 30_000;
 const MAX_FINAL_DELIVERY_RETRIES = 1;
 const CLAUDE_RUNTIME_CAPABILITIES = {
@@ -727,7 +728,7 @@ async function buildCanonUserContent(input) {
     ];
 }
 // ── Session factory ─────────────────────────────────────────────────
-function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
+function createSession(conversationId, environment, agentId, port, typingSignals, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
     const cardResponseUserId = config.ownerId ?? undefined;
     const cardResponseUser = cardResponseUserId ? { responseUserId: cardResponseUserId } : undefined;
@@ -787,48 +788,15 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     // 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(type, requestId) {
-        // 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 = {
-                type,
-                requestId,
-                resolve: (metadata) => {
-                    clearTimeout(timer);
-                    resolve(metadata);
-                },
-            };
-        });
-    }
-    async function waitForRuntimeInputResponse(input) {
-        session.lastActivity = Date.now();
-        while (Date.now() < input.expiresAt) {
-            const response = await client.consumeRuntimeInputResponse({
-                conversationId,
-                inputId: input.inputId,
-            }).catch(() => null);
-            if (response?.status === 'submitted') {
-                return { status: 'submitted', answers: response.answers, value: response.value };
-            }
-            if (response?.status === 'cancelled' || response?.status === 'timeout') {
-                return { status: response.status };
-            }
-            await sleep(1_000);
-        }
-        const response = await client.consumeRuntimeInputResponse({
-            conversationId,
-            inputId: input.inputId,
-        }).catch(() => null);
-        if (response?.status === 'submitted') {
-            return { status: 'submitted', answers: response.answers, value: response.value };
-        }
-        return { status: 'timeout' };
-    }
+    // ── HITL waiters (generic skeleton from @canonmsg/agent-host) ──
+    const hitlWaiters = createHitlWaiters({
+        conversationId,
+        replyTimeoutMs: REPLY_TIMEOUT_MS,
+    }, {
+        session: () => session,
+        port,
+    });
+    const { waitForReply, waitForRuntimeInputResponse } = hitlWaiters;
     function buildArtifactMediaMetadata() {
         return {
             ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
@@ -864,25 +832,27 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     const questionId = randomUUID();
                     const questions = mapClaudeQuestions(input.questions);
                     const expiresAt = Date.now() + REPLY_TIMEOUT_MS;
-                    await client.createRuntimeInputRequest({
+                    await port.requestInput({
                         conversationId,
                         inputId: questionId,
                         kind: 'clarify',
-                        expiresAt,
+                        expiresAt: new Date(expiresAt).toISOString(),
                         title: 'Claude needs input',
                         prompt: questions?.length
                             ? 'Claude needs your input to continue.'
                             : 'Claude needs input to continue.',
-                        ...(questions ? { questions } : {}),
+                        ...(questions
+                            ? { questions: questions }
+                            : { questions: [] }),
                         sensitive: Boolean(questions?.some((question) => question.isSecret)),
                         ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
                         native: {
                             runtime: 'claude-code',
                             method: 'AskUserQuestion',
                             requestId: questionId,
-                            turnId: session.currentTurnId ?? undefined,
+                            ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                         },
-                        turnId: session.currentTurnId ?? undefined,
+                        ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
                     const reply = await waitForRuntimeInputResponse({ inputId: questionId, expiresAt });
@@ -937,7 +907,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         ...(cardResponseUser ?? {}),
                         ...(allowedPrompts.length > 0 ? { allowedPrompts } : {}),
                     });
-                    await sendMessageWithRetry(client, conversationId, planApproval.text, {
+                    await port.sendMessage({
+                        conversationId,
+                        text: planApproval.text,
                         messageId: `claude-plan-${planId}`,
                         ...(session.activeSelfContextId
                             ? { selfContextId: session.activeSelfContextId }
@@ -1090,155 +1062,93 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         setRuntimeControlError: (controlId, value, error) => setRuntimeControlError(controlId, value, error),
         clearRuntimeControlError: (controlId) => clearRuntimeControlError(controlId),
     };
-    const streamingOutput = createTurnOutputController({
-        turnId: `claude-${conversationId}`,
-        mode: 'delta',
-        throttleMs: STREAMING_THROTTLE_MS,
-        writeSnapshot: (snapshot) => {
-            if (session.closed)
-                return Promise.resolve();
-            const turnId = session.currentTurnId ?? snapshot.turnId;
-            session.streamingText = snapshot.text;
-            const blocks = snapshot.blocks?.map((block) => ({ ...block, turnId }));
-            return runtimeState.writeStreaming(conversationId, {
-                text: snapshot.text,
-                status: snapshot.status,
-                messageId: turnId,
-                turnId,
-                blocks,
-            });
-        },
-        clearSnapshot: () => {
-            session.streamingText = '';
-            return runtimeState.clearStreaming(conversationId);
+    // ── Per-session RTDB writers (generic skeleton from @canonmsg/agent-host) ──
+    const writers = createRuntimeWriters({
+        conversationId,
+        agentId,
+        capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+        fallbackTurnId: `claude-${conversationId}`,
+        streamingThrottleMs: STREAMING_THROTTLE_MS,
+        requestedControls: {
+            model: config.model,
+            permissionMode: config.permissionMode,
+            effort: config.effort,
         },
+    }, {
+        session: () => session,
+        port,
+        buildSessionStateExtras: (writerSession) => ({
+            cwd,
+            executionMode: writerSession.environment.mode,
+            ...(writerSession.environment.branch ? { executionBranch: writerSession.environment.branch } : {}),
+            ...(writerSession.environment.worktreePath ? { worktreePath: writerSession.environment.worktreePath } : {}),
+            ...(resolveExecutionFallbackReason(writerSession.environment)
+                ? { executionFallbackReason: resolveExecutionFallbackReason(writerSession.environment) ?? undefined }
+                : {}),
+        }),
+        formatControlError: formatClaudeControlError,
     });
-    // ── Per-session streaming helpers ──
-    function flushStreaming() {
-        streamingOutput.flush().catch(() => { });
-    }
-    function onStreamDelta(text, segmentId) {
-        if (segmentId) {
-            streamingOutput.appendTextSegmentDelta(segmentId, text);
-            return;
-        }
-        streamingOutput.appendDelta(text);
-    }
+    const { streamingOutput, flushStreaming, onStreamDelta, clearStreaming, getFinalTurnTrail, writeState, writeTurn, setRuntimeControlError, clearRuntimeControlError, refreshVisibleWorkSignal, startVisibleWorkSignal, stopVisibleWorkSignal, } = writers;
     function isActiveTurnInterrupted() {
         const turnKey = session.activeInput?.turnKey;
         return Boolean(turnKey && session.interruptedTurnKeys.has(turnKey));
     }
-    function clearStreaming() {
-        return streamingOutput.clear().catch(() => { });
-    }
-    function getFinalTurnTrail() {
-        const turnId = session.currentTurnId ?? `claude-${conversationId}`;
-        return streamingOutput.getFinalTrail().map((block) => ({ ...block, turnId }));
-    }
-    function clearIdleResetTimer() {
-        if (!session.idleResetTimer)
-            return;
-        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();
-        resetClaudeCompletedTurnState(session);
-        stopVisibleWorkSignal();
-        writeState();
-        writeTurn();
-        drainPendingInput();
-    }
-    function scheduleFinalHandoffReset() {
-        clearIdleResetTimer();
-        session.idleResetTimer = setTimeout(() => {
-            session.idleResetTimer = null;
-            typingSignals.clear(conversationId).catch(() => { });
-            clearStreaming();
-            resetTurnToIdle();
-        }, FINAL_MESSAGE_HANDOFF_MS);
-    }
-    function markPendingFinalDelivery(finalText, turn) {
-        clearIdleResetTimer();
-        const retryCount = session.pendingFinalDelivery?.turnKey === turn.turnKey
-            ? session.pendingFinalDelivery.retryCount
-            : 0;
-        session.pendingFinalText = finalText;
-        session.pendingFinalDelivery = {
-            turnKey: turn.turnKey,
-            text: finalText,
-            retryCount,
-            messageId: buildClaudeFinalMessageId({
-                agentId,
-                conversationId,
-                turnKey: turn.turnKey,
-            }),
-        };
-        session.state.state = 'running';
-        session.turnState = 'streaming';
-        stopVisibleWorkSignal();
-        streamingOutput.replaceSnapshot(finalText, 'streaming').catch(() => { });
-        writeState();
-        writeTurn();
-        typingSignals.start(conversationId, 'typing').catch(() => { });
-    }
-    async function deliverFinalReply(finalText, turn = session.activeInput) {
-        if (!shouldDeliverClaudeFinal({
+    // ── Turn queue + final delivery (generic skeleton from @canonmsg/agent-host) ──
+    const turnQueue = createTurnQueue({ conversationId }, {
+        session: () => session,
+        isSessionRunning: (queueSession) => queueSession.state.state === 'running',
+        markSessionRunning: (queueSession) => { queueSession.state.state = 'running'; },
+        prepareInput: (input) => prepareArtifactsForInput(input),
+        sendInput: (input) => sendInput(input),
+        interruptRuntime: (queueSession) => queueSession.query.interrupt(),
+        port,
+        writers: {
+            writeTurn,
+            stopVisibleWorkSignal,
+            clearStreaming,
+        },
+    });
+    const { startCanonInput, drainPendingInput, markQueuedMessageAccepted } = turnQueue;
+    const finalDelivery = createFinalDelivery({
+        conversationId,
+        logPrefix: '[canon-host]',
+        delivery: { mode: 'retry', retryMs: FINAL_DELIVERY_RETRY_MS, maxRetries: MAX_FINAL_DELIVERY_RETRIES },
+    }, {
+        session: () => session,
+        port,
+        typingSignals,
+        writers: {
+            writeState,
+            writeTurn,
+            stopVisibleWorkSignal,
+            clearStreaming,
+            getFinalTurnTrail,
+            replaceStreamingSnapshot: (text, status) => streamingOutput.replaceSnapshot(text, status),
+        },
+        resetCompletedTurnState: (deliverySession) => resetClaudeCompletedTurnState(deliverySession),
+        shouldDeliverFinal: (turn, deliverySession) => shouldDeliverClaudeFinal({
             turn,
-            finalizedTurnKeys: session.finalizedTurnKeys,
-            interruptedTurnKeys: session.interruptedTurnKeys,
-        })) {
-            return true;
-        }
-        const deliverTurn = turn;
-        if (!deliverTurn)
-            return true;
-        const finalMessageId = buildClaudeFinalMessageId({
-            agentId,
+            finalizedTurnKeys: deliverySession.finalizedTurnKeys,
+            interruptedTurnKeys: deliverySession.interruptedTurnKeys,
+        }),
+        buildFinalMessageId: (turnKey) => buildClaudeFinalMessageId({ agentId, conversationId, turnKey }),
+        drainPendingInput: () => drainPendingInput(),
+    });
+    const { clearIdleResetTimer, clearFinalDeliveryTimer, resetTurnToIdle, scheduleFinalHandoffReset, markPendingFinalDelivery, deliverFinalReply, scheduleFinalDeliveryRetry, } = finalDelivery;
+    async function sendTurnArtifactFile(file) {
+        // Byte transfer is bridge-owned (§B8): hand the bridge a path, it streams
+        // the upload; then send the permanent message with the attachment ref.
+        const uploaded = await port.uploadMedia({
+            path: file.path,
+            mime: inferUploadMimeType(file.path),
+            fileName: file.fileName,
             conversationId,
-            turnKey: deliverTurn.turnKey,
         });
-        try {
-            await sendMessageWithRetry(client, conversationId, finalText, {
-                messageId: finalMessageId,
-                ...(session.activeSelfContextId
-                    ? { selfContextId: session.activeSelfContextId }
-                    : {}),
-                metadata: {
-                    turnId: session.currentTurnId,
-                    turnKey: deliverTurn.turnKey,
-                    sourceMessageId: deliverTurn.sourceMessageId ?? undefined,
-                    turnSemantics: 'turn_complete',
-                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
-                    ...(getFinalTurnTrail().length > 0
-                        ? { turnTrail: getFinalTurnTrail() }
-                        : {}),
-                },
-            });
-            session.finalizedTurnKeys.add(deliverTurn.turnKey);
-            session.state.state = 'idle';
-            session.pendingFinalDelivery = null;
-            clearFinalDeliveryTimer();
-            writeState();
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars)`);
-            return true;
-        }
-        catch (err) {
-            markPendingFinalDelivery(finalText, deliverTurn);
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send final reply:`, err);
-            return false;
-        }
-    }
-    function sendTurnArtifactFile(file) {
-        return sendMediaFileMessage(client, conversationId, file.path, '', {
+        return port.sendMessage({
+            conversationId,
+            text: '',
+            contentType: uploaded.attachment.kind,
+            attachments: [uploaded.attachment],
             ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
             metadata: buildArtifactMediaMetadata(),
         });
@@ -1275,138 +1185,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             await routeWorkspaceGeneratedArtifacts(input);
         }
     }
-    function scheduleFinalDeliveryRetry(pending = session.pendingFinalDelivery) {
-        if (!pending || session.closed || session.pendingFinalDelivery?.turnKey !== pending.turnKey)
-            return;
-        if (pending.retryCount >= MAX_FINAL_DELIVERY_RETRIES) {
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Final reply delivery exhausted after bounded retries`);
-            session.pendingFinalDelivery = null;
-            resetTurnToIdle();
-            return;
-        }
-        pending.retryCount += 1;
-        session.pendingFinalDelivery = pending;
-        clearFinalDeliveryTimer();
-        session.finalDeliveryTimer = setTimeout(() => {
-            session.finalDeliveryTimer = null;
-            const retryTurn = session.activeInput?.turnKey === pending.turnKey
-                ? session.activeInput
-                : null;
-            void deliverFinalReply(pending.text, retryTurn).then((sent) => {
-                if (sent) {
-                    scheduleFinalHandoffReset();
-                    return;
-                }
-                scheduleFinalDeliveryRetry();
-            });
-        }, FINAL_DELIVERY_RETRY_MS);
-    }
-    function writeState() {
-        const runtimeControlErrors = Object.keys(session.runtimeControlErrors).length > 0
-            ? session.runtimeControlErrors
-            : null;
-        const controlState = {};
-        const appliedAt = Date.now();
-        if (session.state.model !== undefined) {
-            controlState.model = { value: session.state.model, source: 'applied', appliedAt };
-        }
-        else if (config.model !== undefined) {
-            controlState.model = { value: config.model, source: 'requested' };
-        }
-        if (session.state.permissionMode !== undefined) {
-            controlState.permissionMode = { value: session.state.permissionMode, source: 'applied', appliedAt };
-        }
-        else if (config.permissionMode !== undefined) {
-            controlState.permissionMode = { value: config.permissionMode, source: 'requested' };
-        }
-        if (session.state.effort !== undefined) {
-            controlState.effort = { value: session.state.effort, source: 'applied', appliedAt };
-        }
-        else if (config.effort !== undefined) {
-            controlState.effort = { value: config.effort, source: 'requested' };
-        }
-        runtimeState.writeSessionState(conversationId, {
-            model: session.state.model,
-            permissionMode: session.state.permissionMode,
-            effort: session.state.effort,
-            controlState,
-            runtimeControlErrors,
-            contextUsage: session.state.contextUsage,
-            ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
-            cwd,
-            executionMode: session.environment.mode,
-            ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
-            ...(session.environment.worktreePath ? { worktreePath: session.environment.worktreePath } : {}),
-            ...(resolveExecutionFallbackReason(session.environment)
-                ? { executionFallbackReason: resolveExecutionFallbackReason(session.environment) ?? undefined }
-                : {}),
-            hostMode: true,
-            isActive: true,
-        }).catch(() => { });
-    }
-    function setRuntimeControlError(controlId, value, error) {
-        session.runtimeControlErrors = {
-            ...session.runtimeControlErrors,
-            [controlId]: {
-                value,
-                message: formatClaudeControlError(error),
-                updatedAt: Date.now(),
-            },
-        };
-        writeState();
-    }
-    function clearRuntimeControlError(controlId) {
-        if (!(controlId in session.runtimeControlErrors))
-            return;
-        const next = { ...session.runtimeControlErrors };
-        delete next[controlId];
-        session.runtimeControlErrors = next;
-        writeState();
-    }
-    function writeTurn() {
-        const isOpenTurn = session.turnState === 'thinking'
-            || session.turnState === 'streaming'
-            || session.turnState === 'tool'
-            || session.turnState === 'waiting_input';
-        if (isOpenTurn) {
-            session.currentTurnUpdatedAt = Date.now();
-        }
-        runtimeState.writeTurnState(conversationId, {
-            turnId: session.currentTurnId,
-            state: session.turnState,
-            queueDepth: session.pendingInputs.length,
-            currentSpeakerId: agentId,
-            lastAcceptedIntent: session.lastAcceptedIntent,
-            capabilities: CLAUDE_RUNTIME_CAPABILITIES,
-            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
-            ...(isOpenTurn && session.currentTurnUpdatedAt ? { turnUpdatedAt: session.currentTurnUpdatedAt } : {}),
-            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
-                ? { completedAt: { '.sv': 'timestamp' } }
-                : {}),
-        }).catch(() => { });
-    }
-    function refreshVisibleWorkSignal() {
-        if (session.closed)
-            return;
-        if (session.turnState !== 'thinking' && session.turnState !== 'tool')
-            return;
-        typingSignals.start(conversationId, 'thinking').catch(() => { });
-    }
-    function startVisibleWorkSignal() {
-        refreshVisibleWorkSignal();
-    }
-    function stopVisibleWorkSignal() {
-        if (session.typingKeepaliveTimer) {
-            clearInterval(session.typingKeepaliveTimer);
-            session.typingKeepaliveTimer = null;
-        }
-        typingSignals.clear(conversationId).catch(() => { });
-    }
-    async function markQueuedMessageAccepted(sourceMessageId, markAccepted) {
-        if (!markAccepted || !sourceMessageId)
-            return;
-        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
-    }
     async function prepareArtifactsForInput(input) {
         if (input.kind !== 'canon')
             return;
@@ -1422,25 +1200,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             return;
         }
     }
-    async function startCanonInput(input) {
-        await markQueuedMessageAccepted(input.sourceMessageId, input.markAccepted);
-        await prepareArtifactsForInput(input);
-        session.state.state = 'running';
-        sendInput(input);
-    }
-    function drainPendingInput() {
-        if (session.closed || session.state.state === 'running' || session.pendingInputs.length === 0)
-            return;
-        const next = session.pendingInputs.shift();
-        if (!next)
-            return;
-        session.lastAcceptedIntent = next.intent;
-        writeTurn();
-        void startCanonInput(next);
-    }
     enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => {
-        session.lastActivity = Date.now();
-        const input = createClaudeInputEnvelope({
+        turnQueue.enqueueCanonInput(createClaudeInputEnvelope({
             kind: 'canon',
             msg,
             intent,
@@ -1448,32 +1209,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             markAccepted,
             isOwnerTurn,
             artifactRoutingMode,
-        });
-        if (session.pendingFinalDelivery) {
-            session.pendingInputs.push(input);
-            writeTurn();
-            return;
-        }
-        if (session.state.state === 'running' && intent !== 'interrupt') {
-            session.pendingInputs.push(input);
-            writeTurn();
-            return;
-        }
-        if (session.state.state === 'running' && intent === 'interrupt') {
-            if (session.activeInput) {
-                session.interruptedTurnKeys.add(session.activeInput.turnKey);
-            }
-            session.pendingInputs.unshift(input);
-            session.turnState = 'interrupted';
-            stopVisibleWorkSignal();
-            clearStreaming().catch(() => { });
-            writeTurn();
-            void session.query.interrupt().catch(() => { });
-            return;
-        }
-        session.lastAcceptedIntent = intent;
-        writeTurn();
-        void startCanonInput(input);
+        }));
     };
     writeTurn();
     // ── Process SDK output messages ──
@@ -1752,41 +1488,56 @@ export async function main() {
     for (const warning of workspaceDiscovery.warnings) {
         console.error(`[canon-host] ${warning}`);
     }
-    const { apiKey, agentId: profileAgentId, agentName: profileAgentName, profile, baseUrl, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
+    const { agentName: profileAgentName, profile, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
+    activeLockHandle = lockHandle ?? null;
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
-    // ── Canon API client + RTDB auth ──
-    const client = new CanonClient(apiKey, baseUrl);
-    const rtdb = initRTDBAuth(client);
-    const typingSignals = createTypingStatusPublisher({
-        setTyping: (conversationId, typing, status) => status
-            ? client.setTyping(conversationId, typing, status)
-            : client.setTyping(conversationId, typing),
+    // ── Canon via the Bridge (bridge-execution-plan Phase 6) ──
+    // One connectBridge per host process: the daemon owns the SSE stream,
+    // RTDB auth, control polling, dedup, and reconnect. Notification handlers
+    // must exist BEFORE the hello response lands (replayed frames dispatch
+    // synchronously), so a buffered source subscribes inside `configure` and
+    // the real handlers attach after the session machinery is built.
+    const notifications = createBufferedNotificationSource([
+        'ready',
+        'connectionState',
+        'onMessage',
+        'onMessageDeleted',
+        'onConversationUpdated',
+        'onSessionControl',
+        'onControlSignal',
+        'onControlReply',
+    ]);
+    const bridge = await connectBridge({
+        ...(profile ? { profile } : {}),
+        mode: 'auto',
+        ...(resolvePackagedBridgeBin() ? { binPath: resolvePackagedBridgeBin() } : {}),
+        hello: {
+            clientType: 'claude-code',
+            wantFamilies: ['messages', 'runtime_turn'],
+        },
+        configure: (bridgeClient) => notifications.connect(bridgeClient),
+    });
+    // The BridgeClient's zod-derived result shapes mirror the core wire types
+    // structurally; the port pins the strong types the host machinery uses.
+    const port = bridge.client;
+    bridge.client.onProtocolError((error) => {
+        console.error(`[canon-host] Bridge protocol error: ${error.message}`);
     });
+    const typingSignals = createPortTypingSignals(port);
     async function markQueuedMessageAcceptedForConversation(conversationId, sourceMessageId, markAccepted) {
         if (!markAccepted || !sourceMessageId)
             return;
-        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
-    }
-    let agentId;
-    let ownerId = null;
-    let ownerName = null;
-    try {
-        const ctx = await client.getAgentMe();
-        agentId = ctx.agentId;
-        ownerId = ctx.ownerId;
-        ownerName = ctx.ownerName;
-        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}`);
+        await port.setDisposition({
+            conversationId,
+            messageId: sourceMessageId,
+            inboundDisposition: 'accepted_now',
+        }).catch(() => { });
     }
+    const agentId = bridge.hello.agentId;
+    const ownerId = bridge.hello.agentContext.ownerId ?? null;
+    const ownerName = bridge.hello.agentContext.ownerName ?? null;
+    console.error(`[canon-host] Connected as ${bridge.hello.agentName || agentId} `
+        + `(canon-bridge${bridge.spawnedDaemon ? ' spawned' : ''} at ${bridge.socketPath})`);
     const launchArgs = [...process.argv.slice(2)];
     if (!launchArgs.some((arg) => arg === '--cwd' || arg.startsWith('--cwd='))) {
         launchArgs.push('--cwd', workingDir);
@@ -1815,11 +1566,6 @@ export async function main() {
         lastStartedAt: new Date().toISOString(),
         lastHeartbeatAt: new Date().toISOString(),
     });
-    const runtimeState = createRuntimeStatePublisher({
-        agentId,
-        clientType: 'claude-code',
-        hostMode: true,
-    });
     let streamConnected = false;
     const hostAvailableExecutionModes = [
         ...EXECUTION_ENVIRONMENT_MODES,
@@ -1844,11 +1590,14 @@ export async function main() {
             presentation: runtimePresentation,
         }),
     };
-    const conversationCache = new Map();
-    const knownConversationIds = new Set();
-    const promptedGroupContextConversationIds = new Set();
-    const pendingMembershipChanges = new Map();
-    let lastKnownConversationRefreshAt = 0;
+    // ── Conversation directory (shared inbound-ingestion bookkeeping from @canonmsg/agent-host) ──
+    const directory = createConversationDirectory({
+        agentId,
+        ownerId,
+        ownerName,
+        refreshFloorMs: HEARTBEAT_MS,
+    }, { port });
+    const { conversationCache, knownConversationIds, getConversationMeta, refreshKnownConversationIds, handleConversationUpdated, markGroupContextModeUsed, loadHydratedInboundContext, } = directory;
     const publishRuntimeHeartbeat = async () => {
         heartbeatLocalRuntimeEntry(runtimeId, {
             agentId,
@@ -1869,18 +1618,17 @@ 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(port, runtimeDescriptor).catch((error) => {
             console.error('[canon-host] Failed to publish agent runtime:', error);
         });
-        await publishHostSessionSnapshots({
+        await port.publishHostSessionSnapshots({
             conversationIds: Array.from(knownConversationIds),
-            agentId,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
-            workspaceOptions,
+            workspaceOptions: workspaceOptions.map(({ id, cwd }) => ({ id, cwd })),
             defaultCwd: workingDir,
             extraSessionConfigFields: ['permissionMode', 'effort'],
-            liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
+            liveSessionConfigByConversation: Object.fromEntries(Array.from(sessions.values()).map((session) => {
                 const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
                 return [
                     session.conversationId,
@@ -1933,7 +1681,10 @@ export async function main() {
                 worktreePath: session?.environment.worktreePath ?? null,
                 fallbackReason: resolveExecutionFallbackReason(session?.environment),
             });
-            await runtimeState.writeRuntimeInfo(conversationId, payload);
+            await port.publishRuntimeStatus({
+                conversationId,
+                presentation: payload,
+            });
         })).catch((error) => {
             console.error('[canon-host] Failed to publish runtime info:', error);
         });
@@ -1975,14 +1726,12 @@ export async function main() {
         };
     }
     try {
-        const convos = await client.getConversations();
-        lastKnownConversationRefreshAt = Date.now();
+        const convos = await directory.listConversations();
+        directory.primeFromStartup(convos);
         for (const conversation of convos) {
-            knownConversationIds.add(conversation.id);
-            conversationCache.set(conversation.id, conversation);
-            runtimeState.clearStreaming(conversation.id).catch(() => { });
-            runtimeState.clearSessionState(conversation.id).catch(() => { });
-            runtimeState.clearTurnState(conversation.id).catch(() => { });
+            port.clearStreaming({ conversationId: conversation.id }).catch(() => { });
+            port.clearSessionState({ conversationId: conversation.id }).catch(() => { });
+            port.clearTurnState({ conversationId: conversation.id }).catch(() => { });
             typingSignals.clear(conversation.id).catch(() => { });
         }
         console.error(`[canon-host] ${convos.length} conversations`);
@@ -1990,64 +1739,68 @@ export async function main() {
     catch {
         console.error('[canon-host] Could not load conversations');
     }
-    // ── Session manager ──
-    const sessions = new Map();
-    const approvalManager = ownerId ? new ApprovalManager(client, agentId, ownerId) : null;
-    const pendingSessionCreations = new Map();
-    // Shared /control channel poller (claude host profile): session + signal
-    // keys, sequential conversations, active/idle cadence + jitter sampled at
-    // cycle start, eager baselines at session creation, and nodes left in place
-    // when a handler throws (consumeOnError defaults to false for both keys).
-    const controlPoller = new ControlChannelPoller({
-        rtdb,
-        agentId,
-        conversationIds: () => sessions.keys(),
-        cadence: {
-            kind: 'adaptive',
-            activeMs: CONTROL_POLL_MS,
-            idleMs: IDLE_CONTROL_POLL_MS,
-            jitterMs: CONTROL_POLL_JITTER_MS,
-            hasActiveWork: () => [...sessions.values()].some((session) => !session.closed
-                && (session.state.state === 'running'
-                    || session.state.state === 'requires_action'
-                    || session.pendingInputs.length > 0
-                    || Boolean(session.pendingFinalDelivery))),
-            activitySample: 'cycle-start',
-        },
-        pollOnStart: true,
-        conversationConcurrency: 'sequential',
-        handlers: {
-            session: { handle: applyRuntimeSessionControl },
-            signal: { handle: handleRuntimeControlSignal },
+    // ── Session manager (generic lifecycle from @canonmsg/agent-host) ──
+    const approvalManager = ownerId
+        ? new ApprovalManager(createPortApprovalClient(port), agentId, ownerId)
+        : null;
+    const lifecycle = createSessionLifecycle({
+        maxSessions: MAX_SESSIONS,
+        idleTimeoutMs: IDLE_TIMEOUT_MS,
+        heartbeatMs: HEARTBEAT_MS,
+        idleCheckMs: IDLE_CHECK_MS,
+        logPrefix: '[canon-host]',
+    }, {
+        knownConversationIds,
+        createSession: (conversationId) => createSessionForConversation(conversationId),
+        isSessionRunning: (session) => session.state.state === 'running',
+        writeTurnOnHeartbeat: (session) => session.state.state !== 'running' && session.state.state !== 'requires_action',
+        writeSessionState: (session) => session.writeState(),
+        writeSessionTurn: (session) => session.writeTurn(),
+        releaseEnvironment: (session) => releaseConversationEnvironment(session.environment),
+        persistResumeState,
+        disposeRuntime: (session) => session.query.close(),
+        interruptRuntime: (session) => session.query.interrupt(),
+        port,
+        publishRuntimeHeartbeat,
+        onShutdown: async () => {
+            detachControlNotifications();
+            notifications.detach();
+            approvalManager?.dispose();
+            await port.clearAgentRuntime().catch(() => { });
+            bridge.client.close();
         },
-        onError: ({ scope, key, conversationId, error }) => {
-            if (scope === 'read')
-                return; // Transient RTDB errors — retry next cycle
-            const convo = conversationId ? ` [${conversationId.slice(0, 8)}]` : '';
-            console.error(`[canon-host]${convo} Control ${key ?? 'poll'} ${scope} error:`, error);
+        onShutdownComplete: () => {
+            markLocalRuntimeStopped(runtimeId);
+            lockHandle?.release();
         },
     });
+    const { sessions, getOrCreateSession, closeSession, resetRuntimeSession, markSessionPendingInputsRejected, removeQueuedInput, } = lifecycle;
+    // Interrupt/stop-clear signal handling (generic shell from @canonmsg/agent-host).
+    const handleRuntimeControlSignal = createRuntimeSignalHandler({
+        agentId,
+        logPrefix: '[canon-host]',
+        capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+    }, {
+        sessions,
+        port,
+        isSessionRunning: (session) => session.state.state === 'running',
+        interruptRuntime: (session) => session.query.interrupt(),
+        resetSession: (session) => resetRuntimeSession(session),
+        markSessionPendingInputsRejected,
+    });
+    // Control events arrive as bridge notifications — the bridge owns the ONE
+    // authoritative /control consumer for this identity (plan §2); the host's
+    // adaptive poller (active/idle cadence, jitter, per-session baselines) is
+    // deleted with it.
+    const detachControlNotifications = attachHostControlNotifications(notifications.source, { logPrefix: '[canon-host]' }, {
+        onSessionControl: applyRuntimeSessionControl,
+        onControlSignal: handleRuntimeControlSignal,
+    });
     /** Saved SDK session IDs for resume after idle eviction, keyed by conversation + workspace */
     const savedSessionIds = new Map();
-    const { getConversationMeta } = createConversationMetadataLoader({
-        client,
-        conversationCache,
-    });
     function resolveWorkspaceIdForBaseCwd(baseCwd) {
         return workspaceOptions.find((option) => option.cwd === baseCwd)?.id;
     }
-    async function refreshKnownConversationIds(force = false) {
-        if (!force && Date.now() - lastKnownConversationRefreshAt < HEARTBEAT_MS) {
-            return;
-        }
-        const conversations = await client.getConversations();
-        knownConversationIds.clear();
-        for (const conversation of conversations) {
-            knownConversationIds.add(conversation.id);
-            conversationCache.set(conversation.id, conversation);
-        }
-        lastKnownConversationRefreshAt = Date.now();
-    }
     async function canRequestCanonApproval(conversationId) {
         if (!ownerId)
             return false;
@@ -2055,80 +1808,9 @@ export async function main() {
             .catch(() => conversationCache.get(conversationId) ?? null);
         return Array.isArray(conversation?.memberIds) && conversation.memberIds.includes(ownerId);
     }
-    function handleConversationUpdated(payload) {
-        const rawMemberIds = payload.changes.memberIds;
-        if (!Array.isArray(rawMemberIds))
-            return;
-        const memberIds = rawMemberIds.filter((id) => typeof id === 'string');
-        const cached = conversationCache.get(payload.conversationId);
-        const membershipChange = payload.membershipChange
-            ?? (cached ? diffCanonMemberIds(cached.memberIds, memberIds) : null);
-        if (cached) {
-            conversationCache.set(payload.conversationId, {
-                ...cached,
-                memberIds,
-            });
-        }
-        if (membershipChange) {
-            pendingMembershipChanges.set(payload.conversationId, membershipChange);
-        }
-        if (!memberIds.includes(agentId)) {
-            knownConversationIds.delete(payload.conversationId);
-            conversationCache.delete(payload.conversationId);
-        }
-    }
-    function getGroupContextMode(conversationId, conversation) {
-        if (conversation?.type !== 'group')
-            return undefined;
-        if (pendingMembershipChanges.has(conversationId))
-            return 'membership_change';
-        if (!promptedGroupContextConversationIds.has(conversationId))
-            return 'initial';
-        return undefined;
-    }
-    function markGroupContextModeUsed(conversationId, mode) {
-        if (!mode)
-            return;
-        promptedGroupContextConversationIds.add(conversationId);
-        if (mode === 'membership_change') {
-            pendingMembershipChanges.delete(conversationId);
-        }
-    }
-    async function loadHydratedInboundContext(input) {
-        const [conversation, page] = await Promise.all([
-            getConversationMeta(input.conversationId),
-            input.hydratedPage
-                ? Promise.resolve(input.hydratedPage)
-                : client.getMessagesPage(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => null),
-        ]);
-        return buildHydratedInboundContext({
-            agentId,
-            conversationId: input.conversationId,
-            conversation,
-            page,
-            activeSelfContextId: input.activeSelfContextId,
-            selfContexts: input.selfContexts,
-            provenance: input.provenance,
-            message: input.message,
-            senderName: input.senderName,
-            isOwner: input.isOwner,
-            ownerId,
-            ownerName,
-            membershipChange: pendingMembershipChanges.get(input.conversationId) ?? null,
-            groupContextMode: getGroupContextMode(input.conversationId, conversation),
-        });
-    }
-    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);
+    /** Resume-state persistence on session close (claude-specific: SDK sessionId). */
+    function persistResumeState(session, saveResume) {
+        const conversationId = session.conversationId;
         const resumeKey = buildConversationEnvironmentKey(conversationId, session.environment.baseCwd);
         if (saveResume && session.sdkSessionId) {
             savedSessionIds.set(resumeKey, session.sdkSessionId);
@@ -2160,89 +1842,11 @@ export async function main() {
                 });
             }
         }
-        session.clearStreaming().catch(() => { });
-        if (session.idleResetTimer) {
-            clearTimeout(session.idleResetTimer);
-            session.idleResetTimer = null;
-        }
-        if (session.finalDeliveryTimer) {
-            clearTimeout(session.finalDeliveryTimer);
-            session.finalDeliveryTimer = null;
-        }
-        runtimeState.clearSessionState(conversationId).catch(() => { });
-        runtimeState.clearTurnState(conversationId).catch(() => { });
-        typingSignals.clear(conversationId).catch(() => { });
-        typingSignals.dispose(conversationId);
-        try {
-            session.query.close();
-        }
-        catch { }
-        sessions.delete(conversationId);
-        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';
-        session.clearStreaming().catch(() => { });
-        typingSignals.clear(conversationId).catch(() => { });
-        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) => {
-            if (!input.markAccepted || !input.sourceMessageId)
-                return Promise.resolve();
-            return client.updateMessageDisposition(conversationId, input.sourceMessageId, 'rejected').catch(() => { });
-        }));
-    }
-    function removeQueuedInput(conversationId, sourceMessageId) {
-        const session = sessions.get(conversationId);
-        if (!session || session.pendingInputs.length === 0)
-            return;
-        const before = session.pendingInputs.length;
-        session.pendingInputs = session.pendingInputs.filter((input) => input.sourceMessageId !== sourceMessageId);
-        if (session.pendingInputs.length === before)
-            return;
-        session.writeTurn();
-    }
-    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) {
-        knownConversationIds.add(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);
+    /** Runtime-specific session construction, invoked via the lifecycle's getOrCreateSession. */
+    function createSessionForConversation(conversationId) {
+        return (async () => {
+            const config = await loadSessionConfig(port, conversationId);
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -2259,7 +1863,7 @@ export async function main() {
                     executionMode: environment.mode,
                 });
                 const resumeId = savedSessionIds.get(resumeKey) ?? persisted?.claudeSessionId;
-                const session = createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, (convoId, sdkSessionId) => {
+                const session = createSession(conversationId, environment, agentId, port, typingSignals, (convoId, sdkSessionId) => {
                     // Called when session processing loop ends — save session ID for resume
                     const existing = sessions.get(convoId);
                     if (existing) {
@@ -2283,10 +1887,9 @@ export async function main() {
                     }
                     existing?.clearStreaming().catch(() => { });
                     typingSignals.clear(convoId).catch(() => { });
-                    typingSignals.dispose(convoId);
                     sessions.delete(convoId);
-                    runtimeState.clearSessionState(convoId).catch(() => { });
-                    runtimeState.clearTurnState(convoId).catch(() => { });
+                    port.clearSessionState({ conversationId: convoId }).catch(() => { });
+                    port.clearTurnState({ conversationId: convoId }).catch(() => { });
                 }, (descriptor) => {
                     runtimeDescriptor = descriptor;
                     void publishRuntimeHeartbeat();
@@ -2303,7 +1906,6 @@ export async function main() {
                     ownerId,
                 }, resumeId);
                 sessions.set(conversationId, session);
-                await controlPoller.baseline([conversationId]);
                 return session;
             }
             catch (error) {
@@ -2311,13 +1913,6 @@ export async function main() {
                 throw error;
             }
         })();
-        pendingSessionCreations.set(conversationId, creation);
-        try {
-            return await creation;
-        }
-        finally {
-            pendingSessionCreations.delete(conversationId);
-        }
     }
     async function enqueueRecoveredInboundMessage(input) {
         const m = input.message;
@@ -2374,7 +1969,9 @@ export async function main() {
             const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
             console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Failed to create recovered session: ${message}`);
             await markQueuedMessageAcceptedForConversation(input.conversationId, m.id ?? null, shouldMarkAccepted);
-            await sendMessageWithRetry(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+            await port.sendMessage({
+                conversationId: input.conversationId,
+                text: `I couldn't start a coding session for this workspace: ${userMessage}`,
                 messageId: `claude-start-failed-${m.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
@@ -2424,7 +2021,12 @@ export async function main() {
                 baseCwd: workingDir,
             })?.lastInboundMessageId;
             const recovery = await collectMissedInboundMessages({
-                fetchPage: (before) => client.getMessagesPage(conversation.id, STARTUP_RECOVERY_PAGE_SIZE, before),
+                fetchPage: (before) => port.getMessages({
+                    conversationId: conversation.id,
+                    limit: STARTUP_RECOVERY_PAGE_SIZE,
+                    ...(before ? { before } : {}),
+                    includeBehavior: true,
+                }),
                 cursor,
                 agentId,
             });
@@ -2447,188 +2049,208 @@ export async function main() {
     catch (error) {
         console.error('[canon-host] Failed startup recovery:', error instanceof Error ? error.message : error);
     }
-    // ── 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;
-                knownConversationIds.add(convoId);
-                if (m.metadata?.type === 'approval_reply' || (approvalManager?.pendingCount ?? 0) > 0) {
-                    const consumed = approvalManager?.handleMessage(convoId, {
-                        senderId: m.senderId,
-                        metadata: m.metadata,
-                    }) ?? false;
-                    if (m.metadata?.type === 'approval_reply') {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] ${consumed ? 'Approval reply consumed' : 'Ignoring stale approval reply'} from ${m.senderName || m.senderId}`);
-                        return;
-                    }
-                    if (consumed) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Approval text reply consumed from ${m.senderName || m.senderId}`);
-                        return;
-                    }
+    // ── Inbound Canon events (bridge notifications) ──
+    // The bridge owns SSE reconnect/heartbeat/replay + dedup + self-filtering;
+    // HITL control-reply messages (approval_reply / plan_approval_reply) are
+    // STRIPPED from onMessage bridge-side — unmatched ones arrive as
+    // onControlReply and feed the plan-approval waiters below.
+    const handleInboundMessage = (payload) => {
+        const m = payload.message;
+        if (m.senderId === agentId)
+            return;
+        const convoId = payload.conversationId;
+        knownConversationIds.add(convoId);
+        const sender = m.senderName || m.senderId;
+        const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
+        if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
+            console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
+            return;
+        }
+        void (async () => {
+            let materialized = [];
+            if (m.id) {
+                try {
+                    materialized = await materializeMessageMedia({
+                        id: m.id,
+                        attachments: m.attachments ?? [],
+                    }, { agentId, conversationId: convoId });
                 }
-                // Check for metadata replies (plan approvals).
-                if (m.metadata?.type === 'plan_approval_reply') {
-                    const existingSession = sessions.get(convoId);
-                    const pendingReply = existingSession?.pendingReply;
-                    const isOwnerReply = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-                    const replyRequestId = m.metadata.planId;
-                    if (!pendingReply) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring stale ${m.metadata.type} with no pending request`);
-                        return;
-                    }
-                    if (!isOwnerReply) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring ${m.metadata.type} from non-owner ${m.senderId}`);
-                        return;
-                    }
-                    if (pendingReply.type !== m.metadata.type || pendingReply.requestId !== replyRequestId) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring mismatched ${m.metadata.type} (${String(replyRequestId ?? 'missing-id')})`);
-                        return;
-                    }
-                    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}:${pendingReply.requestId.slice(0, 8)})`);
-                        return;
-                    }
+                catch (error) {
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
                 }
-                const sender = m.senderName || m.senderId;
-                const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-                if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
-                    return;
+            }
+            const content = renderInboundContent(m, materialized);
+            const hydrated = await loadHydratedInboundContext({
+                conversationId: convoId,
+                message: m,
+                senderName: sender,
+                isOwner,
+                activeSelfContextId: payload.activeSelfContextId,
+                selfContexts: payload.selfContexts,
+                provenance: payload.provenance,
+            });
+            const behavior = payload.behavior ?? hydrated.behavior;
+            const activeSelfContextId = hydrated.activeSelfContextId;
+            const selfContexts = hydrated.selfContexts;
+            const replyMedia = await materializePromptReplyContext({
+                replyContext: hydrated.replyContext,
+                agentId,
+                conversationId: convoId,
+                logPrefix: `[canon-host] [${convoId.slice(0, 8)}]`,
+            });
+            const replyContext = replyMedia.replyContext;
+            const participantContext = hydrated.participantContext;
+            const autoReply = payload.turnDispatch?.kind === 'run_turn'
+                ? {
+                    allow: true,
+                    reason: payload.turnDispatch.reason || 'server dispatch allowed this turn',
                 }
-                void (async () => {
-                    let materialized = [];
-                    if (m.id) {
-                        try {
-                            materialized = await materializeMessageMedia({
-                                id: m.id,
-                                attachments: m.attachments ?? [],
-                            }, { agentId, conversationId: convoId });
-                        }
-                        catch (error) {
-                            console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
-                        }
-                    }
-                    const content = renderInboundContent(m, materialized);
-                    const hydrated = await loadHydratedInboundContext({
-                        conversationId: convoId,
-                        message: m,
-                        senderName: sender,
-                        isOwner,
-                        activeSelfContextId: payload.activeSelfContextId,
-                        selfContexts: payload.selfContexts,
-                        provenance: payload.provenance,
-                    });
-                    const behavior = payload.behavior ?? hydrated.behavior;
-                    const activeSelfContextId = hydrated.activeSelfContextId;
-                    const selfContexts = hydrated.selfContexts;
-                    const replyMedia = await materializePromptReplyContext({
-                        replyContext: hydrated.replyContext,
-                        agentId,
-                        conversationId: convoId,
-                        logPrefix: `[canon-host] [${convoId.slice(0, 8)}]`,
-                    });
-                    const replyContext = replyMedia.replyContext;
-                    const participantContext = hydrated.participantContext;
-                    const autoReply = payload.turnDispatch?.kind === 'run_turn'
-                        ? {
-                            allow: true,
-                            reason: payload.turnDispatch.reason || 'server dispatch allowed this turn',
-                        }
-                        : decideAutoReply(participantContext, behavior);
-                    if (!autoReply.allow) {
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
-                        return;
-                    }
-                    markGroupContextModeUsed(convoId, participantContext.groupContextMode);
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
-                    const turnMetadata = normalizeTurnMetadata(m.metadata);
-                    const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
-                    const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
-                    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 markQueuedMessageAcceptedForConversation(convoId, m.id ?? null, shouldMarkAccepted);
-                        await sendMessageWithRetry(client, convoId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
-                            messageId: `claude-start-failed-${m.id}`,
-                            ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
-                            metadata: {
-                                turnSemantics: 'turn_complete',
-                                replyBehavior: 'suppress_auto_reply',
-                            },
-                        }).catch(() => { });
-                        return;
-                    }
-                    session.activeSelfContextId = activeSelfContextId;
-                    const promptText = buildCanonPrompt({
-                        content,
-                        conversationId: convoId,
-                        participantContext,
-                        behavior,
-                        selfContexts,
-                        activeSelfContextId,
-                        provenance: hydrated.provenance,
-                        replyContext,
-                        message: m,
-                    });
-                    const messageContent = await buildCanonUserContent({
-                        promptText,
-                        materialized: [...replyMedia.materialized, ...materialized],
-                    });
-                    const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
-                    session.enqueueInbound({
-                        type: 'user',
-                        message: {
-                            role: 'user',
-                            content: messageContent,
-                        },
-                        parent_tool_use_id: null,
-                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, artifactRoutingMode);
-                    if (m.id) {
-                        saveRuntimeSessionState(runtimeId, {
-                            conversationId: convoId,
-                            baseCwd: workingDir,
-                            lastInboundMessageId: m.id,
-                        });
-                    }
-                })();
-            },
-            onMessageDeleted: (payload) => {
-                removeQueuedInput(payload.conversationId, payload.messageId);
-            },
-            onConversationUpdated: (payload) => {
-                handleConversationUpdated(payload);
-            },
-            onConnected: () => {
+                : decideAutoReply(participantContext, behavior);
+            if (!autoReply.allow) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+                return;
+            }
+            markGroupContextModeUsed(convoId, participantContext.groupContextMode);
+            console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
+            const turnMetadata = normalizeTurnMetadata(m.metadata);
+            const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+            const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+            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 markQueuedMessageAcceptedForConversation(convoId, m.id ?? null, shouldMarkAccepted);
+                await port.sendMessage({
+                    conversationId: convoId,
+                    text: `I couldn't start a coding session for this workspace: ${userMessage}`,
+                    messageId: `claude-start-failed-${m.id}`,
+                    ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
+                    metadata: {
+                        turnSemantics: 'turn_complete',
+                        replyBehavior: 'suppress_auto_reply',
+                    },
+                }).catch(() => { });
+                return;
+            }
+            session.activeSelfContextId = activeSelfContextId;
+            const promptText = buildCanonPrompt({
+                content,
+                conversationId: convoId,
+                participantContext,
+                behavior,
+                selfContexts,
+                activeSelfContextId,
+                provenance: hydrated.provenance,
+                replyContext,
+                message: m,
+            });
+            const messageContent = await buildCanonUserContent({
+                promptText,
+                materialized: [...replyMedia.materialized, ...materialized],
+            });
+            const artifactRoutingMode = resolveArtifactRoutingMode(participantContext);
+            session.enqueueInbound({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    content: messageContent,
+                },
+                parent_tool_use_id: null,
+            }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, artifactRoutingMode);
+            if (m.id) {
+                saveRuntimeSessionState(runtimeId, {
+                    conversationId: convoId,
+                    baseCwd: workingDir,
+                    lastInboundMessageId: m.id,
+                });
+            }
+        })();
+    };
+    /**
+     * Stripped HITL control replies that matched no bridge record: the plan
+     * approval flow (host-raised via a plain sendMessage) resolves its
+     * metadata-reply waiter here; anything else is fed to the approval
+     * manager as a late/second-chance consume.
+     */
+    const handleControlReply = (convoId, m) => {
+        if (m.metadata?.type === 'approval_reply' || (approvalManager?.pendingCount ?? 0) > 0) {
+            const consumed = approvalManager?.handleMessage(convoId, {
+                senderId: m.senderId,
+                metadata: m.metadata,
+            }) ?? false;
+            if (m.metadata?.type === 'approval_reply') {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] ${consumed ? 'Approval reply consumed' : 'Ignoring stale approval reply'} from ${m.senderName || m.senderId}`);
+                return;
+            }
+            if (consumed) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Approval text reply consumed from ${m.senderName || m.senderId}`);
+                return;
+            }
+        }
+        if (m.metadata?.type === 'plan_approval_reply') {
+            const existingSession = sessions.get(convoId);
+            const pendingReply = existingSession?.pendingReply;
+            const isOwnerReply = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
+            const replyRequestId = m.metadata.planId;
+            if (!pendingReply) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring stale ${m.metadata.type} with no pending request`);
+                return;
+            }
+            if (!isOwnerReply) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring ${m.metadata.type} from non-owner ${m.senderId}`);
+                return;
+            }
+            if (pendingReply.type !== m.metadata.type || pendingReply.requestId !== replyRequestId) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring mismatched ${m.metadata.type} (${String(replyRequestId ?? 'missing-id')})`);
+                return;
+            }
+            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}:${pendingReply.requestId.slice(0, 8)})`);
+            }
+        }
+    };
+    notifications.attach({
+        onMessage: (params) => {
+            handleInboundMessage(params);
+        },
+        onMessageDeleted: (params) => {
+            const payload = params;
+            removeQueuedInput(payload.conversationId, payload.messageId);
+        },
+        onConversationUpdated: (params) => {
+            handleConversationUpdated(params);
+        },
+        onControlReply: (params) => {
+            const payload = params;
+            handleControlReply(payload.conversationId, payload.message);
+        },
+        ready: () => {
+            streamConnected = true;
+            void publishRuntimeHeartbeat();
+            console.error('[canon-host] Bridge ready');
+        },
+        connectionState: (params) => {
+            const { upstream } = params;
+            if (upstream === 'connected') {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
-                console.error('[canon-host] SSE connected');
-            },
-            onDisconnected: () => {
+                console.error('[canon-host] Canon upstream connected');
+            }
+            else {
                 streamConnected = false;
-                runtimeState.clearAgentRuntime().catch(() => { });
-                console.error('[canon-host] SSE disconnected');
-            },
-            onError: (err) => console.error(`[canon-host] SSE error: ${err.message}`),
+                port.clearAgentRuntime().catch(() => { });
+                console.error(`[canon-host] Canon upstream ${upstream}`);
+            }
         },
     });
-    stream.start().catch((err) => {
-        console.error('[canon-host] SSE start error:', err instanceof Error ? err.message : err);
-    });
     // ── Control signal watcher ──
     // Session control signals (model, mode, effort). A missing/closed session
     // leaves the node in place; lastSeen still advances, so a stale control is
@@ -2687,92 +2309,9 @@ export async function main() {
         }
         session.writeState();
     }
-    // Interrupt/stop-clear signal. Throwing leaves the node in place
-    // (consumeOnError: false); lastSeen has already advanced, so the failed
-    // signal is reported but never retried.
-    async function handleRuntimeControlSignal(event) {
-        const convoId = event.conversationId;
-        const session = sessions.get(convoId);
-        if (!session || session.closed)
-            return { consume: false };
-        if (event.type === 'new_session') {
-            console.error(`[canon-host] [${convoId.slice(0, 8)}] new_session signal`);
-            await resetRuntimeSession(session);
-            return;
-        }
-        const isActive = session.state.state === 'running';
-        if (!isActive && (event.type !== 'stop_and_drop' || session.pendingInputs.length === 0)) {
-            return; // Nothing to interrupt — consume the stale signal
-        }
-        console.error(`[canon-host] [${convoId.slice(0, 8)}] ${event.type} signal`);
-        if (event.type === 'stop_and_drop') {
-            const droppedInputs = session.pendingInputs.splice(0);
-            await markSessionPendingInputsRejected(convoId, droppedInputs);
-        }
-        if (session.activeInput) {
-            session.interruptedTurnKeys.add(session.activeInput.turnKey);
-        }
-        session.pendingFinalText = null;
-        session.turnState = 'interrupted';
-        session.clearStreaming().catch(() => { });
-        typingSignals.clear(convoId).catch(() => { });
-        runtimeState.writeTurnState(convoId, {
-            turnId: session.currentTurnId,
-            state: 'interrupted',
-            queueDepth: session.pendingInputs.length,
-            currentSpeakerId: agentId,
-            lastAcceptedIntent: session.lastAcceptedIntent,
-            capabilities: CLAUDE_RUNTIME_CAPABILITIES,
-            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
-            completedAt: { '.sv': 'timestamp' },
-        }).catch(() => { });
-        if (isActive) {
-            await session.query.interrupt();
-        }
-    }
-    controlPoller.start();
-    // ── Heartbeat (per-session) ──
-    const heartbeat = setInterval(() => {
-        for (const session of sessions.values()) {
-            session.writeState();
-            if (session.state.state !== 'running' && session.state.state !== 'requires_action') {
-                session.writeTurn();
-            }
-        }
-        void publishRuntimeHeartbeat();
-    }, 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...');
-        controlPoller.stop();
-        clearInterval(heartbeat);
-        clearInterval(idleCheck);
-        stream.stop();
-        approvalManager?.dispose();
-        await runtimeState.clearAgentRuntime().catch(() => { });
-        for (const convoId of [...sessions.keys()]) {
-            closeSession(convoId);
-        }
-        markLocalRuntimeStopped(runtimeId);
-        (lockHandle ?? getActiveProfileLock())?.release();
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-    process.on('SIGHUP', shutdown);
+    // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──
+    lifecycle.startTimers();
+    lifecycle.installSignalHandlers();
     console.error('[canon-host] Ready — sessions created on demand');
     // Keep alive
     await new Promise(() => { });
@@ -2781,7 +2320,7 @@ export async function main() {
 runCli(import.meta.url, main, (err) => {
     const message = err instanceof Error ? err.message : String(err);
     console.error(`[canon-host] ${message}`);
-    getActiveProfileLock()?.release();
+    activeLockHandle?.release();
     process.exit(1);
 }, {
     name: 'canon-claude',