@canonmsg/claude-code-plugin 0.32.0 → 0.34.0

package/dist/host.js

@@ -29,13 +29,14 @@ import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, collectMissedInboundMessages, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
 import { buildCanonUserContent, renderClaudeInboundContent, withClaudeReplyContextMediaReferences, } from './canon-user-content.js';
-import { 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, formatPendingContactLifecycleContext, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, readLocalRuntimeEntry, reconcileContactLifecycleEvents, recordLocalRuntimeContactLifecycleEvent, saveLocalRuntimeContactLifecycleCursor, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, takeLocalRuntimeContactLifecycleEvents, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { 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, ExecutionEnvironmentError, CanonClient, CanonStream, ControlChannelPoller, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, RuntimeRequestManager, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, parseTurnVerbosityConfig, prepareConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, decideAutoReply, initRTDBAuth, isChunkedSendMessageError, sendMessageWithRetry, sendMessageWithRetryChunked, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, resolveLocalRuntimeSessionState, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { runCli } from '@canonmsg/core';
-import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer, } from '@canonmsg/agent-tools';
+import { CANON_VERB_MCP_SERVER_NAME, createCanonVerbMcpServer } from '@canonmsg/agent-tools';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { applyClaudeSessionControl, boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, beginClaudeAssistantResponse, claimClaudeTextSegmentId, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, endClaudeAssistantResponse, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeStreamingWrite, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, claudeFinalTurnTrail, publishedClaudeTurnState, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, shouldStopTypingDotsOnStreamedText, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeTurnFinal, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, shouldRouteClaudeTurnArtifacts, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
+import { boundClaudeFinalMetadata, buildClaudeFinalChunkingOptions, buildClaudeFinalMessageId, buildClaudeFinalTurnMetadata, buildClaudePendingFinalDelivery, buildClaudeTurnFailureNotice, buildTruncatedFinalText, buildUndeliverableFinalNotice, canDrainClaudeQueuedInput, beginClaudeAssistantResponse, claimClaudeTextSegmentId, claudeFinalWillChunk, classifyFinalDeliveryFailure, claudeInputOwnsTurnSlot, createClaudeTurnActivityState, decideClaudeControlSignalAction, decideClaudeInboundDispatch, dispatchClaudeInput, endClaudeAssistantResponse, isClaudeTurnSlotReserved, readClaudeFinalDeliveryResume, releaseClaudeTurnSlot, runClaudeExhaustedFinalDelivery, shouldApplyClaudeEchoedSessionState, shouldReleaseClaudeTurnSlot, isClaudeMainTurnMessage, openClaudeTurn, planClaudeAssistantTrail, planClaudeStreamingWrite, planClaudeToolCallStart, planClaudeToolProgress, planClaudeToolResults, claudeFinalTurnTrail, publishedClaudeTurnState, rememberDispatchedClaudeInput, resetClaudeTurnActivityState, shouldOpenClaudeTurnOnRunning, shouldStopTypingDotsOnStreamedText, isOpenClaudeTurnState, takeClaudeResultOwner, takeClaudeToolBlockIdByIndex, claudeModelInfoToOption, claudeOriginForCanonSender, composeClaudeTurnFinal, describeUndeliveredClaudeFinal, confirmClaudeInterrupt, createClaudeInputEnvelope, deriveClaudeSupplementalModelProbes, formatClaudeCliVersion, formatClaudeControlError, isClaudeCustomModelOption, isSupportedClaudeCliVersion, mergeClaudeDiscoveredModelOptions, parseClaudeCliVersion, resolveClaudeTurnResponseRouting, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, shouldRouteClaudeTurnArtifacts, MINIMUM_CLAUDE_CLI_VERSION, } from './session-state.js';
 import { CLAUDE_SUPPORTED_DIALOG_KINDS, buildClaudeAskUserPermissionDenied, buildClaudeAskUserPermissionResult, createClaudeUserDialogCoordinator, parseClaudeAskUserDialog, parseClaudeAskUserToolInput, resolveClaudeUserDialogRequestId, } from './user-dialog.js';
+import { isProactiveCommunicationEnabled } from './communication-policy.js';
 function parseRuntimeVisibilityPreset(value) {
     return value === 'normal' || value === 'minimal' || value === 'full' ? value : undefined;
 }
@@ -53,6 +54,8 @@ COMMON FLAGS
   --cwd <path>             Project directory to run Claude Code from
   --workspace <path>       Additional project to expose in Canon
   --workspace-root <path>  Discover projects under an approved root
+  --default-execution-mode <worktree|locked>
+                          Default for new Canon conversations
   --runtime-visibility <normal|minimal|full>
                           Detail visibility preset
   --show-runtime-detail <field>
@@ -86,12 +89,10 @@ let workspaceRoots = [];
 let workspaceRootMetadata = [];
 let runtimeModels = [];
 const CLAUDE_METADATA_TTL_MS = 5 * 60 * 1000;
+const LOCAL_CONFIGURATION_REQUIRED_MESSAGE = 'This agent needs local runtime configuration before it can start this conversation. '
+    + 'Its operator must configure it and retry.';
 const allowedNonOwnerClaudeTools = parseAllowedNonOwnerClaudeTools(process.env.CANON_CLAUDE_NON_OWNER_ALLOWED_TOOLS);
-/**
- * Agent-developer setting, resolved once at startup. Deliberately NOT read from
- * `/session-config`: that path is the USER's per-conversation control plane,
- * and owner ruling 5 puts turn verbosity outside user control.
- */
+/** Turn verbosity is local agent-developer configuration, resolved at startup. */
 let configuredTurnVerbosity = null;
 /**
  * `--turn-verbosity` beats `CANON_TURN_VERBOSITY`; `null` means "unset, use the
@@ -271,6 +272,7 @@ function buildClaudeRuntimeDescriptor(input) {
         workspaces: input.workspaces,
         workspaceRoots: input.workspaceRoots,
         executionModes: input.executionModes,
+        defaultExecutionMode: input.defaultExecutionMode,
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         effortOptions: [...EFFORT_OPTIONS],
@@ -303,11 +305,7 @@ function buildClaudeRuntimeDescriptor(input) {
                 activation: { kind: 'control', controlId: 'permissionMode', value: 'plan' },
             },
         ],
-        admissionActions: {
-            ...HOST_ADMISSION_ACTIONS_DISABLED,
-            requestContact: true,
-            reachOut: true,
-        },
+        admissionActions: HOST_ADMISSION_ACTIONS_DISABLED,
         presentation: input.presentation,
         commands,
     });
@@ -419,32 +417,20 @@ function toModelOptions(models) {
 async function publishAgentRuntime(agentId, runtime, rtdb) {
     await publishHostAgentRuntime(agentId, 'claude-code', runtime, rtdb);
 }
-async function loadSessionConfig(conversationId, agentId, rtdb) {
-    const config = await loadHostSessionConfig({
-        conversationId,
-        agentId,
-        rtdb,
-        extraStringFields: ['permissionMode', 'effort'],
-        retryMissingMs: 3_000,
-    });
-    return {
-        ...config,
-        permissionMode: config?.permissionMode
-            ? parseClaudePermissionMode(config.permissionMode) ?? undefined
-            : undefined,
-        effort: normalizeClaudeEffortLevel(config?.effort),
-        ultracode: parseClaudeUltracodeMode(config?.runtimeControlValues?.ultracode),
-    };
+export function resolveSessionExecutionMode(defaultExecutionMode = 'worktree') {
+    return defaultExecutionMode;
 }
-function resolveSessionExecutionMode(config) {
-    if (config?.executionMode)
-        return config.executionMode;
-    throw new ExecutionEnvironmentError('Session config is missing an execution mode.', 'Choose Isolated worktree or Use shared project before starting this coding session.');
+function resolveConfiguredDefaultExecutionMode(value) {
+    if (value == null || value === '')
+        return 'worktree';
+    if (value === 'worktree' || value === 'locked')
+        return value;
+    throw new Error('--default-execution-mode must be worktree or locked');
 }
-function resolveWorkspaceCwd(config) {
-    return resolveHostWorkspaceCwd({
+function resolveWorkspaceCwd() {
+    return resolveConfiguredWorkspaceCwd({
         workspaceOptions,
-        config,
+        workspaceId: workspaceOptions[0]?.id,
         defaultCwd: workingDir,
     });
 }
@@ -757,16 +743,6 @@ const CLAUDE_RUNTIME_CAPABILITIES = {
  */
 const NO_REPLY_VERB = 'no_reply';
 export const NO_REPLY_TOOL_NAME = `mcp__${CANON_VERB_MCP_SERVER_NAME}__${NO_REPLY_VERB}`;
-export const REACH_OUT_TOOL_NAME = `mcp__${CANON_VERB_MCP_SERVER_NAME}__send_to`;
-function ownerBoundRenderOptions(isOwner) {
-    const admissionActions = isOwner
-        ? { ...HOST_ADMISSION_ACTIONS_DISABLED, requestContact: true, reachOut: true }
-        : HOST_ADMISSION_ACTIONS_DISABLED;
-    return {
-        admissionActions,
-        ...(admissionActions.reachOut ? { reachOutToolName: REACH_OUT_TOOL_NAME } : {}),
-    };
-}
 export function buildCanonPrompt(input) {
     return renderCodingHostInboundPrompt(buildCanonInboundFrameV1(buildCanonTurnContextV2({
         content: input.content,
@@ -799,8 +775,8 @@ function resolveClaudeTurnModes(participantContext) {
         }),
     };
 }
-function renderInboundContent(message, materialized, renderOptions = {}) {
-    return renderClaudeInboundContent(message, materialized, renderOptions);
+function renderInboundContent(message, materialized) {
+    return renderClaudeInboundContent(message, materialized);
 }
 async function materializePromptReplyContext(input) {
     if (!input.replyContext?.found || !input.replyContext.attachments?.length) {
@@ -813,27 +789,17 @@ async function materializePromptReplyContext(input) {
         });
         return {
             ...result,
-            replyContext: withClaudeReplyContextMediaReferences(result.replyContext, result.materialized, input.renderOptions),
+            replyContext: withClaudeReplyContextMediaReferences(result.replyContext, result.materialized),
         };
     }
     catch (error) {
         console.error(`${input.logPrefix} Failed to materialize replied-to media:`, error instanceof Error ? error.message : error);
         return {
-            replyContext: withClaudeReplyContextMediaReferences(input.replyContext, [], input.renderOptions),
+            replyContext: withClaudeReplyContextMediaReferences(input.replyContext, []),
             materialized: [],
         };
     }
 }
-function ownerBoundReplyContactTarget(replyContext) {
-    const card = replyContext?.found ? replyContext.contactCard : undefined;
-    if (!card?.userId)
-        return undefined;
-    return {
-        targetUserId: card.userId,
-        ...(card.canonContactId ? { canonContactId: card.canonContactId } : {}),
-        sourceCardMessageId: replyContext.messageId,
-    };
-}
 // ── Session factory ─────────────────────────────────────────────────
 function createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
@@ -852,7 +818,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             messageQueue.push(input);
         }
     };
-    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}, replyContactTarget) => {
+    let enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => {
         sendInput(createClaudeInputEnvelope({
             kind: 'canon',
             msg,
@@ -861,7 +827,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             markAccepted,
             isOwnerTurn,
             requestingUserId,
-            replyContactTarget,
             ...turnModes,
         }));
     };
@@ -1008,24 +973,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                     const turnKey = session.activeInput?.turnKey;
                     if (turnKey)
                         session.silencedTurnKeys.add(turnKey);
-                }, {
-                    ownerBoundCommunication: {
-                        getContext: () => {
-                            const input = session.activeInput;
-                            if (!input?.isOwnerTurn || !input.sourceMessageId)
-                                return null;
-                            return {
-                                isOwnerTurn: true,
-                                conversationId,
-                                sourceMessageId: input.sourceMessageId,
-                                ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
-                                ...(input.replyContactTarget
-                                    ? { replyContactTarget: input.replyContactTarget }
-                                    : {}),
-                            };
-                        },
-                    },
-                }),
+                }, { communication: config.communicationEnabled === true }),
             },
         },
         ...(claudeCliPath ? { pathToClaudeCodeExecutable: claudeCliPath } : {}),
@@ -1214,7 +1162,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         environment,
         query: q,
         sendInput,
-        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}, replyContactTarget) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, requestingUserId, turnModes, replyContactTarget),
+        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, requestingUserId, turnModes),
         state: {
             model: undefined,
             permissionMode: config.permissionMode,
@@ -1491,6 +1439,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                         deliveryIntent: session.lastAcceptedIntent,
                         suppressAutoReply: input.suppressAutoReply,
                     }),
+                    ...(input.turn.replyAuthority ? { replyAuthority: input.turn.replyAuthority } : {}),
                 });
                 console.error(`[canon-host] [${conversationId.slice(0, 8)}] `
                     + (degraded.length === input.finalText.length
@@ -1558,6 +1507,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 messageId: finalMessageId,
                 ...(selfContextId ? { selfContextId } : {}),
                 metadata,
+                ...(deliverTurn.replyAuthority ? { replyAuthority: deliverTurn.replyAuthority } : {}),
             }, {}, buildClaudeFinalChunkingOptions(resume));
             markFinalTurnDelivered(deliverTurn);
             console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars`
@@ -1620,6 +1570,9 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     }
     function sendTurnArtifactFile(file) {
         return sendMediaFileMessage(client, conversationId, file.path, '', {
+            ...(session.activeInput?.replyAuthority
+                ? { replyAuthority: session.activeInput.replyAuthority }
+                : {}),
             ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
             metadata: buildArtifactMediaMetadata(),
         });
@@ -1698,51 +1651,8 @@ function createSession(conversationId, environment, agentId, client, typingSigna
         }, 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(() => { });
@@ -1968,7 +1878,7 @@ function createSession(conversationId, environment, agentId, client, typingSigna
     function hasInterruptibleSdkInput() {
         return session.activeInput !== null && session.dispatchingInput === null;
     }
-    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}, replyContactTarget) => {
+    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false, isOwnerTurn = false, requestingUserId = null, turnModes = {}) => {
         session.lastActivity = Date.now();
         const input = createClaudeInputEnvelope({
             kind: 'canon',
@@ -1978,7 +1888,6 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             markAccepted,
             isOwnerTurn,
             requestingUserId,
-            replyContactTarget,
             ...turnModes,
         });
         const decision = decideClaudeInboundDispatch({
@@ -2430,11 +2339,13 @@ function createSession(conversationId, environment, agentId, client, typingSigna
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 availableExecutionModes: config.availableExecutionModes,
+                defaultExecutionMode: config.defaultExecutionMode,
                 runtimeDescriptor: buildClaudeRuntimeDescriptor({
                     models: modelList,
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: config.availableExecutionModes,
+                    defaultExecutionMode: config.defaultExecutionMode,
                     presentation: config.runtimePresentation,
                 }),
             });
@@ -2464,6 +2375,7 @@ export async function main() {
             cwd: { type: 'string' },
             workspace: { type: 'string', multiple: true },
             'workspace-root': { type: 'string', multiple: true },
+            'default-execution-mode': { type: 'string' },
             'runtime-visibility': { type: 'string' },
             'show-runtime-detail': { type: 'string', multiple: true },
             'hide-runtime-detail': { type: 'string', multiple: true },
@@ -2476,6 +2388,7 @@ export async function main() {
         env: process.env.CANON_TURN_VERBOSITY,
         onWarning: (message) => console.error(`[canon-host] ${message}`),
     });
+    const defaultExecutionMode = resolveConfiguredDefaultExecutionMode(args['default-execution-mode']);
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const configuredWorkspaces = (args.workspace ?? []).filter((value) => typeof value === 'string');
     const configuredWorkspaceRoots = (args['workspace-root'] ?? []).filter((value) => typeof value === 'string');
@@ -2516,11 +2429,13 @@ export async function main() {
     let agentId;
     let ownerId = null;
     let ownerName = null;
+    let communicationEnabled = false;
     try {
         const ctx = await client.getAgentMe();
         agentId = ctx.agentId;
         ownerId = ctx.ownerId;
         ownerName = ctx.ownerName;
+        communicationEnabled = isProactiveCommunicationEnabled(ctx.outboundPolicy);
         console.error(`[canon-host] Connected as ${ctx.displayName || agentId}`);
     }
     catch {
@@ -2567,15 +2482,6 @@ export async function main() {
         hostMode: true,
         rtdb,
     });
-    const recoveryCheckpointTrackers = new Map();
-    function recoveryCheckpointsFor(conversationId) {
-        let tracker = recoveryCheckpointTrackers.get(conversationId);
-        if (!tracker) {
-            tracker = createClaudeRecoveryCheckpointTracker((messageId) => persistConversationRecoveryCursor(conversationId, messageId));
-            recoveryCheckpointTrackers.set(conversationId, tracker);
-        }
-        return tracker;
-    }
     let streamConnected = false;
     const hostAvailableExecutionModes = [
         ...EXECUTION_ENVIRONMENT_MODES,
@@ -2587,6 +2493,7 @@ export async function main() {
         hide: stringArgs(args['hide-runtime-detail']),
     });
     let runtimeDescriptor = {
+        defaultExecutionMode,
         defaultWorkspaceId: workspaceOptions[0]?.id,
         defaultPermissionMode: 'default',
         availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
@@ -2597,6 +2504,7 @@ export async function main() {
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
+            defaultExecutionMode,
             presentation: runtimePresentation,
         }),
     };
@@ -2617,25 +2525,6 @@ export async function main() {
             agentId,
             rtdb,
             clientType: 'claude-code',
-            runtime: runtimeDescriptor,
-            workspaceOptions,
-            defaultCwd: workingDir,
-            extraSessionConfigFields: ['permissionMode', 'effort'],
-            liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
-                const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
-                return [
-                    session.conversationId,
-                    {
-                        ...(session.state.model ? { model: session.state.model } : {}),
-                        ...(session.state.permissionMode ? { permissionMode: session.state.permissionMode } : {}),
-                        ...(session.state.effort ? { effort: session.state.effort } : {}),
-                        ...(session.state.ultracode ? { runtimeControlValues: { ultracode: session.state.ultracode } } : {}),
-                        ...(workspaceId ? { workspaceId } : {}),
-                        executionMode: session.environment.mode,
-                        executionBranch: session.environment.branch ?? null,
-                    },
-                ];
-            })),
         }).catch((error) => {
             console.error('[canon-host] Failed to publish session snapshots:', error);
         });
@@ -2675,6 +2564,7 @@ export async function main() {
                     workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                     workspaceRoots: workspaceRootMetadata,
                     executionModes: hostAvailableExecutionModes,
+                    defaultExecutionMode,
                     presentation: runtimePresentation,
                 }),
             };
@@ -2709,6 +2599,7 @@ export async function main() {
     try {
         runtimeModels = await detectRuntimeModels(workingDir);
         runtimeDescriptor = {
+            defaultExecutionMode,
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
@@ -2721,12 +2612,14 @@ export async function main() {
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
+                defaultExecutionMode,
                 presentation: runtimePresentation,
             }),
         };
     }
     catch {
         runtimeDescriptor = {
+            defaultExecutionMode,
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultPermissionMode: 'default',
             availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
@@ -2737,6 +2630,7 @@ export async function main() {
                 workspaces: buildPublicWorkspaceOptions(workspaceOptions),
                 workspaceRoots: workspaceRootMetadata,
                 executionModes: hostAvailableExecutionModes,
+                defaultExecutionMode,
                 presentation: runtimePresentation,
             }),
         };
@@ -2759,14 +2653,23 @@ export async function main() {
     }
     // ── Session manager ──
     const sessions = new Map();
+    const recoveryCheckpointTrackers = new Map();
+    function recoveryCheckpointsFor(conversationId) {
+        let tracker = recoveryCheckpointTrackers.get(conversationId);
+        if (!tracker) {
+            tracker = createClaudeRecoveryCheckpointTracker((messageId) => persistConversationRecoveryCursor(conversationId, messageId));
+            recoveryCheckpointTrackers.set(conversationId, tracker);
+        }
+        return tracker;
+    }
     const approvalManager = ownerId ? new ApprovalManager(client, agentId, ownerId) : null;
     // Interactive runtime input (AskUserQuestion) works with or without an owner,
     // so its poll engine is always present. Create + poll fold onto the built-in
     // input descriptor via `request()` (see the AskUserQuestion canUseTool branch).
     const runtimeInputManager = new RuntimeRequestManager(client, { agentId, ownerId: ownerId ?? '' });
     const pendingSessionCreations = new Map();
-    // Shared /control channel poller (claude host profile): session + signal
-    // keys, sequential conversations, active/idle cadence + jitter sampled at
+    // Shared /control channel poller (claude host profile): 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({
@@ -2788,7 +2691,6 @@ export async function main() {
         pollOnStart: true,
         conversationConcurrency: 'sequential',
         handlers: {
-            session: { handle: applyRuntimeSessionControl },
             signal: { handle: handleRuntimeControlSignal },
         },
         onError: ({ scope, key, conversationId, error }) => {
@@ -2887,7 +2789,6 @@ export async function main() {
             ownerName,
             membershipChange: pendingMembershipChanges.get(input.conversationId) ?? null,
             groupContextMode: getGroupContextMode(input.conversationId, conversation),
-            renderOptions: input.renderOptions,
         });
     }
     function closeSession(conversationId, options = {}) {
@@ -3024,22 +2925,47 @@ export async function main() {
             evictOldestIdle();
         }
         const creation = (async () => {
-            const config = await loadSessionConfig(conversationId, agentId, rtdb);
-            const sessionExecutionMode = resolveSessionExecutionMode(config);
-            const workspaceCwd = resolveWorkspaceCwd(config);
-            const environment = prepareConversationEnvironment({
+            const sessionExecutionMode = resolveSessionExecutionMode(defaultExecutionMode);
+            const workspaceCwd = resolveWorkspaceCwd();
+            let environment = prepareConversationEnvironment({
                 agentId,
                 conversationId,
                 workspaceCwd,
                 allowWorktrees: sessionExecutionMode === 'worktree',
             });
             try {
-                const resumeKey = buildConversationEnvironmentKey(conversationId, environment.baseCwd);
-                const persisted = loadRuntimeSessionState(runtimeId, {
+                const persistedMapping = resolveLocalRuntimeSessionState(runtimeId, {
                     conversationId,
                     baseCwd: environment.baseCwd,
                     executionMode: environment.mode,
+                    resumeField: 'claudeSessionId',
+                    configuredBaseCwds: workspaceOptions.map((workspace) => workspace.cwd),
+                    availableExecutionModes: hostAvailableExecutionModes,
                 });
+                if (persistedMapping.status === 'configuration_required') {
+                    throw new ExecutionEnvironmentError(persistedMapping.message, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
+                }
+                if (persistedMapping.status === 'adopted'
+                    && (persistedMapping.state.baseCwd !== environment.baseCwd
+                        || persistedMapping.state.executionMode !== environment.mode)) {
+                    const restoredEnvironment = prepareConversationEnvironment({
+                        agentId,
+                        conversationId,
+                        workspaceCwd: persistedMapping.state.baseCwd,
+                        allowWorktrees: persistedMapping.state.executionMode === 'worktree',
+                    });
+                    if (restoredEnvironment.mode !== persistedMapping.state.executionMode) {
+                        releaseConversationEnvironment(restoredEnvironment);
+                        throw new ExecutionEnvironmentError(`Conversation ${conversationId} requires local execution mode ${persistedMapping.state.executionMode}, but workspace ${persistedMapping.state.baseCwd} can only be opened in ${restoredEnvironment.mode} mode.`, LOCAL_CONFIGURATION_REQUIRED_MESSAGE);
+                    }
+                    releaseConversationEnvironment(environment);
+                    environment = restoredEnvironment;
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Restoring saved local runtime → ${environment.mode} (${environment.baseCwd})`);
+                }
+                const resumeKey = buildConversationEnvironmentKey(conversationId, environment.baseCwd);
+                const persisted = persistedMapping.status === 'new'
+                    ? null
+                    : persistedMapping.state;
                 const resumeId = savedSessionIds.get(resumeKey) ?? persisted?.claudeSessionId;
                 const session = createSession(conversationId, environment, agentId, client, typingSignals, runtimeState, (convoId, sdkSessionId) => {
                     // Called when session processing loop ends — save session ID for resume
@@ -3080,18 +3006,20 @@ export async function main() {
                     runtimeDescriptor = descriptor;
                     void publishRuntimeHeartbeat();
                 }, {
-                    model: config?.model ?? runtimeModels[0]?.value,
-                    permissionMode: config?.permissionMode ?? 'default',
-                    effort: config?.effort,
-                    ultracode: config?.ultracode,
+                    model: runtimeModels[0]?.value,
+                    permissionMode: 'default',
+                    effort: undefined,
+                    ultracode: undefined,
                     availableModels: runtimeModels,
                     availableExecutionModes: hostAvailableExecutionModes,
+                    defaultExecutionMode,
                     runtimePresentation,
                     approvalManager,
                     runtimeInputManager,
                     canRequestApproval: () => canRequestCanonApproval(conversationId),
                     runtimeId,
                     ownerId,
+                    communicationEnabled,
                     onInputCompleted: (sourceMessageId) => {
                         recoveryCheckpointsFor(conversationId).settle(sourceMessageId);
                         settleInboundMessageId(sourceMessageId, true);
@@ -3100,6 +3028,10 @@ export async function main() {
                 }, resumeId);
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
+                await runtimeState.patchAgentSessionSnapshot(conversationId, {
+                    configurationStatus: 'ready',
+                    lastError: null,
+                });
                 return session;
             }
             catch (error) {
@@ -3151,15 +3083,13 @@ export async function main() {
         }
         const sender = m.senderName || m.senderId;
         const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-        const renderOptions = ownerBoundRenderOptions(isOwner);
-        const content = renderInboundContent(m, materialized, renderOptions);
+        const content = renderInboundContent(m, materialized);
         const hydrated = await loadHydratedInboundContext({
             conversationId: input.conversationId,
             message: m,
             senderName: sender,
             isOwner,
             hydratedPage: input.hydratedPage,
-            renderOptions,
         });
         const behavior = input.hydratedPage?.behavior ?? hydrated.behavior;
         const activeSelfContextId = hydrated.activeSelfContextId;
@@ -3169,7 +3099,6 @@ export async function main() {
             agentId,
             conversationId: input.conversationId,
             logPrefix: `[canon-host] [${input.conversationId.slice(0, 8)}]`,
-            renderOptions,
         });
         const replyContext = replyMedia.replyContext;
         const participantContext = hydrated.participantContext;
@@ -3188,13 +3117,17 @@ export async function main() {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
             console.error(`[canon-host] [${input.conversationId.slice(0, 8)}] Failed to create recovered session: ${message}`);
+            await runtimeState.patchAgentSessionSnapshot(input.conversationId, {
+                configurationStatus: 'configuration_required',
+                lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
+            }).catch(() => { });
             await markQueuedMessageAcceptedForConversation(input.conversationId, m.id ?? null, shouldMarkAccepted);
-            await sendMessageWithRetry(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+            await sendMessageWithRetry(client, input.conversationId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
                 messageId: `claude-start-failed-${m.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
+                    runtimeStatus: 'configuration_required',
                     turnSemantics: 'turn_complete',
                     replyBehavior: 'suppress_auto_reply',
                 },
@@ -3202,7 +3135,7 @@ export async function main() {
             return 'handled';
         }
         session.activeSelfContextId = activeSelfContextId;
-        const basePromptText = buildCanonPrompt({
+        const promptText = buildCanonPrompt({
             content,
             conversationId: input.conversationId,
             participantContext,
@@ -3213,12 +3146,6 @@ export async function main() {
             replyContext,
             message: m,
         });
-        const lifecycleContext = isOwner
-            ? formatPendingContactLifecycleContext(takeLocalRuntimeContactLifecycleEvents(runtimeId, input.conversationId))
-            : null;
-        const promptText = lifecycleContext
-            ? `${basePromptText}\n\n${lifecycleContext}`
-            : basePromptText;
         const messageContent = await buildCanonUserContent({
             promptText,
             materialized: [...replyMedia.materialized, ...materialized],
@@ -3236,7 +3163,7 @@ export async function main() {
                 senderId: m.senderId,
                 senderName: m.senderName,
             }),
-        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes, ownerBoundReplyContactTarget(replyContext));
+        }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
         return 'queued';
     }
     const acceptedInboundMessageIds = new Set();
@@ -3316,27 +3243,6 @@ export async function main() {
         const conversationsDiscoveredWhileOffline = startupRecoveryComplete
             ? new Set([...knownConversationIds].filter((id) => !knownBeforeRefresh.has(id)))
             : new Set();
-        try {
-            let cursor = readLocalRuntimeEntry(runtimeId)?.contactLifecycleCursor ?? null;
-            for (let pageNumber = 0; pageNumber < 10; pageNumber += 1) {
-                const page = await client.listContactRequestLifecyclePage({
-                    cursor,
-                    limit: 100,
-                });
-                await reconcileContactLifecycleEvents({
-                    requests: page.requests,
-                    requesterId: agentId,
-                    record: (request) => recordLocalRuntimeContactLifecycleEvent(runtimeId, request),
-                });
-                cursor = page.nextCursor;
-                saveLocalRuntimeContactLifecycleCursor(runtimeId, cursor);
-                if (!page.hasMore)
-                    break;
-            }
-        }
-        catch (error) {
-            console.error('[canon-host] Contact lifecycle recovery failed:', error instanceof Error ? error.message : error);
-        }
         for (const conversationId of knownConversationIds) {
             const recoveryCheckpoints = recoveryCheckpointsFor(conversationId);
             const recoveryBatch = recoveryCheckpoints.reserveBatch();
@@ -3436,8 +3342,7 @@ export async function main() {
                             console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
                         }
                     }
-                    const renderOptions = ownerBoundRenderOptions(isOwner);
-                    const content = renderInboundContent(m, materialized, renderOptions);
+                    const content = renderInboundContent(m, materialized);
                     const hydrated = await loadHydratedInboundContext({
                         conversationId: convoId,
                         message: m,
@@ -3446,7 +3351,6 @@ export async function main() {
                         activeSelfContextId: payload.activeSelfContextId,
                         selfContexts: payload.selfContexts,
                         provenance: payload.provenance,
-                        renderOptions,
                     });
                     const behavior = payload.behavior ?? hydrated.behavior;
                     const activeSelfContextId = hydrated.activeSelfContextId;
@@ -3456,7 +3360,6 @@ export async function main() {
                         agentId,
                         conversationId: convoId,
                         logPrefix: `[canon-host] [${convoId.slice(0, 8)}]`,
-                        renderOptions,
                     });
                     const replyContext = replyMedia.replyContext;
                     const participantContext = hydrated.participantContext;
@@ -3481,21 +3384,27 @@ export async function main() {
                     }
                     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 runtimeState.patchAgentSessionSnapshot(convoId, {
+                            configurationStatus: 'configuration_required',
+                            lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
+                        }).catch(() => { });
                         await markQueuedMessageAcceptedForConversation(convoId, m.id ?? null, shouldMarkAccepted);
-                        await sendMessageWithRetry(client, convoId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+                        await sendMessageWithRetry(client, convoId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
                             messageId: `claude-start-failed-${m.id}`,
                             ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                             metadata: {
+                                turnId: `claude-start:${m.id}`,
+                                runtimeStatus: 'configuration_required',
                                 turnSemantics: 'turn_complete',
                                 replyBehavior: 'suppress_auto_reply',
                             },
+                            ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
                         }).catch(() => { });
                         return false;
                     }
                     session.activeSelfContextId = activeSelfContextId;
-                    const basePromptText = buildCanonPrompt({
+                    const promptText = buildCanonPrompt({
                         content,
                         conversationId: convoId,
                         participantContext,
@@ -3506,17 +3415,14 @@ export async function main() {
                         replyContext,
                         message: m,
                     });
-                    const lifecycleContext = isOwner
-                        ? formatPendingContactLifecycleContext(takeLocalRuntimeContactLifecycleEvents(runtimeId, convoId))
-                        : null;
-                    const promptText = lifecycleContext
-                        ? `${basePromptText}\n\n${lifecycleContext}`
-                        : basePromptText;
                     const messageContent = await buildCanonUserContent({
                         promptText,
                         materialized: [...replyMedia.materialized, ...materialized],
                     });
-                    const turnModes = resolveClaudeTurnModes(participantContext);
+                    const turnModes = {
+                        ...resolveClaudeTurnModes(participantContext),
+                        replyAuthority: payload.replyAuthority ?? null,
+                    };
                     session.enqueueInbound({
                         type: 'user',
                         message: {
@@ -3529,7 +3435,7 @@ export async function main() {
                             senderId: m.senderId,
                             senderName: m.senderName,
                         }),
-                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes, ownerBoundReplyContactTarget(replyContext));
+                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted, isOwner, m.senderType === 'human' ? m.senderId : null, turnModes);
                     return true;
                 })().then((queued) => {
                     if (!queued) {
@@ -3547,24 +3453,20 @@ export async function main() {
             onConversationUpdated: (payload) => {
                 handleConversationUpdated(payload);
             },
-            onContactRequestUpdated: (payload) => {
-                if (payload.requesterId !== agentId || !payload.sourceConversationId)
-                    return;
-                recordLocalRuntimeContactLifecycleEvent(runtimeId, payload);
-            },
             onReplayExpired: () => {
                 void reconnectRecovery.onReplayExpired().catch((error) => {
-                    console.error('[canon-host] Replay-expired recovery failed:', error);
+                    console.error('[canon-host] Replay-expiry recovery failed:', error instanceof Error ? error.message : error);
                 });
             },
             onConnected: () => {
                 streamConnected = true;
                 void publishRuntimeHeartbeat();
                 const recovery = reconnectRecovery.onConnected();
-                if (recovery)
+                if (recovery) {
                     void recovery.catch((error) => {
-                        console.error('[canon-host] Reconnect recovery failed:', error);
+                        console.error('[canon-host] Reconnect recovery failed:', error instanceof Error ? error.message : error);
                     });
+                }
                 console.error('[canon-host] SSE connected');
             },
             onDisconnected: () => {
@@ -3578,39 +3480,6 @@ export async function main() {
     stream.start().catch((err) => {
         console.error('[canon-host] SSE start error:', err instanceof Error ? err.message : err);
     });
-    // ── Control signal watcher ──
-    // Session control signals (model, mode, effort). A missing/closed session
-    // leaves the node in place; lastSeen still advances, so a stale control is
-    // never replayed once a session exists.
-    async function applyRuntimeSessionControl(event) {
-        const convoId = event.conversationId;
-        const session = sessions.get(convoId);
-        if (!session || session.closed)
-            return { consume: false };
-        const ctrl = event.control;
-        console.error(`[canon-host] [${convoId.slice(0, 8)}] Control:`, 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();
-    }
     // 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) {