@canonmsg/claude-code-plugin 0.22.0 → 0.24.0

package/dist/host.js

@@ -26,19 +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 { 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 { 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 { runCli } from './cli-entry.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { applyClaudeSessionControl, buildClaudeFinalMessageId, buildClaudeInitialSessionState, claudeModelInfoToOption, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, normalizeClaudeEffortLevel, parseClaudePermissionMode, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
-import { claudeThinkingToConfig, parseClaudeSessionDefaults, resolveEffectiveSessionSettings, } from './session-defaults.js';
-import { mapClaudeSubagentActivity } from './subagent-activity.js';
+import { applyClaudeSessionControl, buildClaudeFinalMessageId, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -77,11 +72,6 @@ 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 = [];
@@ -89,29 +79,6 @@ let workspaceRootMetadata = [];
 let runtimeModels = [];
 const CLAUDE_METADATA_TTL_MS = 5 * 60 * 1000;
 const allowedNonOwnerClaudeTools = parseAllowedNonOwnerClaudeTools(process.env.CANON_CLAUDE_NON_OWNER_ALLOWED_TOOLS);
-const CLAUDE_THINKING_CONTROL_OPTIONS = [
-    {
-        value: 'adaptive',
-        label: 'Adaptive',
-        description: 'Let Claude decide when and how much to think.',
-    },
-    {
-        value: 'off',
-        label: 'Off',
-        description: 'Disable extended thinking for this session.',
-    },
-];
-const CLAUDE_ULTRACODE_CONTROL_OPTIONS = [
-    {
-        value: 'off',
-        label: 'Off',
-    },
-    {
-        value: 'on',
-        label: 'On',
-        description: 'Enable Claude Code ultracode mode when the selected model supports it.',
-    },
-];
 let runtimeMetadata = {
     account: null,
     mcpServers: [],
@@ -228,6 +195,26 @@ function buildClaudeRuntimeDescriptor(input) {
                 controlId: 'effort',
             },
         },
+        {
+            id: 'ultracode-details',
+            label: 'Ultracode',
+            description: 'Toggle Claude ultracode using /ultracode.',
+            aliases: ['ultracode'],
+            category: 'runtime',
+            placements: ['composer_slash', 'command_palette'],
+            availability: ['always'],
+            args: [{
+                    id: 'level',
+                    label: 'Level',
+                    kind: 'enum',
+                    required: true,
+                    choices: [...CLAUDE_ULTRACODE_OPTIONS],
+                }],
+            dispatch: {
+                kind: 'control',
+                controlId: 'ultracode',
+            },
+        },
         {
             ...RUNTIME_NEW_SESSION_ACTION,
             primitive: 'session.new',
@@ -236,40 +223,24 @@ function buildClaudeRuntimeDescriptor(input) {
         RUNTIME_STOP_AND_DROP_ACTION,
     ];
     commands.push(...buildNativeSlashCommandDescriptors(runtimeMetadata.commands, new Set(commands.flatMap((command) => [command.id, ...(command.aliases ?? [])]))));
-    const extraRuntimeControls = [
-        {
-            id: 'thinking',
-            label: 'Thinking',
-            description: 'Claude SDK thinking mode. Mid-session changes toggle thinking on or off; display/budget stay session-start scoped.',
-            options: CLAUDE_THINKING_CONTROL_OPTIONS,
-            defaultValue: input.defaults?.thinking ?? 'adaptive',
-            availability: 'setup_and_live',
-            liveBehavior: 'immediate',
-            selectionPolicy: 'inherit',
-        },
-        {
-            id: 'ultracode',
-            label: 'Ultracode',
-            description: 'Enable Claude Code ultracode mode when the selected model supports it.',
-            options: CLAUDE_ULTRACODE_CONTROL_OPTIONS,
-            defaultValue: input.defaults?.ultracode ?? 'off',
-            availability: 'setup_and_live',
-            liveBehavior: 'immediate',
-            selectionPolicy: 'inherit',
-        },
-    ];
     return buildFirstPartyCodingRuntimeDescriptor({
         clientType: 'claude-code',
         models: input.models,
-        defaultModel: input.defaults?.model ?? input.models[0]?.value ?? null,
         workspaces: input.workspaces,
         workspaceRoots: input.workspaceRoots,
         executionModes: input.executionModes,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         effortOptions: [...CLAUDE_EFFORT_OPTIONS],
-        defaultEffort: input.defaults?.effort,
-        extraRuntimeControls,
+        extraRuntimeControls: [{
+                id: 'ultracode',
+                label: 'Ultracode',
+                options: [...CLAUDE_ULTRACODE_OPTIONS],
+                defaultValue: 'off',
+                availability: 'setup_and_live',
+                liveBehavior: 'immediate',
+                selectionPolicy: 'inherit',
+            }],
         streamingTextMode: 'delta',
         turnModes: [
             {
@@ -295,6 +266,36 @@ function buildClaudeRuntimeDescriptor(input) {
         commands,
     });
 }
+const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_OPTIONS.map((option) => option.value));
+function parseClaudePermissionMode(value) {
+    if (value === 'acceptEdits'
+        || value === 'auto'
+        || value === 'bypassPermissions'
+        || value === 'default'
+        || value === 'dontAsk'
+        || value === 'plan') {
+        return value;
+    }
+    return null;
+}
+function normalizeClaudeEffortLevel(value) {
+    return typeof value === 'string' && CLAUDE_EFFORT_VALUES.has(value)
+        ? value
+        : undefined;
+}
+async function applyClaudeEffortLevel(q, effort) {
+    await q.applyFlagSettings({ effortLevel: effort });
+}
+const CLAUDE_ULTRACODE_OPTIONS = [
+    { value: 'on', label: 'On' },
+    { value: 'off', label: 'Off' },
+];
+function parseClaudeUltracodeMode(value) {
+    return value === 'on' || value === 'off' ? value : undefined;
+}
+async function applyClaudeUltracode(q, enabled) {
+    await q.applyFlagSettings({ ultracode: enabled });
+}
 let cachedClaudeCliPath;
 // The SDK bundles a Bun-compiled `claude` Mach-O binary next to
 // claude-agent-sdk-darwin-arm64. On some macOS setups that exact binary gets
@@ -331,36 +332,28 @@ function resolveClaudeCliPath() {
     console.error('[canon-host] claude CLI not on PATH; using SDK-bundled binary');
     return undefined;
 }
-const CLAUDE_SUPPLEMENTAL_MODEL_PROBES = ['opus'];
-function mergeModelOptions(...groups) {
-    const byValue = new Map();
-    for (const group of groups) {
-        for (const option of group) {
-            if (!byValue.has(option.value)) {
-                byValue.set(option.value, option);
-            }
-        }
-    }
-    return [...byValue.values()];
-}
 function toModelOptions(models) {
-    return models.map(claudeModelInfoToOption);
+    return models.map((model) => ({
+        value: model.value,
+        label: model.displayName,
+    }));
 }
-async function publishAgentRuntime(port, runtime) {
-    await port.publishHostAgentRuntime({
-        clientType: 'claude-code',
-        runtime: runtime,
-    });
+async function publishAgentRuntime(agentId, runtime) {
+    await publishHostAgentRuntime(agentId, 'claude-code', runtime);
 }
-async function loadSessionConfig(port, conversationId) {
-    const raw = await port.getSessionConfig({ conversationId });
-    const config = readHostSessionConfig(raw, ['permissionMode', 'effort']);
+async function loadSessionConfig(conversationId, agentId) {
+    const config = await loadHostSessionConfig({
+        conversationId,
+        agentId,
+        extraStringFields: ['permissionMode', 'effort'],
+    });
     return {
         ...config,
         permissionMode: config?.permissionMode
             ? parseClaudePermissionMode(config.permissionMode) ?? undefined
             : undefined,
         effort: normalizeClaudeEffortLevel(config?.effort),
+        ultracode: parseClaudeUltracodeMode(config?.runtimeControlValues?.ultracode),
     };
 }
 function resolveSessionExecutionMode(config) {
@@ -384,21 +377,6 @@ function resolveExecutionFallbackReason(environment) {
         : environment.reason;
 }
 async function detectRuntimeModels(cwd) {
-    const discovered = await detectRuntimeModelsForSelection(cwd, 'default');
-    const supplemental = await Promise.all(CLAUDE_SUPPLEMENTAL_MODEL_PROBES.map(async (model) => {
-        try {
-            const options = await detectRuntimeModelsForSelection(cwd, model);
-            const option = options.find((entry) => entry.value === model);
-            return option && !isClaudeCustomModelOption(option) ? [option] : [];
-        }
-        catch (error) {
-            console.error(`[canon-host] Supplemental Claude model probe failed for ${model}:`, error);
-            return [];
-        }
-    }));
-    return mergeModelOptions(discovered, ...supplemental);
-}
-async function detectRuntimeModelsForSelection(cwd, model) {
     const emptyPrompt = {
         async *[Symbol.asyncIterator]() { },
     };
@@ -408,7 +386,6 @@ async function detectRuntimeModelsForSelection(cwd, model) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
-            model,
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -436,7 +413,6 @@ async function inspectClaudeRuntimeMetadata(cwd, activeQuery) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
-            model: 'default',
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -486,6 +462,9 @@ 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;
@@ -617,22 +596,13 @@ function buildClaudeRuntimeInfo(input) {
                 tier: 'diagnostic',
             }
             : null,
-        input.fallbackModel
+        runtimeModels[0]
             ? {
                 id: 'fallbackModel',
                 label: 'Fallback model',
-                value: input.fallbackModel,
+                value: runtimeModels[0].label,
                 tier: 'diagnostic',
-                source: 'applied',
-            }
-            : null,
-        input.ultracodeEnabled
-            ? {
-                id: 'ultracode',
-                label: 'Ultracode',
-                value: 'Enabled',
-                tier: 'detail',
-                source: 'applied',
+                source: 'host-default',
             }
             : null,
         {
@@ -725,6 +695,9 @@ 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 = {
@@ -793,7 +766,7 @@ async function buildCanonUserContent(input) {
     ];
 }
 // ── Session factory ─────────────────────────────────────────────────
-function createSession(conversationId, environment, agentId, port, typingSignals, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
+function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
     const cardResponseUserId = config.ownerId ?? undefined;
     const cardResponseUser = cardResponseUserId ? { responseUserId: cardResponseUserId } : undefined;
@@ -853,15 +826,48 @@ function createSession(conversationId, environment, agentId, port, typingSignals
     // 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
-    // ── HITL waiters (generic skeleton from @canonmsg/agent-host) ──
-    const hitlWaiters = createHitlWaiters({
-        conversationId,
-        replyTimeoutMs: REPLY_TIMEOUT_MS,
-    }, {
-        session: () => session,
-        port,
-    });
-    const { waitForReply, waitForRuntimeInputResponse } = hitlWaiters;
+    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' };
+    }
     function buildArtifactMediaMetadata() {
         return {
             ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
@@ -873,27 +879,16 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         };
     }
     const claudeCliPath = resolveClaudeCliPath();
-    const initialThinkingConfig = claudeThinkingToConfig(config.sessionSettings.thinking);
     const queryOptions = {
         systemPrompt: { type: 'preset', preset: 'claude_code' },
         tools: { type: 'preset', preset: 'claude_code' },
-        model: config.model ?? 'default',
         permissionMode: parseClaudePermissionMode(config.permissionMode) ?? 'default',
         allowDangerouslySkipPermissions: true,
         cwd,
         includePartialMessages: true,
         maxTurns: 200,
         ...(config.effort ? { effort: config.effort } : {}),
-        ...(initialThinkingConfig ? { thinking: initialThinkingConfig } : {}),
-        ...(config.sessionSettings.fallbackModel ? { fallbackModel: config.sessionSettings.fallbackModel } : {}),
-        agentProgressSummaries: config.sessionSettings.agentProgressSummaries ?? true,
-        ...(config.sessionSettings.agents ? { agents: config.sessionSettings.agents } : {}),
-        settings: {
-            forceLoginMethod: 'claudeai',
-            ...(config.sessionSettings.ultracode
-                ? { ultracode: config.sessionSettings.ultracode === 'on' }
-                : {}),
-        },
+        settings: { forceLoginMethod: 'claudeai' },
         settingSources: ['project', 'local'],
         ...(claudeCliPath ? { pathToClaudeCodeExecutable: claudeCliPath } : {}),
         stderr: (data) => {
@@ -908,27 +903,25 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                     const questionId = randomUUID();
                     const questions = mapClaudeQuestions(input.questions);
                     const expiresAt = Date.now() + REPLY_TIMEOUT_MS;
-                    await port.requestInput({
+                    await client.createRuntimeInputRequest({
                         conversationId,
                         inputId: questionId,
                         kind: 'clarify',
-                        expiresAt: new Date(expiresAt).toISOString(),
+                        expiresAt,
                         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,
-                            ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                            turnId: session.currentTurnId ?? undefined,
                         },
-                        ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                        turnId: session.currentTurnId ?? undefined,
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
                     const reply = await waitForRuntimeInputResponse({ inputId: questionId, expiresAt });
@@ -983,9 +976,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                         ...(cardResponseUser ?? {}),
                         ...(allowedPrompts.length > 0 ? { allowedPrompts } : {}),
                     });
-                    await port.sendMessage({
-                        conversationId,
-                        text: planApproval.text,
+                    await sendMessageWithRetry(client, conversationId, planApproval.text, {
                         messageId: `claude-plan-${planId}`,
                         ...(session.activeSelfContextId
                             ? { selfContextId: session.activeSelfContextId }
@@ -1037,6 +1028,9 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                         if (session.state.permissionMode === 'plan') {
                             session.state.permissionMode = 'default';
                             writeState();
+                            // Converge the app immediately on the SDK-driven plan-mode exit
+                            // instead of waiting for the next 30s heartbeat (lag fix).
+                            config.publishSessionSnapshots?.([conversationId]);
                         }
                         return { behavior: 'allow' };
                     }
@@ -1101,13 +1095,13 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         query: q,
         sendInput,
         enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, artifactRoutingMode),
-        state: buildClaudeInitialSessionState({
-            model: config.model,
+        state: {
+            model: undefined,
             permissionMode: config.permissionMode,
-            effort: config.effort,
-            fallbackModel: config.sessionSettings.fallbackModel,
-            runtimeControlValues: config.sessionSettings.runtimeControlValues,
-        }),
+            effort: undefined,
+            ultracode: undefined,
+            state: 'idle',
+        },
         availableModels: config.availableModels,
         streamingText: '',
         streamingTimer: null,
@@ -1139,92 +1133,155 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         setRuntimeControlError: (controlId, value, error) => setRuntimeControlError(controlId, value, error),
         clearRuntimeControlError: (controlId) => clearRuntimeControlError(controlId),
     };
-    // ── 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: {},
-    }, {
-        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,
+    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);
+        },
     });
-    const { streamingOutput, flushStreaming, onStreamDelta, clearStreaming, getFinalTurnTrail, writeState, writeTurn, setRuntimeControlError, clearRuntimeControlError, refreshVisibleWorkSignal, startVisibleWorkSignal, stopVisibleWorkSignal, } = writers;
-    // Initial values come from persisted session config and are effective for
-    // this query. Publish immediately so controls do not linger as requested.
-    writeState();
+    // ── Per-session streaming helpers ──
+    function flushStreaming() {
+        streamingOutput.flush().catch(() => { });
+    }
+    function onStreamDelta(text, segmentId) {
+        if (segmentId) {
+            streamingOutput.appendTextSegmentDelta(segmentId, text);
+            return;
+        }
+        streamingOutput.appendDelta(text);
+    }
     function isActiveTurnInterrupted() {
         const turnKey = session.activeInput?.turnKey;
         return Boolean(turnKey && session.interruptedTurnKeys.has(turnKey));
     }
-    // ── 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({
+    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,
-            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,
+            finalizedTurnKeys: session.finalizedTurnKeys,
+            interruptedTurnKeys: session.interruptedTurnKeys,
+        })) {
+            return true;
+        }
+        const deliverTurn = turn;
+        if (!deliverTurn)
+            return true;
+        const finalMessageId = buildClaudeFinalMessageId({
+            agentId,
             conversationId,
+            turnKey: deliverTurn.turnKey,
         });
-        return port.sendMessage({
-            conversationId,
-            text: '',
-            contentType: uploaded.attachment.kind,
-            attachments: [uploaded.attachment],
+        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, '', {
             ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
             metadata: buildArtifactMediaMetadata(),
         });
@@ -1261,6 +1318,145 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             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' };
+        }
+        if (session.state.ultracode !== undefined) {
+            controlState.ultracode = { value: session.state.ultracode, source: 'applied', appliedAt };
+        }
+        else if (config.ultracode !== undefined) {
+            controlState.ultracode = { value: config.ultracode, source: 'requested' };
+        }
+        runtimeState.writeSessionState(conversationId, {
+            model: session.state.model,
+            permissionMode: session.state.permissionMode,
+            effort: session.state.effort,
+            ...(session.state.ultracode ? { runtimeControlValues: { ultracode: session.state.ultracode } } : {}),
+            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;
@@ -1276,8 +1472,25 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             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') => {
-        turnQueue.enqueueCanonInput(createClaudeInputEnvelope({
+        session.lastActivity = Date.now();
+        const input = createClaudeInputEnvelope({
             kind: 'canon',
             msg,
             intent,
@@ -1285,11 +1498,35 @@ function createSession(conversationId, environment, agentId, port, typingSignals
             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 ──
-    let assistantStreamOrdinal = 0;
     const processMessages = async () => {
         try {
             for await (const msg of q) {
@@ -1320,10 +1557,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                             stopVisibleWorkSignal();
                             break;
                         }
-                        if (event?.type === 'message_start') {
-                            assistantStreamOrdinal += 1;
-                        }
-                        else if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                        if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
                             session.toolInProgress = true;
                             session.turnState = 'tool';
                             streamingOutput.addBlock({
@@ -1352,35 +1586,12 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                             stopVisibleWorkSignal();
                             writeTurn();
                             const blockIndex = typeof event.index === 'number' ? event.index : 'latest';
-                            const messageOrdinal = assistantStreamOrdinal || 1;
-                            onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${messageOrdinal}:${blockIndex}`);
+                            onStreamDelta(event.delta.text, `text:${session.currentTurnId ?? conversationId}:${blockIndex}`);
                         }
                         break;
                     }
                     case 'system': {
                         const subtype = msg.subtype;
-                        if (subtype === 'task_started'
-                            || subtype === 'task_progress'
-                            || subtype === 'task_updated'
-                            || subtype === 'task_notification') {
-                            const activity = mapClaudeSubagentActivity(msg);
-                            if (activity && !isActiveTurnInterrupted()) {
-                                if (!session.currentTurnId) {
-                                    session.currentTurnId = randomUUID();
-                                    session.currentTurnOpenedAt = Date.now();
-                                }
-                                if (session.state.state === 'running' && session.turnState !== 'streaming') {
-                                    session.turnState = 'thinking';
-                                    startVisibleWorkSignal();
-                                    writeTurn();
-                                }
-                                await streamingOutput.addBlock(activity).catch(() => { });
-                            }
-                        }
-                        if (subtype === 'model_refusal_fallback') {
-                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Model refusal fallback: `
-                                + `${msg.original_model} → ${msg.fallback_model}`);
-                        }
                         if (subtype === 'session_state_changed') {
                             const state = msg.state;
                             session.state.state = state;
@@ -1392,7 +1603,6 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                                 }
                                 session.state.contextUsage = undefined;
                                 session.pendingFinalText = null;
-                                assistantStreamOrdinal = 0;
                                 session.toolInProgress = false;
                                 session.turnState = 'thinking';
                                 startVisibleWorkSignal();
@@ -1489,6 +1699,33 @@ function createSession(conversationId, environment, agentId, port, typingSignals
     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 (config.effort) {
+            try {
+                await applyClaudeEffortLevel(q, config.effort);
+                session.state.effort = config.effort;
+            }
+            catch (err) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial effort:`, err);
+            }
+        }
+        if (config.ultracode) {
+            try {
+                await applyClaudeUltracode(q, config.ultracode === 'on');
+                session.state.ultracode = config.ultracode;
+            }
+            catch (err) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to set initial ultracode:`, err);
+            }
+        }
         if (!resumeSessionId) {
             // New session — send seed message to activate streaming input mode
             sendInput(createClaudeInputEnvelope({
@@ -1503,32 +1740,25 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                 },
             }));
         }
-        // Refresh the canonical runtime descriptor from a neutral probe. The live
-        // session may be initialized with a selected model, which can narrow the
-        // SDK's cached model list.
+        // Refresh the canonical runtime descriptor after Claude reports supported models.
         try {
-            const discoveredModels = await detectRuntimeModels(cwd).catch((error) => {
-                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Model discovery failed:`, error);
-                return runtimeModels;
-            });
-            if (discoveredModels.length > 0) {
-                runtimeModels = discoveredModels;
-            }
-            const modelList = resolveClaudeModelOptions({
-                discovered: runtimeModels,
+            const models = await q.supportedModels();
+            const modelList = mergeClaudeModelOptions({
+                previous: runtimeModels,
+                next: toModelOptions(models),
                 selectedModel: session.state.model,
             });
             session.availableModels = modelList;
+            runtimeModels = modelList;
             onRuntimeDescriptorUpdate({
                 defaultWorkspaceId: workspaceOptions[0]?.id,
-                defaultModel: config.sessionSettings.model ?? modelList[0]?.value,
+                defaultModel: modelList[0]?.value,
                 defaultPermissionMode: 'default',
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 availableExecutionModes: config.availableExecutionModes,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: modelList,
-                    defaults: config.sessionSettings,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: config.availableExecutionModes,
@@ -1536,7 +1766,7 @@ function createSession(conversationId, environment, agentId, port, typingSignals
                 }),
             });
             writeState();
-            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Models: ${modelList.map((m) => m.label).join(', ')}`);
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Models: ${models.map((m) => m.displayName).join(', ')}`);
         }
         catch {
             writeState();
@@ -1581,57 +1811,41 @@ export async function main() {
     for (const warning of workspaceDiscovery.warnings) {
         console.error(`[canon-host] ${warning}`);
     }
-    const { agentName: profileAgentName, profile, sessionDefaults: rawSessionDefaults, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
-    const profileSessionDefaults = parseClaudeSessionDefaults(rawSessionDefaults);
-    activeLockHandle = lockHandle ?? null;
+    const { apiKey, agentId: profileAgentId, agentName: profileAgentName, profile, baseUrl, lockHandle, } = resolveCanonAgent({ logPrefix: '[canon-host]', expectedClientType: 'claude-code' });
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
-    // ── 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}`);
+    // ── 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),
     });
-    const typingSignals = createPortTypingSignals(port);
     async function markQueuedMessageAcceptedForConversation(conversationId, sourceMessageId, markAccepted) {
         if (!markAccepted || !sourceMessageId)
             return;
-        await port.setDisposition({
-            conversationId,
-            messageId: sourceMessageId,
-            inboundDisposition: 'accepted_now',
-        }).catch(() => { });
+        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}`);
     }
-    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);
@@ -1660,6 +1874,11 @@ 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,
@@ -1672,40 +1891,39 @@ export async function main() {
     });
     let runtimeDescriptor = {
         defaultWorkspaceId: workspaceOptions[0]?.id,
-        defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
         defaultPermissionMode: 'default',
         availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         availableExecutionModes: hostAvailableExecutionModes,
         runtimeDescriptor: buildClaudeRuntimeDescriptor({
             models: runtimeModels,
-            defaults: profileSessionDefaults,
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
             presentation: runtimePresentation,
         }),
     };
-    // ── 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 publishSessionSnapshotsForConversations = async (conversationIds) => {
-        const ids = Array.from(new Set(conversationIds));
-        if (!streamConnected || ids.length === 0)
+    const conversationCache = new Map();
+    const knownConversationIds = new Set();
+    const promptedGroupContextConversationIds = new Set();
+    const pendingMembershipChanges = new Map();
+    let lastKnownConversationRefreshAt = 0;
+    // Publish the app-subscribed /agent-session snapshot for the given
+    // conversations. Extracted from the heartbeat so control handlers can converge
+    // the app immediately instead of waiting for the next 30s heartbeat
+    // (session-control lag fix). Hoisted so it is reachable from earlier code.
+    async function publishSessionSnapshots(conversationIds) {
+        if (!streamConnected || conversationIds.length === 0)
             return;
-        await port.publishHostSessionSnapshots({
-            conversationIds: ids,
+        await publishHostSessionSnapshots({
+            conversationIds,
+            agentId,
             clientType: 'claude-code',
             runtime: runtimeDescriptor,
-            workspaceOptions: workspaceOptions.map(({ id, cwd }) => ({ id, cwd })),
+            workspaceOptions,
             defaultCwd: workingDir,
             extraSessionConfigFields: ['permissionMode', 'effort'],
-            liveSessionConfigByConversation: Object.fromEntries(Array.from(sessions.values()).map((session) => {
+            liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
                 const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
                 return [
                     session.conversationId,
@@ -1713,9 +1931,7 @@ export async function main() {
                         ...(session.state.model ? { model: session.state.model } : {}),
                         ...(session.state.permissionMode ? { permissionMode: session.state.permissionMode } : {}),
                         ...(session.state.effort ? { effort: session.state.effort } : {}),
-                        ...(session.state.runtimeControlValues
-                            ? { runtimeControlValues: session.state.runtimeControlValues }
-                            : {}),
+                        ...(session.state.ultracode ? { runtimeControlValues: { ultracode: session.state.ultracode } } : {}),
                         ...(workspaceId ? { workspaceId } : {}),
                         executionMode: session.environment.mode,
                         executionBranch: session.environment.branch ?? null,
@@ -1725,7 +1941,7 @@ export async function main() {
         }).catch((error) => {
             console.error('[canon-host] Failed to publish session snapshots:', error);
         });
-    };
+    }
     const publishRuntimeHeartbeat = async () => {
         heartbeatLocalRuntimeEntry(runtimeId, {
             agentId,
@@ -1746,20 +1962,18 @@ export async function main() {
             console.error('[canon-host] Failed to refresh Claude runtime metadata:', error);
             return runtimeMetadata;
         });
-        await publishAgentRuntime(port, runtimeDescriptor).catch((error) => {
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
             console.error('[canon-host] Failed to publish agent runtime:', error);
         });
-        await publishSessionSnapshotsForConversations(knownConversationIds);
+        await publishSessionSnapshots(Array.from(knownConversationIds));
         // Rebuild so the descriptor picks up native slash commands from the
         // metadata refresh above — the initial descriptor is built before the
         // command inventory has loaded.
         if (runtimeDescriptor.runtimeDescriptor) {
             runtimeDescriptor = {
                 ...runtimeDescriptor,
-                defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: runtimeModels,
-                    defaults: profileSessionDefaults,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: hostAvailableExecutionModes,
@@ -1787,15 +2001,8 @@ export async function main() {
                 executionBranch: session?.environment.branch ?? null,
                 worktreePath: session?.environment.worktreePath ?? null,
                 fallbackReason: resolveExecutionFallbackReason(session?.environment),
-                fallbackModel: session?.state.fallbackModel
-                    ?? profileSessionDefaults.fallbackModel
-                    ?? null,
-                ultracodeEnabled: (session?.state.runtimeControlValues?.ultracode ?? profileSessionDefaults.ultracode) === 'on',
-            });
-            await port.publishRuntimeStatus({
-                conversationId,
-                presentation: payload,
             });
+            await runtimeState.writeRuntimeInfo(conversationId, payload);
         })).catch((error) => {
             console.error('[canon-host] Failed to publish runtime info:', error);
         });
@@ -1805,7 +2012,7 @@ export async function main() {
         runtimeModels = await detectRuntimeModels(workingDir);
         runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
-            defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
+            defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableModels: runtimeModels,
@@ -1813,7 +2020,6 @@ export async function main() {
             availableExecutionModes: hostAvailableExecutionModes,
             runtimeDescriptor: buildClaudeRuntimeDescriptor({
                 models: runtimeModels,
-                defaults: profileSessionDefaults,
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
@@ -1824,14 +2030,12 @@ export async function main() {
     catch {
         runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
-            defaultModel: profileSessionDefaults.model ?? runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
             runtimeDescriptor: buildClaudeRuntimeDescriptor({
                 models: runtimeModels,
-                defaults: profileSessionDefaults,
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
@@ -1840,12 +2044,14 @@ export async function main() {
         };
     }
     try {
-        const convos = await directory.listConversations();
-        directory.primeFromStartup(convos);
+        const convos = await client.getConversations();
+        lastKnownConversationRefreshAt = Date.now();
         for (const conversation of convos) {
-            port.clearStreaming({ conversationId: conversation.id }).catch(() => { });
-            port.clearSessionState({ conversationId: conversation.id }).catch(() => { });
-            port.clearTurnState({ conversationId: conversation.id }).catch(() => { });
+            knownConversationIds.add(conversation.id);
+            conversationCache.set(conversation.id, conversation);
+            runtimeState.clearStreaming(conversation.id).catch(() => { });
+            runtimeState.clearSessionState(conversation.id).catch(() => { });
+            runtimeState.clearTurnState(conversation.id).catch(() => { });
             typingSignals.clear(conversation.id).catch(() => { });
         }
         console.error(`[canon-host] ${convos.length} conversations`);
@@ -1853,68 +2059,64 @@ export async function main() {
     catch {
         console.error('[canon-host] Could not load conversations');
     }
-    // ── 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();
+    // ── 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',
         },
-        onShutdownComplete: () => {
-            markLocalRuntimeStopped(runtimeId);
-            lockHandle?.release();
+        pollOnStart: true,
+        conversationConcurrency: 'sequential',
+        handlers: {
+            session: { handle: applyRuntimeSessionControl },
+            signal: { handle: handleRuntimeControlSignal },
+        },
+        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);
         },
-    });
-    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;
@@ -1922,9 +2124,80 @@ export async function main() {
             .catch(() => conversationCache.get(conversationId) ?? null);
         return Array.isArray(conversation?.memberIds) && conversation.memberIds.includes(ownerId);
     }
-    /** Resume-state persistence on session close (claude-specific: SDK sessionId). */
-    function persistResumeState(session, saveResume) {
-        const conversationId = session.conversationId;
+    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);
         const resumeKey = buildConversationEnvironmentKey(conversationId, session.environment.baseCwd);
         if (saveResume && session.sdkSessionId) {
             savedSessionIds.set(resumeKey, session.sdkSessionId);
@@ -1956,15 +2229,89 @@ 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')}`);
     }
-    /** Runtime-specific session construction, invoked via the lifecycle's getOrCreateSession. */
-    function createSessionForConversation(conversationId) {
-        return (async () => {
-            const config = await loadSessionConfig(port, conversationId);
-            const sessionSettings = resolveEffectiveSessionSettings({
-                profileDefaults: profileSessionDefaults,
-                sessionConfig: config,
-            });
+    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);
             const sessionExecutionMode = resolveSessionExecutionMode(config);
             const workspaceCwd = resolveWorkspaceCwd(config);
             const environment = prepareConversationEnvironment({
@@ -1981,7 +2328,7 @@ export async function main() {
                     executionMode: environment.mode,
                 });
                 const resumeId = savedSessionIds.get(resumeKey) ?? persisted?.claudeSessionId;
-                const session = createSession(conversationId, environment, agentId, port, typingSignals, (convoId, sdkSessionId) => {
+                const session = createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, (convoId, sdkSessionId) => {
                     // Called when session processing loop ends — save session ID for resume
                     const existing = sessions.get(convoId);
                     if (existing) {
@@ -2005,17 +2352,18 @@ export async function main() {
                     }
                     existing?.clearStreaming().catch(() => { });
                     typingSignals.clear(convoId).catch(() => { });
+                    typingSignals.dispose(convoId);
                     sessions.delete(convoId);
-                    port.clearSessionState({ conversationId: convoId }).catch(() => { });
-                    port.clearTurnState({ conversationId: convoId }).catch(() => { });
+                    runtimeState.clearSessionState(convoId).catch(() => { });
+                    runtimeState.clearTurnState(convoId).catch(() => { });
                 }, (descriptor) => {
                     runtimeDescriptor = descriptor;
                     void publishRuntimeHeartbeat();
                 }, {
-                    model: sessionSettings.model ?? runtimeModels[0]?.value,
+                    model: config?.model ?? runtimeModels[0]?.value,
                     permissionMode: config?.permissionMode ?? 'default',
-                    effort: sessionSettings.effort,
-                    sessionSettings,
+                    effort: config?.effort,
+                    ultracode: config?.ultracode,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
                     runtimePresentation,
@@ -2023,8 +2371,10 @@ export async function main() {
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
                     ownerId,
+                    publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
                 }, resumeId);
                 sessions.set(conversationId, session);
+                await controlPoller.baseline([conversationId]);
                 return session;
             }
             catch (error) {
@@ -2032,6 +2382,13 @@ 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;
@@ -2088,9 +2445,7 @@ 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 port.sendMessage({
-                conversationId: input.conversationId,
-                text: `I couldn't start a coding session for this workspace: ${userMessage}`,
+            await sendMessageWithRetry(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
                 messageId: `claude-start-failed-${m.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
@@ -2133,261 +2488,307 @@ export async function main() {
             });
         }
     }
-    try {
-        for (const conversation of conversationCache.values()) {
-            const cursor = loadRuntimeSessionState(runtimeId, {
-                conversationId: conversation.id,
-                baseCwd: workingDir,
-            })?.lastInboundMessageId;
-            const recovery = await collectMissedInboundMessages({
-                fetchPage: (before) => port.getMessages({
-                    conversationId: conversation.id,
-                    limit: STARTUP_RECOVERY_PAGE_SIZE,
-                    ...(before ? { before } : {}),
-                    includeBehavior: true,
-                }),
-                cursor,
-                agentId,
-            });
-            if (recovery.mode === 'truncated-window') {
-                console.error(`[canon-host] [${conversation.id.slice(0, 8)}] Startup recovery cursor not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; recovering truncated window`);
-            }
-            if (recovery.messages.length > 1) {
-                console.error(`[canon-host] [${conversation.id.slice(0, 8)}] Recovered ${recovery.messages.length} missed messages in ${conversation.id}`);
-            }
-            for (const message of recovery.messages) {
-                console.error(`[canon-host] [${conversation.id.slice(0, 8)}] Recovering inbound message on startup`);
-                await enqueueRecoveredInboundMessage({
-                    conversationId: conversation.id,
-                    message: message,
-                    hydratedPage: recovery.newestPage,
-                });
-            }
-        }
-    }
-    catch (error) {
-        console.error('[canon-host] Failed startup recovery:', error instanceof Error ? error.message : error);
-    }
-    // ── 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 });
+    // ── 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;
+                    }
                 }
-                catch (error) {
-                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
+                // 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;
+                    }
                 }
-            }
-            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',
+                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;
                 }
-                : 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') {
+                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: () => {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
-                console.error('[canon-host] Canon upstream connected');
-            }
-            else {
+                console.error('[canon-host] SSE connected');
+            },
+            onDisconnected: () => {
                 streamConnected = false;
-                port.clearAgentRuntime().catch(() => { });
-                console.error(`[canon-host] Canon upstream ${upstream}`);
-            }
+                runtimeState.clearAgentRuntime().catch(() => { });
+                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 ──
-    // Session control signals (model, mode, effort). The bridge has already
-    // consumed the control notification, so every path must publish an answer.
+    // Session control signals (model, mode, effort). A missing/closed session
+    // leaves the node in place; lastSeen still advances, so a stale control is
+    // never replayed once a session exists.
     async function applyRuntimeSessionControl(event) {
         const convoId = event.conversationId;
         const session = sessions.get(convoId);
-        if (!session || session.closed) {
-            console.error(`[canon-host] [${convoId.slice(0, 8)}] Control received without live session; publishing persisted snapshot`);
-            void publishSessionSnapshotsForConversations([convoId]);
-            return;
-        }
+        if (!session || session.closed)
+            return { consume: false };
         const ctrl = event.control;
         console.error(`[canon-host] [${convoId.slice(0, 8)}] Control:`, ctrl);
-        applyClaudeSessionControl(session, ctrl);
+        await applyClaudeSessionControl({
+            model: ctrl.model,
+            permissionMode: ctrl.permissionMode,
+            effort: ctrl.effort,
+            ultracode: ctrl.runtimeControlValues?.ultracode,
+        }, {
+            state: session.state,
+            parsePermissionMode: parseClaudePermissionMode,
+            normalizeEffort: normalizeClaudeEffortLevel,
+            parseUltracode: parseClaudeUltracodeMode,
+            setModel: (model) => session.query.setModel(model),
+            setPermissionMode: (mode) => session.query.setPermissionMode(mode),
+            applyEffort: (level) => applyClaudeEffortLevel(session.query, level),
+            applyUltracode: (enabled) => applyClaudeUltracode(session.query, enabled),
+            setRuntimeControlError: (controlId, value, error) => session.setRuntimeControlError(controlId, value, error),
+            clearRuntimeControlError: (controlId) => session.clearRuntimeControlError(controlId),
+            // Publish the app-subscribed snapshot immediately so the control-pending
+            // gate clears now instead of at the next 30s heartbeat (lag fix).
+            publishSnapshot: () => { void publishSessionSnapshots([convoId]); },
+        });
+        session.writeState();
     }
-    // ── Heartbeat + idle cleanup + graceful shutdown (agent-host lifecycle) ──
-    lifecycle.startTimers();
-    lifecycle.installSignalHandlers();
+    // 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);
     console.error('[canon-host] Ready — sessions created on demand');
     // Keep alive
     await new Promise(() => { });
@@ -2396,7 +2797,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}`);
-    activeLockHandle?.release();
+    getActiveProfileLock()?.release();
     process.exit(1);
 }, {
     name: 'canon-claude',