@canonmsg/claude-code-plugin 0.25.0 → 0.25.3

package/dist/host.js

@@ -28,12 +28,14 @@ import { readFile } from 'node:fs/promises';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
 import { captureTurnArtifactSnapshot, collectTurnArtifacts, } from '@canonmsg/coding-agent-host';
-import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonInboundFrameV1, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, 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, RuntimeRequestManager, 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 { 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, 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, RuntimeRequestManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, readLocalRuntimeEntry, resolveCanonAgent, initRTDBAuth, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, shouldTriggerAgentTurn, 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, createClaudeInputEnvelope, formatClaudeControlError, mergeClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { applyClaudeSessionControl, buildClaudeFinalMessageId, claudeModelInfoToOption, confirmClaudeInterrupt, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, mergeClaudeDiscoveredModelOptions, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
+import { collectMissedInboundMessages, STARTUP_RECOVERY_MAX_MESSAGES, STARTUP_RECOVERY_PAGE_SIZE, } from './startup-recovery.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -309,6 +311,7 @@ function resolveClaudeCliPath() {
     const override = process.env.CANON_CLAUDE_CLI_PATH?.trim();
     if (override) {
         if (existsSync(override)) {
+            assertExternalClaudeCliVersion(override);
             cachedClaudeCliPath = override;
             console.error(`[canon-host] claude CLI override: ${override}`);
             return override;
@@ -320,6 +323,7 @@ function resolveClaudeCliPath() {
             encoding: 'utf8',
         }).trim();
         if (resolved && existsSync(resolved)) {
+            assertExternalClaudeCliVersion(resolved);
             cachedClaudeCliPath = resolved;
             console.error(`[canon-host] claude CLI on PATH: ${resolved}`);
             return resolved;
@@ -332,11 +336,25 @@ function resolveClaudeCliPath() {
     console.error('[canon-host] claude CLI not on PATH; using SDK-bundled binary');
     return undefined;
 }
+function assertExternalClaudeCliVersion(cliPath) {
+    const output = execFileSync(cliPath, ['--version'], { encoding: 'utf8' }).trim();
+    const match = output.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match) {
+        throw new Error(`Could not determine Claude Code version from: ${output}`);
+    }
+    const installed = match.slice(1, 4).map(Number);
+    const minimum = [2, 1, 201];
+    const supported = installed.some((value, index) => {
+        if (value === minimum[index])
+            return false;
+        return value > minimum[index] && installed.slice(0, index).every((part, partIndex) => part === minimum[partIndex]);
+    }) || installed.every((value, index) => value === minimum[index]);
+    if (!supported) {
+        throw new Error(`Claude Code ${minimum.join('.')} or newer is required; found ${match[0]}.`);
+    }
+}
 function toModelOptions(models) {
-    return models.map((model) => ({
-        value: model.value,
-        label: model.displayName,
-    }));
+    return models.map(claudeModelInfoToOption);
 }
 async function publishAgentRuntime(agentId, runtime) {
     await publishHostAgentRuntime(agentId, 'claude-code', runtime);
@@ -376,7 +394,28 @@ function resolveExecutionFallbackReason(environment) {
         ? null
         : environment.reason;
 }
+const CLAUDE_SUPPLEMENTAL_MODEL_PROBES = ['opus', 'fable'];
 async function detectRuntimeModels(cwd) {
+    const [discovered, supplemental] = await Promise.all([
+        detectRuntimeModelsForSelection(cwd, 'default'),
+        detectSupplementalRuntimeModels(cwd),
+    ]);
+    return mergeClaudeDiscoveredModelOptions(discovered, ...supplemental);
+}
+async function detectSupplementalRuntimeModels(cwd) {
+    return 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 [];
+        }
+    }));
+}
+async function detectRuntimeModelsForSelection(cwd, model) {
     const emptyPrompt = {
         async *[Symbol.asyncIterator]() { },
     };
@@ -386,6 +425,7 @@ async function detectRuntimeModels(cwd) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
+            model,
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -413,6 +453,7 @@ 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' },
@@ -465,78 +506,6 @@ async function refreshClaudeRuntimeMetadata(input) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function mapClaudeQuestions(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const questions = value.slice(0, 12).flatMap((entry) => {
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
-            return [];
-        const record = entry;
-        const id = typeof record.id === 'string' && record.id.trim()
-            ? record.id.trim().slice(0, 120)
-            : typeof record.question === 'string' && record.question.trim()
-                ? record.question.trim().slice(0, 80).replace(/[^A-Za-z0-9_.:-]+/g, '-')
-                : null;
-        const question = typeof record.question === 'string' && record.question.trim()
-            ? record.question.trim().slice(0, 1000)
-            : null;
-        if (!id || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id) || !question)
-            return [];
-        const header = typeof record.header === 'string' && record.header.trim()
-            ? record.header.trim().slice(0, 120)
-            : undefined;
-        const rawOptions = Array.isArray(record.options) ? record.options : [];
-        const choices = rawOptions.slice(0, 12).flatMap((option) => {
-            if (!option || typeof option !== 'object' || Array.isArray(option))
-                return [];
-            const optionRecord = option;
-            const label = typeof optionRecord.label === 'string' && optionRecord.label.trim()
-                ? optionRecord.label.trim().slice(0, 120)
-                : typeof optionRecord.value === 'string' && optionRecord.value.trim()
-                    ? optionRecord.value.trim().slice(0, 120)
-                    : null;
-            if (!label)
-                return [];
-            const optionValue = typeof optionRecord.value === 'string' && optionRecord.value.trim()
-                ? optionRecord.value.trim().slice(0, 120)
-                : label;
-            const description = typeof optionRecord.description === 'string' && optionRecord.description.trim()
-                ? optionRecord.description.trim().slice(0, 240)
-                : undefined;
-            const preview = typeof optionRecord.preview === 'string' && optionRecord.preview.trim()
-                ? optionRecord.preview.trim().slice(0, 4000)
-                : undefined;
-            return [{
-                    label,
-                    value: optionValue,
-                    ...(description ? { description } : {}),
-                    ...(preview ? { preview } : {}),
-                }];
-        });
-        return [{
-                id,
-                question,
-                ...(header ? { header } : {}),
-                ...(choices.length ? { choices } : {}),
-                // Mac-app parity: AskUserQuestion always offers a free-text "Other" escape
-                // hatch (the SDK adds it client-side, not via the tool schema). Default it
-                // on for choice questions unless the agent explicitly opted out.
-                ...(resolveQuestionAllowOther(choices.length > 0, record.allowOther ?? record.isOther)
-                    ? { allowOther: true }
-                    : {}),
-                ...(record.isSecret === true ? { isSecret: true } : {}),
-                ...(record.multiSelect === true ? { multiSelect: true } : {}),
-            }];
-    });
-    return questions.length ? questions : undefined;
-}
-function flattenRuntimeInputAnswers(answers) {
-    const flattened = {};
-    for (const [questionId, answer] of Object.entries(answers ?? {})) {
-        flattened[questionId] = answer.answers.join(', ');
-    }
-    return flattened;
-}
 /** Pre-image reader for approval diff synthesis: missing file → null (Write creates it). */
 async function readApprovalDiffPreImage(filePath) {
     try {
@@ -700,6 +669,7 @@ 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_RECOVERY_CURSOR_WORKSPACE_ID = 'claude-recovery-cursor-v1';
 const CLAUDE_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
@@ -768,7 +738,6 @@ async function buildCanonUserContent(input) {
 // ── Session factory ─────────────────────────────────────────────────
 function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
-    const cardResponseUserId = config.ownerId ?? undefined;
     // Per-session input stream with message queue
     let resolveInput = null;
     let inputDone = false;
@@ -784,7 +753,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             messageQueue.push(input);
         }
     };
-    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => {
+    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => {
         sendInput(createClaudeInputEnvelope({
             kind: 'canon',
             msg,
@@ -792,6 +761,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             sourceMessageId,
             markAccepted,
             isOwnerTurn,
+            requestingUserId,
             artifactRoutingMode,
         }));
     };
@@ -825,7 +795,53 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     // eslint-disable-next-line prefer-const -- session must be declared before queryOptions but assigned after query()
     let session;
     const REPLY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-    function waitForReply(type, requestId) {
+    const coordinateUserDialog = createClaudeUserDialogCoordinator();
+    async function requestClaudeUserDialog(dialog, nativeRequestId, signal) {
+        const questionId = /^[A-Za-z0-9_.:-]{1,160}$/.test(nativeRequestId)
+            ? nativeRequestId
+            : randomUUID();
+        const responseRouting = resolveClaudeTurnResponseRouting(session.activeInput, config.ownerId, dialog.questions.some((question) => question.isSecret));
+        const responseUserId = responseRouting.responseUserId;
+        if (!responseUserId) {
+            return buildClaudeAskUserPermissionDenied('No eligible human participant can answer this question.');
+        }
+        return coordinateUserDialog(questionId, async () => {
+            try {
+                const reply = await config.runtimeInputManager.request('input', conversationId, {
+                    kind: 'clarify',
+                    title: 'Claude needs input',
+                    prompt: 'Claude needs your input to continue.',
+                    questions: dialog.questions,
+                    sensitive: dialog.questions.some((question) => question.isSecret),
+                    responseUserId,
+                    native: {
+                        runtime: 'claude-code',
+                        method: 'AskUserQuestion',
+                        requestId: nativeRequestId,
+                        turnId: session.currentTurnId ?? undefined,
+                    },
+                    turnId: session.currentTurnId ?? undefined,
+                }, {
+                    requestId: questionId,
+                    expiresAt: Date.now() + REPLY_TIMEOUT_MS,
+                    responderPolicy: 'infer',
+                    signal,
+                    onCreated: () => {
+                        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
+                        session.lastActivity = Date.now();
+                    },
+                });
+                if (reply.status === 'submitted') {
+                    return buildClaudeAskUserPermissionResult(dialog, reply);
+                }
+                return buildClaudeAskUserPermissionDenied(reply.status === 'timeout' ? 'No reply received (timed out)' : 'The user cancelled this question.');
+            }
+            catch {
+                return buildClaudeAskUserPermissionDenied(signal.aborted ? 'The question was interrupted.' : 'No reply received (timed out)');
+            }
+        });
+    }
+    function waitForReply(type, requestId, responseUserId) {
         // Keep session alive while waiting for user input
         session.lastActivity = Date.now();
         return new Promise((resolve, reject) => {
@@ -836,6 +852,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             session.pendingReply = {
                 type,
                 requestId,
+                responseUserId,
                 resolve: (metadata) => {
                     clearTimeout(timer);
                     resolve(metadata);
@@ -857,6 +874,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     const queryOptions = {
         systemPrompt: { type: 'preset', preset: 'claude_code' },
         tools: { type: 'preset', preset: 'claude_code' },
+        model: 'default',
         permissionMode: parseClaudePermissionMode(config.permissionMode) ?? 'default',
         allowDangerouslySkipPermissions: true,
         cwd,
@@ -872,61 +890,30 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 console.error(`[claude-cli] [${conversationId.slice(0, 8)}] ${trimmed}`);
             }
         },
-        canUseTool: async (toolName, input) => {
+        supportedDialogKinds: [...CLAUDE_SUPPORTED_DIALOG_KINDS],
+        onUserDialog: async (request, { signal }) => {
+            const dialog = parseClaudeAskUserDialog(request);
+            if (!dialog)
+                return { behavior: 'cancelled' };
+            const nativeRequestId = resolveClaudeUserDialogRequestId(request, dialog) ?? randomUUID();
+            const result = await requestClaudeUserDialog(dialog, nativeRequestId, signal);
+            return signal.aborted ? { behavior: 'cancelled' } : { behavior: 'completed', result };
+        },
+        canUseTool: async (toolName, input, options) => {
             if (toolName === 'AskUserQuestion') {
-                try {
-                    const questionId = randomUUID();
-                    const questions = mapClaudeQuestions(input.questions);
-                    const expiresAt = Date.now() + REPLY_TIMEOUT_MS;
-                    // Create + poll fold onto the shared spine. `responderPolicy: 'infer'`
-                    // keeps the claude host's responder rule byte-identical (explicit
-                    // `cardResponseUserId` wins, else omit — never the manager's ownerId
-                    // fallback), and `native` carries the claude-specific descriptor.
-                    const reply = await config.runtimeInputManager.request('input', conversationId, {
-                        kind: 'clarify',
-                        title: 'Claude needs input',
-                        prompt: questions?.length
-                            ? 'Claude needs your input to continue.'
-                            : 'Claude needs input to continue.',
-                        ...(questions ? { questions } : {}),
-                        sensitive: Boolean(questions?.some((question) => question.isSecret)),
-                        responseUserId: cardResponseUserId,
-                        native: {
-                            runtime: 'claude-code',
-                            method: 'AskUserQuestion',
-                            requestId: questionId,
-                            turnId: session.currentTurnId ?? undefined,
-                        },
-                        turnId: session.currentTurnId ?? undefined,
-                    }, {
-                        requestId: questionId,
-                        expiresAt,
-                        responderPolicy: 'infer',
-                        onCreated: () => {
-                            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
-                            session.lastActivity = Date.now();
-                        },
-                    });
-                    if (reply.status !== 'submitted') {
-                        return { behavior: 'deny', message: 'No reply received (timed out)' };
-                    }
+                const dialog = parseClaudeAskUserToolInput(input, options.toolUseID);
+                if (!dialog)
+                    return buildClaudeAskUserPermissionDenied('Claude did not provide a valid question.');
+                return requestClaudeUserDialog(dialog, options.toolUseID, options.signal);
+            }
+            const turnResponseRouting = resolveClaudeTurnResponseRouting(session.activeInput, config.ownerId);
+            if (toolName === 'ExitPlanMode') {
+                if (!turnResponseRouting.responseUserId) {
                     return {
-                        behavior: 'allow',
-                        updatedInput: {
-                            ...input,
-                            answers: reply.answers
-                                ? flattenRuntimeInputAnswers(reply.answers)
-                                : reply.value
-                                    ? { answer: reply.value }
-                                    : {},
-                        },
+                        behavior: 'deny',
+                        message: 'No eligible human participant can review this plan.',
                     };
                 }
-                catch {
-                    return { behavior: 'deny', message: 'No reply received (timed out)' };
-                }
-            }
-            if (toolName === 'ExitPlanMode') {
                 try {
                     const planId = randomUUID();
                     const allowedPrompts = Array.isArray(input.allowedPrompts)
@@ -962,21 +949,21 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         title: 'Plan ready for review.',
                         summary: 'Claude has prepared a plan and is asking permission to continue.',
                         ...(planBody ? { body: planBody } : {}),
-                        ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
+                        responseUserId: turnResponseRouting.responseUserId,
                         ...(allowedPrompts.length > 0 ? { allowedPrompts } : {}),
                         ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
+                        expiresAt: Date.now() + REPLY_TIMEOUT_MS,
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
-                    const reply = await waitForReply('plan_approval_reply', planId);
+                    const reply = await waitForReply('plan_approval_reply', planId, turnResponseRouting.responseUserId);
                     if (reply.decision === 'approve') {
                         // Honor opt-in selective grants: when the card sent an explicit
                         // granted subset, pre-approve those tools as session rules so they
                         // do not re-prompt. Owner-turn only; absent grants preserve the
                         // legacy behavior (each tool still prompts individually).
-                        const isOwnerTurn = session.activeInput?.kind === 'canon'
-                            ? session.activeInput.isOwnerTurn === true
-                            : true;
-                        if (isOwnerTurn && config.approvalManager && Array.isArray(reply.grantedPrompts)) {
+                        if (turnResponseRouting.allowSessionRule
+                            && config.approvalManager
+                            && Array.isArray(reply.grantedPrompts)) {
                             // Only pre-approve tools the plan actually offered, and bound the
                             // count/length to match parseSessionRule's caps — grantedPrompts
                             // is untrusted wire metadata, not the validated approval path.
@@ -1036,9 +1023,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 conversationId,
                 runtimeId: config.runtimeId,
                 turnId: session.currentTurnId,
-                isOwnerTurn: session.activeInput?.kind === 'canon'
-                    ? session.activeInput.isOwnerTurn === true
-                    : true,
+                isOwnerTurn: turnResponseRouting.isOwnerTurn,
+                responseUserId: turnResponseRouting.responseUserId,
+                allowSessionRule: turnResponseRouting.allowSessionRule,
                 approvalManager: config.approvalManager,
                 canRequestApproval: config.canRequestApproval,
                 allowedNonOwnerTools: allowedNonOwnerClaudeTools,
@@ -1073,7 +1060,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         environment,
         query: q,
         sendInput,
-        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, artifactRoutingMode),
+        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, requestingUserId, artifactRoutingMode),
         state: {
             model: undefined,
             permissionMode: config.permissionMode,
@@ -1103,12 +1090,14 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         lastAcceptedIntent: null,
         lastActivity: Date.now(),
         typingKeepaliveTimer: null,
+        controlInterruptPending: false,
         closed: false,
         sdkSessionId: resumeSessionId || null,
         pendingReply: null,
         writeState: () => writeState(),
         writeTurn: () => writeTurn(),
         clearStreaming: () => clearStreaming(),
+        markInputCompleted: (input) => markInputCompleted(input),
         setRuntimeControlError: (controlId, value, error) => setRuntimeControlError(controlId, value, error),
         clearRuntimeControlError: (controlId) => clearRuntimeControlError(controlId),
     };
@@ -1153,6 +1142,24 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     function clearStreaming() {
         return streamingOutput.clear().catch(() => { });
     }
+    function markInputCompleted(input) {
+        if (input?.kind !== 'canon' || !input.sourceMessageId)
+            return;
+        if (config.runtimeId) {
+            try {
+                saveRuntimeSessionState(config.runtimeId, {
+                    conversationId,
+                    baseCwd: config.recoveryBaseCwd ?? environment.baseCwd,
+                    workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
+                    lastInboundMessageId: input.sourceMessageId,
+                });
+            }
+            catch (error) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to persist inbound recovery cursor:`, error instanceof Error ? error.message : error);
+            }
+        }
+        config.onInputCompleted?.(input.sourceMessageId);
+    }
     function getFinalTurnTrail() {
         const turnId = session.currentTurnId ?? `claude-${conversationId}`;
         return streamingOutput.getFinalTrail().map((block) => ({ ...block, turnId }));
@@ -1246,6 +1253,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 },
             });
             session.finalizedTurnKeys.add(deliverTurn.turnKey);
+            markInputCompleted(deliverTurn);
             session.state.state = 'idle';
             session.pendingFinalDelivery = null;
             clearFinalDeliveryTimer();
@@ -1458,7 +1466,10 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         sendInput(input);
     }
     function drainPendingInput() {
-        if (session.closed || session.state.state === 'running' || session.pendingInputs.length === 0)
+        if (session.closed
+            || session.controlInterruptPending
+            || session.state.state === 'running'
+            || session.pendingInputs.length === 0)
             return;
         const next = session.pendingInputs.shift();
         if (!next)
@@ -1467,7 +1478,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         writeTurn();
         void startCanonInput(next);
     }
-    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => {
+    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, requestingUserId = null, artifactRoutingMode = 'disabled') => {
         session.lastActivity = Date.now();
         const input = createClaudeInputEnvelope({
             kind: 'canon',
@@ -1476,6 +1487,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             sourceMessageId,
             markAccepted,
             isOwnerTurn,
+            requestingUserId,
             artifactRoutingMode,
         });
         if (session.pendingFinalDelivery) {
@@ -1489,15 +1501,21 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             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(() => { });
+            const interruptedInput = session.activeInput;
+            void session.query.interrupt().then(() => {
+                if (interruptedInput) {
+                    session.interruptedTurnKeys.add(interruptedInput.turnKey);
+                    markInputCompleted(interruptedInput);
+                }
+                session.turnState = 'interrupted';
+                stopVisibleWorkSignal();
+                clearStreaming().catch(() => { });
+                writeTurn();
+            }).catch((error) => {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Input interrupt failed; message remains queued:`, error instanceof Error ? error.message : error);
+            });
             return;
         }
         session.lastAcceptedIntent = intent;
@@ -1644,6 +1662,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                             // Non-fatal
                         }
                         if (finalDelivered) {
+                            if (!finalText || !shouldDeliverFinal) {
+                                markInputCompleted(completedInput);
+                            }
                             if (completedInput?.turnKey === session.activeInput?.turnKey) {
                                 session.activeInput = null;
                             }
@@ -1722,9 +1743,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         // Refresh the canonical runtime descriptor after Claude reports supported models.
         try {
             const models = await q.supportedModels();
-            const modelList = mergeClaudeModelOptions({
-                previous: runtimeModels,
-                next: toModelOptions(models),
+            const supplemental = await detectSupplementalRuntimeModels(cwd);
+            const modelList = resolveClaudeModelOptions({
+                discovered: mergeClaudeDiscoveredModelOptions(toModelOptions(models), ...supplemental),
                 selectedModel: session.state.model,
             });
             session.availableModels = modelList;
@@ -2192,25 +2213,13 @@ export async function main() {
             });
         }
         else {
-            const existingState = loadRuntimeSessionState(runtimeId, {
-                conversationId,
-                baseCwd: session.environment.baseCwd,
-                executionMode: session.environment.mode,
-            });
             savedSessionIds.delete(resumeKey);
             clearRuntimeSessionState(runtimeId, {
                 conversationId,
                 baseCwd: session.environment.baseCwd,
                 executionMode: session.environment.mode,
+                preserveInboundCursor: true,
             });
-            if (existingState?.lastInboundMessageId) {
-                saveRuntimeSessionState(runtimeId, {
-                    conversationId,
-                    baseCwd: session.environment.baseCwd,
-                    executionMode: session.environment.mode,
-                    lastInboundMessageId: existingState.lastInboundMessageId,
-                });
-            }
         }
         session.clearStreaming().catch(() => { });
         if (session.idleResetTimer) {
@@ -2234,8 +2243,27 @@ export async function main() {
     }
     async function resetRuntimeSession(session) {
         const conversationId = session.conversationId;
+        const sdkTurnActive = (session.state.state === 'running'
+            || session.state.state === 'requires_action') && !session.pendingFinalDelivery;
+        session.controlInterruptPending = sdkTurnActive;
+        const interruptResult = await confirmClaudeInterrupt({
+            active: sdkTurnActive,
+            interrupt: () => session.query.interrupt(),
+        });
+        if (interruptResult === 'defer') {
+            session.controlInterruptPending = false;
+            throw new Error('Claude Code did not acknowledge the new-session interrupt.');
+        }
+        session.closed = true;
+        if (session.finalDeliveryTimer) {
+            clearTimeout(session.finalDeliveryTimer);
+            session.finalDeliveryTimer = null;
+        }
         const droppedInputs = session.pendingInputs.splice(0);
         await markSessionPendingInputsRejected(conversationId, droppedInputs);
+        session.markInputCompleted(session.activeInput);
+        for (const input of droppedInputs)
+            session.markInputCompleted(input);
         if (session.activeInput) {
             session.interruptedTurnKeys.add(session.activeInput.turnKey);
         }
@@ -2244,9 +2272,6 @@ export async function main() {
         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) {
@@ -2330,10 +2355,17 @@ export async function main() {
                                 conversationId: convoId,
                                 baseCwd: existing.environment.baseCwd,
                                 executionMode: existing.environment.mode,
+                                preserveInboundCursor: true,
                             });
                         }
                     }
                     existing?.clearStreaming().catch(() => { });
+                    if (existing) {
+                        settleInboundMessageId(existing.activeInput?.sourceMessageId, false);
+                        for (const input of existing.pendingInputs) {
+                            settleInboundMessageId(input.sourceMessageId, false);
+                        }
+                    }
                     typingSignals.clear(convoId).catch(() => { });
                     typingSignals.dispose(convoId);
                     sessions.delete(convoId);
@@ -2354,7 +2386,11 @@ export async function main() {
                     runtimeInputManager,
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
+                    recoveryBaseCwd: workingDir,
                     ownerId,
+                    onInputCompleted: (sourceMessageId) => {
+                        settleInboundMessageId(sourceMessageId, true);
+                    },
                     publishSessionSnapshots: (ids) => { void publishSessionSnapshots(ids); },
                 }, resumeId);
                 sessions.set(conversationId, session);
@@ -2375,9 +2411,27 @@ export async function main() {
         }
     }
     async function enqueueRecoveredInboundMessage(input) {
-        const m = input.message;
+        const m = {
+            id: input.message.id,
+            senderId: input.message.senderId,
+            senderName: input.message.senderName,
+            senderType: input.message.senderType,
+            isOwner: input.message.isOwner,
+            text: input.message.text ?? undefined,
+            contentType: input.message.contentType,
+            attachments: input.message.attachments,
+            mentions: input.message.mentions,
+            reactions: input.message.reactions,
+            replyTo: input.message.replyTo ?? undefined,
+            replyToPosition: input.message.replyToPosition ?? undefined,
+            forwarded: input.message.forwarded,
+            forwardedFrom: input.message.forwardedFrom,
+            metadata: input.message.metadata,
+            contactCard: input.message.contactCard,
+            createdAt: input.message.createdAt,
+        };
         if (m.senderId === agentId)
-            return;
+            return 'handled';
         let materialized = [];
         if (m.id) {
             try {
@@ -2414,7 +2468,7 @@ export async function main() {
         const autoReply = decideAutoReply(participantContext, behavior);
         if (!autoReply.allow) {
             console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Suppressed recovered auto-reply: ${autoReply.reason}`);
-            return;
+            return 'handled';
         }
         markGroupContextModeUsed(input.conversationId, participantContext.groupContextMode);
         const turnMetadata = normalizeTurnMetadata(m.metadata);
@@ -2437,7 +2491,7 @@ export async function main() {
                     replyBehavior: 'suppress_auto_reply',
                 },
             }).catch(() => { });
-            return;
+            return 'handled';
         }
         session.activeSelfContextId = activeSelfContextId;
         const promptText = buildCanonPrompt({
@@ -2463,15 +2517,153 @@ export async function main() {
                 content: messageContent,
             },
             parent_tool_use_id: null,
-        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, artifactRoutingMode);
-        if (m.id) {
-            saveRuntimeSessionState(runtimeId, {
-                conversationId: input.conversationId,
-                baseCwd: workingDir,
-                lastInboundMessageId: m.id,
-            });
+        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, artifactRoutingMode);
+        return 'queued';
+    }
+    const acceptedInboundMessageIds = new Set();
+    const inFlightInboundMessageIds = new Set();
+    function claimInboundMessageId(messageId) {
+        if (!messageId)
+            return true;
+        if (acceptedInboundMessageIds.has(messageId) || inFlightInboundMessageIds.has(messageId))
+            return false;
+        inFlightInboundMessageIds.add(messageId);
+        return true;
+    }
+    function settleInboundMessageId(messageId, accepted) {
+        if (!messageId)
+            return;
+        inFlightInboundMessageIds.delete(messageId);
+        if (!accepted)
+            return;
+        acceptedInboundMessageIds.add(messageId);
+        while (acceptedInboundMessageIds.size > 2_048) {
+            const oldest = acceptedInboundMessageIds.values().next().value;
+            if (!oldest)
+                break;
+            acceptedInboundMessageIds.delete(oldest);
+        }
+    }
+    function handleRuntimeReplyMessage(conversationId, message) {
+        if (message.metadata?.type === 'approval_reply' || (approvalManager?.pendingCount ?? 0) > 0) {
+            const consumed = approvalManager?.handleMessage(conversationId, {
+                senderId: message.senderId,
+                metadata: message.metadata,
+            }) ?? false;
+            if (message.metadata?.type === 'approval_reply') {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] ${consumed ? 'Approval reply consumed' : 'Ignoring stale approval reply'} from ${message.senderName || message.senderId}`);
+                return true;
+            }
+            if (consumed) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Approval text reply consumed from ${message.senderName || message.senderId}`);
+                return true;
+            }
+        }
+        if (message.metadata?.type !== 'plan_approval_reply')
+            return false;
+        const existingSession = sessions.get(conversationId);
+        const pendingReply = existingSession?.pendingReply;
+        const replyRequestId = message.metadata.planId;
+        if (!pendingReply) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring stale ${message.metadata.type} with no pending request`);
+            return true;
+        }
+        if (message.senderId !== pendingReply.responseUserId) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring ${message.metadata.type} from unexpected responder ${message.senderId}`);
+            return true;
+        }
+        if (pendingReply.type !== message.metadata.type || pendingReply.requestId !== replyRequestId) {
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Ignoring mismatched ${message.metadata.type} (${String(replyRequestId ?? 'missing-id')})`);
+            return true;
         }
+        existingSession.pendingReply = null;
+        existingSession.lastActivity = Date.now();
+        pendingReply.resolve(message.metadata);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Reply received (${message.metadata.type}:${pendingReply.requestId.slice(0, 8)})`);
+        return true;
     }
+    function persistedConversationCursors(conversationId) {
+        const canonicalCursor = loadRuntimeSessionState(runtimeId, {
+            conversationId,
+            baseCwd: workingDir,
+            workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
+        })?.lastInboundMessageId ?? null;
+        if (canonicalCursor)
+            return { canonicalCursor, legacyCursors: [] };
+        const legacyCursors = Object.values(readLocalRuntimeEntry(runtimeId)?.sessions ?? {})
+            .filter((state) => state.conversationId === conversationId)
+            .map((state) => state.lastInboundMessageId)
+            .filter((messageId) => Boolean(messageId));
+        return { canonicalCursor: null, legacyCursors: [...new Set(legacyCursors)] };
+    }
+    async function performMissedInboundRecovery() {
+        for (const conversationId of knownConversationIds) {
+            try {
+                const cursors = persistedConversationCursors(conversationId);
+                const recovered = await collectMissedInboundMessages({
+                    fetchPage: (before) => client.getMessagesPage(conversationId, STARTUP_RECOVERY_PAGE_SIZE, before),
+                    cursor: cursors.canonicalCursor,
+                    cursorCandidates: cursors.legacyCursors,
+                    agentId,
+                });
+                if (!cursors.canonicalCursor
+                    && recovered.cursor
+                    && recovered.messages.length === 0) {
+                    saveRuntimeSessionState(runtimeId, {
+                        conversationId,
+                        baseCwd: workingDir,
+                        workspaceId: CLAUDE_RECOVERY_CURSOR_WORKSPACE_ID,
+                        lastInboundMessageId: recovered.cursor,
+                    });
+                }
+                if (recovered.mode === 'truncated-window') {
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovery cursor was not found within ${STARTUP_RECOVERY_MAX_MESSAGES} messages; replaying the bounded recent window`);
+                }
+                for (const message of recovered.messages) {
+                    if (!claimInboundMessageId(message.id))
+                        continue;
+                    try {
+                        let queued = false;
+                        if (!handleRuntimeReplyMessage(conversationId, message)) {
+                            const trigger = shouldTriggerAgentTurn({
+                                senderType: message.senderType,
+                                metadata: message.metadata,
+                            });
+                            if (trigger.allow) {
+                                queued = await enqueueRecoveredInboundMessage({
+                                    conversationId,
+                                    message,
+                                    hydratedPage: recovered.newestPage,
+                                }) === 'queued';
+                            }
+                        }
+                        if (!queued)
+                            settleInboundMessageId(message.id, true);
+                    }
+                    catch (error) {
+                        settleInboundMessageId(message.id, false);
+                        throw error;
+                    }
+                }
+                if (recovered.messages.length > 0) {
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Recovered ${recovered.messages.length} inbound message(s) (${recovered.mode})`);
+                }
+            }
+            catch (error) {
+                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Startup recovery failed:`, error instanceof Error ? error.message : error);
+            }
+        }
+    }
+    let recoveryInFlight = null;
+    function recoverMissedInboundMessages() {
+        if (recoveryInFlight)
+            return recoveryInFlight;
+        recoveryInFlight = performMissedInboundRecovery().finally(() => {
+            recoveryInFlight = null;
+        });
+        return recoveryInFlight;
+    }
+    await recoverMissedInboundMessages();
     // ── Connect SSE stream for inbound Canon messages ──
     const stream = new CanonStream({
         apiKey,
@@ -2481,53 +2673,19 @@ export async function main() {
                 const m = payload.message;
                 if (m.senderId === agentId)
                     return;
+                if (!claimInboundMessageId(m.id))
+                    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;
-                    }
-                }
-                // 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;
-                    }
+                if (handleRuntimeReplyMessage(convoId, m)) {
+                    settleInboundMessageId(m.id, true);
+                    return;
                 }
                 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}`);
+                    settleInboundMessageId(m.id, true);
                     return;
                 }
                 void (async () => {
@@ -2572,7 +2730,7 @@ export async function main() {
                         : decideAutoReply(participantContext, behavior);
                     if (!autoReply.allow) {
                         console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
-                        return;
+                        return false;
                     }
                     markGroupContextModeUsed(convoId, participantContext.groupContextMode);
                     console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
@@ -2596,7 +2754,7 @@ export async function main() {
                                 replyBehavior: 'suppress_auto_reply',
                             },
                         }).catch(() => { });
-                        return;
+                        return false;
                     }
                     session.activeSelfContextId = activeSelfContextId;
                     const promptText = buildCanonPrompt({
@@ -2622,15 +2780,15 @@ export async function main() {
                             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,
-                        });
-                    }
-                })();
+                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, artifactRoutingMode);
+                    return true;
+                })().then((queued) => {
+                    if (!queued)
+                        settleInboundMessageId(m.id, true);
+                }).catch((error) => {
+                    settleInboundMessageId(m.id, false);
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to process inbound message:`, error instanceof Error ? error.message : error);
+                });
             },
             onMessageDeleted: (payload) => {
                 removeQueuedInput(payload.conversationId, payload.messageId);
@@ -2641,6 +2799,7 @@ export async function main() {
             onConnected: () => {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
+                void recoverMissedInboundMessages();
                 console.error('[canon-host] SSE connected');
             },
             onDisconnected: () => {
@@ -2687,31 +2846,57 @@ export async function main() {
         });
         session.writeState();
     }
-    // Interrupt/stop-clear signal. Throwing leaves the node in place
-    // (consumeOnError: false); lastSeen has already advanced, so the failed
-    // signal is reported but never retried.
+    // Stop/new-session signals remain pending until the Claude SDK confirms the
+    // interrupt. `defer` deliberately makes the poller revisit the same node.
     async function handleRuntimeControlSignal(event) {
         const convoId = event.conversationId;
         const session = sessions.get(convoId);
         if (!session || session.closed)
-            return { consume: false };
+            return { defer: true };
         if (event.type === 'new_session') {
             console.error(`[canon-host] [${convoId.slice(0, 8)}] new_session signal`);
-            await resetRuntimeSession(session);
+            try {
+                await resetRuntimeSession(session);
+            }
+            catch (error) {
+                console.error(`[canon-host] [${convoId.slice(0, 8)}] New-session interrupt failed; retrying signal:`, error instanceof Error ? error.message : error);
+                return { defer: true };
+            }
             return;
         }
-        const isActive = session.state.state === 'running';
+        const isActive = session.state.state === 'running' || session.state.state === 'requires_action';
         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);
+        const sdkTurnActive = isActive && !session.pendingFinalDelivery;
+        session.controlInterruptPending = sdkTurnActive;
+        const interruptResult = await confirmClaudeInterrupt({
+            active: sdkTurnActive,
+            interrupt: () => session.query.interrupt(),
+        });
+        if (interruptResult === 'defer') {
+            session.controlInterruptPending = false;
+            console.error(`[canon-host] [${convoId.slice(0, 8)}] Stop interrupt failed; retrying signal`);
+            return { defer: true };
+        }
+        const droppedInputs = event.type === 'stop_and_drop'
+            ? session.pendingInputs.splice(0)
+            : [];
+        if (droppedInputs.length > 0) {
             await markSessionPendingInputsRejected(convoId, droppedInputs);
         }
+        session.markInputCompleted(session.activeInput);
+        for (const input of droppedInputs)
+            session.markInputCompleted(input);
         if (session.activeInput) {
             session.interruptedTurnKeys.add(session.activeInput.turnKey);
         }
+        if (session.finalDeliveryTimer) {
+            clearTimeout(session.finalDeliveryTimer);
+            session.finalDeliveryTimer = null;
+        }
+        session.pendingFinalDelivery = null;
         session.pendingFinalText = null;
         session.turnState = 'interrupted';
         session.clearStreaming().catch(() => { });
@@ -2726,9 +2911,7 @@ export async function main() {
             ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
             completedAt: { '.sv': 'timestamp' },
         }).catch(() => { });
-        if (isActive) {
-            await session.query.interrupt();
-        }
+        session.controlInterruptPending = false;
     }
     controlPoller.start();
     // ── Heartbeat (per-session) ──