@canonmsg/codex-plugin 0.27.0 → 0.29.0

package/dist/host.js

@@ -6,11 +6,11 @@ import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
 import { buildTrailBlockId, buildUndeliverableFinalNotice, captureTurnArtifactSnapshot, createTurnArtifactRouter, IDLE_TIMEOUT_MS, PLAN_BLOCK_TITLE, resolveTurnArtifactRouting, collectMissedInboundMessages, createRecoveryCheckpointTracker, createReconnectRecoveryCoordinator, STARTUP_RECOVERY_PAGE_SIZE, } from '@canonmsg/coding-agent-host';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, HOST_ADMISSION_ACTIONS_DISABLED, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, formatPendingContactLifecycleContext, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, readLocalRuntimeEntry, reconcileContactLifecycleEvents, recordLocalRuntimeContactLifecycleEvent, saveLocalRuntimeContactLifecycleCursor, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveHostWorkspaceCwd, isSilentTurnSuppressed, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, takeLocalRuntimeContactLifecycleEvents, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, resolveQuestionAllowOther, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, buildCanonInboundFrameV1, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, decideAutoReply, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, markLocalRuntimeStopped, normalizeTurnMetadata, parseTurnVerbosityConfig, RuntimeRequestManager, prepareConversationEnvironment, releaseConversationEnvironment, resolveLocalRuntimeSessionState, resolveCanonAgent, verifyResolvedAgentEnvironment, CanonApiError, loadRuntimeSessionState, sendMessageWithRetry, sendMessageWithRetryChunked, saveRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCodingHostInboundPrompt, resolveConfiguredWorkspaceCwd, isSilentTurnSuppressed, resolveSilentTurnDelivery, resolveTurnVerbosity, shouldTriggerAgentTurn, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { validateCard } from '@canonmsg/rich-cards';
 import { CodexConversationAdapter, } from './adapter.js';
 import { CodexAppServerAdapter, } from './app-server-adapter.js';
-import { CODEX_APP_DYNAMIC_TOOLS, CODEX_NO_REPLY_MODEL_TOOL_NAME, CODEX_SERVICE_AGENT_DYNAMIC_TOOLS, answerCodexCanonVerb, answerCodexNoReply, classifyCodexAppToolRequest, deniedCodexAppToolResult, handleCodexAppToolCall, isCanonRuntimeControlToolCall, isCodexAppToolCall, isCodexCanonVerbToolCall, isCodexServiceAgentToolCall, parseCanonRuntimeControlRequest, readCodexNoReplyReason, successfulCodexAppToolResult, } from './codex-app-tools.js';
+import { CODEX_APP_DYNAMIC_TOOLS, CODEX_NO_REPLY_MODEL_TOOL_NAME, CODEX_SERVICE_AGENT_DYNAMIC_TOOLS, answerCodexNoReply, classifyCodexAppToolRequest, deniedCodexAppToolResult, filterCodexCommunicationTools, handleCodexAppToolCall, handleCodexCommunicateToolCall, isCanonRuntimeControlToolCall, isCodexAppToolCall, isCodexCommunicateToolCall, isCodexServiceAgentToolCall, parseCanonRuntimeControlRequest, readCodexNoReplyReason, successfulCodexAppToolResult, } from './codex-app-tools.js';
 import { mapCanonApprovalResultToCodexDecision, mapCodexAppServerApprovalRequest, } from './app-server-approval.js';
 import { clearStoredThreadId, buildCodexThreadPolicyFingerprint, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 import { deriveCodexPermissionEnvelope, mapCanonPermissionToCodex, } from './permission-mode.js';
@@ -30,6 +30,7 @@ COMMON FLAGS
   --cwd <path>                         Project directory to run Codex from
   --workspace <path>                   Additional project to expose in Canon
   --workspace-root <path>              Discover projects under an approved root
+  --default-execution-mode <mode>      New-conversation default: worktree or locked
   --model <model>                      Default Codex model for new turns
   --sandbox <mode>                     Codex sandbox mode
   --full-auto                          Allow non-interactive write access
@@ -68,36 +69,14 @@ export function buildCodexInitialSessionState(input) {
         state: 'idle',
     };
 }
-export function buildCodexLiveSessionConfig(input) {
-    return {
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
-        ...(input.effort ? { effort: input.effort } : {}),
-        ...(input.workspaceId ? { workspaceId: input.workspaceId } : {}),
-        executionMode: input.executionMode,
-        executionBranch: input.executionBranch ?? null,
-    };
-}
-export function buildCodexServiceSnapshotConfig(input) {
-    // Keep every setup key present, including keys whose host value is
-    // undefined. `publishHostSessionSnapshots` merges this over any persisted
-    // coding config, so an absent host value clears rather than resurrects a
-    // stale member-selected value.
-    return {
-        model: input.model,
-        permissionMode: input.permissionMode,
-        effort: input.effort,
-        workspaceId: input.workspaceId,
-        executionMode: 'locked',
-        executionBranch: null,
-    };
-}
 const MAX_SESSIONS = 12;
 export function createCodexRecoveryCheckpointTracker(persist) {
     return createRecoveryCheckpointTracker(persist);
 }
 // IDLE_TIMEOUT_MS (30 minutes) is shared with the other coding-agent hosts.
 const HEARTBEAT_MS = 30_000;
+const LOCAL_CONFIGURATION_REQUIRED_MESSAGE = 'This agent needs local runtime configuration before it can start this conversation. '
+    + 'Its operator must configure it and retry.';
 /** How Codex says it finished the work but Canon would not take the answer. */
 const CODEX_UNDELIVERABLE_FINAL_WORDING = {
     lead: 'The Codex host completed the turn, but Canon could not deliver the reply',
@@ -112,18 +91,13 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsNonFinalPermanentMessages: false,
 };
 let workingDir = process.cwd();
-/**
- * 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;
 let workspaceOptions = [];
 let workspaceRoots = [];
 let workspaceRootMetadata = [];
 /** Conservative fallback used only when native app-server discovery is unavailable. */
 export const CODEX_EFFORT_OPTIONS = FALLBACK_CODEX_EFFORT_OPTIONS;
-export const CODEX_SESSION_CONFIG_FIELDS = ['permissionMode', 'effort'];
 const MAX_CODEX_SKILL_COMMAND_CHOICES = 50;
 export function buildCodexSkillCommands(skills) {
     return skills
@@ -199,6 +173,7 @@ export function buildCodexRuntimeDescriptor(input) {
         workspaces: serviceAgentMode ? [] : input.workspaces,
         workspaceRoots: serviceAgentMode ? undefined : input.workspaceRoots,
         executionModes: serviceAgentMode ? [] : input.executionModes,
+        defaultExecutionMode: serviceAgentMode ? 'locked' : input.defaultExecutionMode,
         permissionModes: serviceAgentMode ? [] : input.permissionModes,
         defaultPermissionMode: serviceAgentMode ? undefined : input.defaultPermissionMode,
         permissionModeLabel: 'Execution policy',
@@ -210,9 +185,6 @@ export function buildCodexRuntimeDescriptor(input) {
         effortLiveBehavior: 'next_turn',
         presentation: input.presentation,
         streamingTextMode: 'snapshot',
-        admissionActions: input.supportsCanonCommunicationTools && !serviceAgentMode
-            ? { ...HOST_ADMISSION_ACTIONS_DISABLED, requestContact: true, reachOut: true }
-            : HOST_ADMISSION_ACTIONS_DISABLED,
         ...(input.supportsPlanMode && !serviceAgentMode
             ? {
                 turnModes: [
@@ -284,29 +256,22 @@ export function getCodexRequestingUserId(message) {
 async function publishAgentRuntime(agentId, runtime, rtdb) {
     await publishHostAgentRuntime(agentId, 'codex', runtime, rtdb);
 }
-async function loadSessionConfig(conversationId, agentId, rtdb, retryMissing = true) {
-    return loadHostSessionConfig({
-        conversationId,
-        agentId,
-        rtdb,
-        extraStringFields: CODEX_SESSION_CONFIG_FIELDS,
-        retryMissingMs: retryMissing ? 3_000 : 0,
-    });
-}
-export function resolveSessionExecutionMode(config, serviceAgentMode = false) {
+export function resolveSessionExecutionMode(serviceAgentMode = false, defaultExecutionMode = 'worktree') {
     if (serviceAgentMode)
         return 'locked';
-    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.');
+    return defaultExecutionMode;
 }
-export function resolveCodexSessionConfig(config, serviceAgentMode = false) {
-    return serviceAgentMode ? null : config ?? null;
+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');
 }
-export function resolveWorkspaceCwd(config, serviceAgentMode = false) {
-    return resolveHostWorkspaceCwd({
+export function resolveWorkspaceCwd() {
+    return resolveConfiguredWorkspaceCwd({
         workspaceOptions,
-        config: serviceAgentMode ? null : config,
+        workspaceId: workspaceOptions[0]?.id,
         defaultCwd: workingDir,
     });
 }
@@ -377,8 +342,8 @@ function buildCanonPrompt(input) {
         message: input.message,
     })), input.noReplyToolName ? { noReplyToolName: input.noReplyToolName } : {});
 }
-function renderInboundContent(message, materialized, options) {
-    return renderCanonHostInboundContent(message, materialized, options);
+function renderInboundContent(message, materialized) {
+    return renderCanonHostInboundContent(message, materialized);
 }
 async function materializePromptReplyContext(input) {
     if (!input.replyContext?.found || !input.replyContext.attachments?.length) {
@@ -395,16 +360,6 @@ async function materializePromptReplyContext(input) {
         return { replyContext: 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,
-    };
-}
 function summarizeCommand(command) {
     const trimmed = command.trim();
     if (!trimmed)
@@ -650,6 +605,7 @@ export async function main() {
             'add-dir': { type: 'string', multiple: true },
             workspace: { type: 'string', multiple: true },
             'workspace-root': { type: 'string', multiple: true },
+            'default-execution-mode': { type: 'string' },
             config: { type: 'string', multiple: true },
             'codex-bin': { type: 'string' },
             'runtime-visibility': { type: 'string' },
@@ -674,8 +630,11 @@ export async function main() {
         onWarning: (message) => console.error(`[canon-codex] ${message}`),
     });
     const serviceAgentMode = args['service-agent'] === true;
+    const defaultExecutionMode = serviceAgentMode
+        ? 'locked'
+        : resolveConfiguredDefaultExecutionMode(args['default-execution-mode']);
     const nativeVisionEnabled = args['no-native-vision'] !== true;
-    const codexDynamicTools = serviceAgentMode
+    const baseCodexDynamicTools = serviceAgentMode
         ? CODEX_SERVICE_AGENT_DYNAMIC_TOOLS
         : CODEX_APP_DYNAMIC_TOOLS;
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
@@ -720,11 +679,13 @@ export async function main() {
     let agentId;
     let ownerId = null;
     let ownerName = null;
+    let outboundPolicy = null;
     try {
         const ctx = await client.getAgentMe();
         agentId = ctx.agentId;
         ownerId = ctx.ownerId;
         ownerName = ctx.ownerName;
+        outboundPolicy = ctx.outboundPolicy;
         console.error(`[canon-codex] Connected as ${ctx.displayName || agentId}`);
     }
     catch {
@@ -737,6 +698,7 @@ export async function main() {
         }
         console.error(`[canon-codex] Authenticated as ${agentId}`);
     }
+    let codexDynamicTools = filterCodexCommunicationTools(baseCodexDynamicTools, outboundPolicy);
     // Shared poll/timeout engine. Built-in `input`/`card` descriptors own
     // create+poll (codex passes native/responder policy via payload/options).
     // Approval keeps codex's own resolution shape (no owner-authored outcome
@@ -927,34 +889,11 @@ export async function main() {
             ownerName,
             membershipChange: pendingMembershipChanges.get(input.conversationId) ?? null,
             groupContextMode: getGroupContextMode(input.conversationId, conversation),
-            renderOptions: input.renderOptions,
         });
     }
     function writeState(session) {
-        const appliedAt = Date.now();
-        const controlState = {};
-        if (session.state.model !== undefined) {
-            controlState.model = { value: session.state.model, source: 'applied', appliedAt };
-        }
-        if (session.state.permissionMode !== undefined) {
-            controlState.permissionMode = { value: session.state.permissionMode, source: 'applied', appliedAt };
-        }
-        if (session.state.effort !== undefined) {
-            controlState.effort = { value: session.state.effort, source: 'applied', appliedAt };
-        }
         runtimeState.writeSessionState(session.conversationId, {
             lastError: session.state.lastError,
-            model: session.state.model,
-            permissionMode: session.state.permissionMode,
-            effort: session.state.effort,
-            controlState,
-            cwd: session.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,
             clientType: 'codex',
             isActive: true,
@@ -1225,7 +1164,7 @@ export async function main() {
             session.currentTurnOpenedAt = null;
             session.currentTurnUpdatedAt = null;
             session.currentTurnCanUseCodexAppTools = false;
-            session.currentTurnCanUseCodexCanonTools = false;
+            session.currentReplyAuthority = null;
             session.currentTurnSilenced = false;
             session.lastAcceptedIntent = null;
             session.resetRequested = false;
@@ -1263,20 +1202,47 @@ export async function main() {
             evictOldestIdle();
         }
         const creation = (async () => {
-            const config = resolveCodexSessionConfig(await loadSessionConfig(conversationId, agentId, rtdb, !serviceAgentMode), serviceAgentMode);
-            const sessionExecutionMode = resolveSessionExecutionMode(config, serviceAgentMode);
-            const workspaceCwd = resolveWorkspaceCwd(config, serviceAgentMode);
-            const environment = prepareConversationEnvironment({
+            const sessionExecutionMode = resolveSessionExecutionMode(serviceAgentMode, defaultExecutionMode);
+            const workspaceCwd = resolveWorkspaceCwd();
+            let environment = prepareConversationEnvironment({
                 agentId,
                 conversationId,
                 workspaceCwd,
                 allowWorktrees: sessionExecutionMode === 'worktree',
             });
             try {
+                const persistedMapping = resolveLocalRuntimeSessionState(runtimeId, {
+                    conversationId,
+                    baseCwd: environment.baseCwd,
+                    executionMode: environment.mode,
+                    resumeField: 'threadId',
+                    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-codex] [${conversationId.slice(0, 8)}] Restoring saved local runtime → ${environment.mode} (${environment.baseCwd})`);
+                }
                 const sessionCwd = environment.cwd;
                 const policy = resolveCodexEffectiveRuntimePolicy({
                     args,
-                    config,
+                    config: null,
                     permissionEnvelope: codexPermissionEnvelope,
                     environment,
                     serviceAgentMode,
@@ -1285,12 +1251,17 @@ export async function main() {
                 if (modelGuard) {
                     throw new ExecutionEnvironmentError(modelGuard, modelGuard);
                 }
-                const storedThreadId = loadStoredThreadId(runtimeId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint);
+                const storedThreadId = loadStoredThreadId(runtimeId, conversationId, environment.baseCwd, environment.mode, policy.fingerprint, {
+                    ...(persistedMapping.status === 'new' || !persistedMapping.state.workspaceId
+                        ? {}
+                        : { workspaceId: persistedMapping.state.workspaceId }),
+                    allowLegacyPolicyMigration: persistedMapping.status !== 'new',
+                });
                 const effectiveModel = policy.model ?? codexDefaultModel;
                 const initialEffortResolution = resolveCodexEffortForModel({
                     models: codexModels,
                     model: effectiveModel,
-                    requestedEffort: config?.effort ?? configuredCodexEffort,
+                    requestedEffort: configuredCodexEffort,
                 });
                 const initialEffort = initialEffortResolution.value;
                 const adapter = useAppServer
@@ -1338,8 +1309,7 @@ export async function main() {
                     currentTurnOpenedAt: null,
                     currentTurnUpdatedAt: null,
                     currentTurnCanUseCodexAppTools: false,
-                    currentTurnCanUseCodexCanonTools: false,
-                    currentTurnReplyContactTarget: null,
+                    currentReplyAuthority: null,
                     currentTurnAbortController: null,
                     // Corrected by the first turn that runs; a session with no turn
                     // publishes nothing anyway, and quiet is never an accident.
@@ -1357,6 +1327,10 @@ export async function main() {
                 };
                 sessions.set(conversationId, session);
                 await controlPoller.baseline([conversationId]);
+                await runtimeState.patchAgentSessionSnapshot(conversationId, {
+                    configurationStatus: 'ready',
+                    lastError: null,
+                });
                 console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Environment → ${environment.mode} (${sessionCwd})`);
                 writeState(session);
                 writeTurn(session);
@@ -1386,10 +1360,9 @@ export async function main() {
             planMode,
             artifactRoutingMode: turn.artifactRoutingMode ?? 'disabled',
             canUseCodexAppTools: turn.canUseCodexAppTools ?? false,
-            canUseCodexCanonTools: turn.canUseCodexCanonTools ?? false,
             ...(turn.turnVerbosity ? { turnVerbosity: turn.turnVerbosity } : {}),
             requestingUserId: turn.requestingUserId ?? null,
-            ...(turn.replyContactTarget ? { replyContactTarget: turn.replyContactTarget } : {}),
+            replyAuthority: turn.replyAuthority ?? null,
         };
         if (toFront) {
             session.queue.unshift(nextPrompt);
@@ -1420,38 +1393,6 @@ export async function main() {
             requestingUserId: responseUserId,
         });
     }
-    function recordContactLifecycleEvent(request) {
-        if (request.requesterId !== agentId || !request.sourceConversationId)
-            return false;
-        return recordLocalRuntimeContactLifecycleEvent(runtimeId, request);
-    }
-    async function reconcileContactLifecycleInbox() {
-        let cursor = readLocalRuntimeEntry(runtimeId)?.contactLifecycleCursor ?? null;
-        let recorded = 0;
-        let duplicate = 0;
-        let ignored = 0;
-        for (let pageNumber = 0; pageNumber < 10; pageNumber += 1) {
-            const page = await client.listContactRequestLifecyclePage({
-                cursor,
-                limit: 100,
-            });
-            const result = await reconcileContactLifecycleEvents({
-                requests: page.requests,
-                requesterId: agentId,
-                record: (request) => recordLocalRuntimeContactLifecycleEvent(runtimeId, request),
-            });
-            recorded += result.recorded;
-            duplicate += result.duplicate;
-            ignored += result.ignored;
-            cursor = page.nextCursor;
-            saveLocalRuntimeContactLifecycleCursor(runtimeId, cursor);
-            if (!page.hasMore)
-                break;
-        }
-        if (recorded > 0) {
-            console.error(`[canon-codex] Contact lifecycle recovery: recorded=${recorded} duplicate=${duplicate} ignored=${ignored}`);
-        }
-    }
     function resolveArtifactRoutingMode(participantContext) {
         return participantContext.conversationType === 'direct' && participantContext.isOwner
             ? 'workspace-generated'
@@ -1463,19 +1404,15 @@ export async function main() {
      * so a prompt that waits behind another still runs under the answer it
      * arrived with.
      */
-    function resolveCodexTurnModes(participantContext, message, replyContext) {
+    function resolveCodexTurnModes(participantContext, message) {
         return {
             artifactRoutingMode: resolveArtifactRoutingMode(participantContext),
             canUseCodexAppTools: participantContext.isOwner || serviceAgentMode,
-            canUseCodexCanonTools: participantContext.isOwner && !serviceAgentMode,
             turnVerbosity: resolveTurnVerbosity({
                 configured: configuredTurnVerbosity,
                 conversationType: participantContext.conversationType,
             }),
             requestingUserId: getCodexRequestingUserId(message),
-            ...(participantContext.isOwner && replyContext
-                ? { replyContactTarget: ownerBoundReplyContactTarget(replyContext) }
-                : {}),
         };
     }
     function runtimeCardRequestPayload(method, params) {
@@ -1492,6 +1429,15 @@ export async function main() {
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
         if (request.method === 'item/tool/call' && isCodexAppToolCall(params)) {
+            if (isCodexCommunicateToolCall(params)) {
+                if (!(session.adapter instanceof CodexAppServerAdapter)) {
+                    return deniedCodexAppToolResult('This Codex transport does not support dynamic tools.');
+                }
+                if (outboundPolicy !== 'open' && outboundPolicy !== 'approval-required') {
+                    return deniedCodexAppToolResult('Outbound communication is not enabled by the agent operator.');
+                }
+                return handleCodexCommunicateToolCall(client, params);
+            }
             if (serviceAgentMode && !isCodexServiceAgentToolCall(params)) {
                 return deniedCodexAppToolResult('This service agent exposes only Canon conversation tools.');
             }
@@ -1517,23 +1463,6 @@ export async function main() {
             if (disposition === 'denied-non-owner') {
                 return deniedCodexAppToolResult('Only the Canon owner can use codex_app tools.');
             }
-            if (isCodexCanonVerbToolCall(params)) {
-                if (!session.currentTurnCanUseCodexCanonTools) {
-                    return deniedCodexAppToolResult('Canon contact and conversation tools require a real owner-authored inbound turn.');
-                }
-                return await answerCodexCanonVerb({
-                    client,
-                    params,
-                    context: {
-                        conversationId: session.conversationId,
-                        sourceMessageId,
-                        turnId: session.currentTurnId,
-                        ...(session.currentTurnReplyContactTarget
-                            ? { replyContactTarget: session.currentTurnReplyContactTarget }
-                            : {}),
-                    },
-                });
-            }
             if (isCanonRuntimeControlToolCall(params)) {
                 const command = parseCanonRuntimeControlRequest(params);
                 if (!command) {
@@ -1641,6 +1570,8 @@ export async function main() {
                 currentThreadId: session.adapter.getThreadId(),
                 currentCwd: session.cwd,
                 workspaces: workspaceOptions,
+                communicationEnabled: outboundPolicy === 'open'
+                    || outboundPolicy === 'approval-required',
                 model: session.state.model ?? null,
                 effort: session.state.effort ?? null,
             }, params);
@@ -1873,8 +1804,7 @@ export async function main() {
                 console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to materialize media:`, error instanceof Error ? error.message : error);
             }
         }
-        const renderOptions = resolveInboundContentRenderOptions(input.isOwner);
-        const renderedContent = renderInboundContent(input.message, materialized, renderOptions);
+        const renderedContent = renderInboundContent(input.message, materialized);
         const turnMetadata = normalizeTurnMetadata(input.message.metadata);
         const requestedPlanMode = turnMetadata?.requestedTurnMode === 'plan';
         const planCommand = resolveCodexPlanCommand({
@@ -1893,7 +1823,6 @@ export async function main() {
             selfContexts: input.selfContexts,
             provenance: input.provenance,
             hydratedPage: input.hydratedPage,
-            renderOptions,
         });
         const behavior = input.behavior ?? hydrated.behavior;
         const activeSelfContextId = hydrated.activeSelfContextId;
@@ -1933,22 +1862,28 @@ 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-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
+            await runtimeState.patchAgentSessionSnapshot(input.conversationId, {
+                configurationStatus: 'configuration_required',
+                lastError: LOCAL_CONFIGURATION_REQUIRED_MESSAGE,
+            }).catch(() => { });
             await markQueuedMessageAccepted(input.conversationId, input.message.id, shouldMarkAccepted);
-            await sendMessageWithRetryChunked(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+            await sendMessageWithRetryChunked(client, input.conversationId, LOCAL_CONFIGURATION_REQUIRED_MESSAGE, {
                 messageId: `codex-start-failed-${input.message.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
+                    turnId: `codex-start:${input.message.id}`,
+                    runtimeStatus: 'configuration_required',
                     turnSemantics: 'turn_complete',
                     replyBehavior: 'suppress_auto_reply',
                 },
+                ...(input.replyAuthority ? { replyAuthority: input.replyAuthority } : {}),
             }).catch(() => { });
             recoveryCheckpointsFor(input.conversationId).settle(input.message.id);
             return;
         }
         session.activeSelfContextId = activeSelfContextId;
-        const basePrompt = buildCanonPrompt({
+        const prompt = buildCanonPrompt({
             content,
             conversationId: input.conversationId,
             participantContext,
@@ -1960,12 +1895,11 @@ export async function main() {
             message: input.message,
             ...(useAppServer ? { noReplyToolName: CODEX_NO_REPLY_MODEL_TOOL_NAME } : {}),
         });
-        const lifecycleContext = input.isOwner
-            ? formatPendingContactLifecycleContext(takeLocalRuntimeContactLifecycleEvents(runtimeId, input.conversationId))
-            : null;
-        const prompt = lifecycleContext ? `${basePrompt}\n\n${lifecycleContext}` : basePrompt;
         if (session.running && deliveryIntent === 'interrupt') {
-            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, resolveCodexTurnModes(participantContext, input.message, replyContext));
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
+                ...resolveCodexTurnModes(participantContext, input.message),
+                replyAuthority: input.replyAuthority ?? null,
+            });
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
             session.currentTurnAbortController?.abort(new Error('Codex turn interrupted by a newer message'));
             await session.adapter.interrupt().catch(() => { });
@@ -1973,10 +1907,14 @@ export async function main() {
             typingSignals.clear(input.conversationId).catch(() => { });
             return;
         }
-        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, resolveCodexTurnModes(participantContext, input.message, replyContext));
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode, {
+            ...resolveCodexTurnModes(participantContext, input.message),
+            replyAuthority: input.replyAuthority ?? null,
+        });
     }
     function sendTurnArtifactFile(session, file) {
         return sendMediaFileMessage(client, session.conversationId, file.path, '', {
+            ...(session.currentReplyAuthority ? { replyAuthority: session.currentReplyAuthority } : {}),
             ...(session.activeSelfContextId ? { selfContextId: session.activeSelfContextId } : {}),
             metadata: {
                 ...(session.currentTurnId ? { turnId: session.currentTurnId } : {}),
@@ -2004,8 +1942,7 @@ export async function main() {
         session.currentTurnOpenedAt = Date.now();
         session.currentTurnUpdatedAt = session.currentTurnOpenedAt;
         session.currentTurnCanUseCodexAppTools = nextTurn.canUseCodexAppTools === true;
-        session.currentTurnCanUseCodexCanonTools = nextTurn.canUseCodexCanonTools === true;
-        session.currentTurnReplyContactTarget = nextTurn.replyContactTarget ?? null;
+        session.currentReplyAuthority = nextTurn.replyAuthority;
         session.currentTurnAbortController = new AbortController();
         // A continuation prompt (a plan-review result) carries none, and keeps the
         // conversation's last answer rather than silently reverting to verbose.
@@ -2310,6 +2247,9 @@ export async function main() {
                 const turnTrail = buildFinalTurnTrail(session);
                 await sendMessageWithRetryChunked(client, session.conversationId, result.finalMessage, {
                     messageId: buildCodexMessageId(session, 'final'),
+                    ...(session.currentReplyAuthority
+                        ? { replyAuthority: session.currentReplyAuthority }
+                        : {}),
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
                         : {}),
@@ -2335,6 +2275,9 @@ export async function main() {
                 const turnTrail = buildFinalTurnTrail(session);
                 await sendMessageWithRetryChunked(client, session.conversationId, userVisibleError, {
                     messageId: buildCodexMessageId(session, 'error'),
+                    ...(session.currentReplyAuthority
+                        ? { replyAuthority: session.currentReplyAuthority }
+                        : {}),
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
                         : {}),
@@ -2391,6 +2334,9 @@ export async function main() {
             await routeArtifactsOnce();
             await sendMessageWithRetryChunked(client, session.conversationId, message, {
                 messageId: buildCodexMessageId(session, 'failure'),
+                ...(session.currentReplyAuthority
+                    ? { replyAuthority: session.currentReplyAuthority }
+                    : {}),
                 ...(session.activeSelfContextId
                     ? { selfContextId: session.activeSelfContextId }
                     : {}),
@@ -2419,8 +2365,7 @@ export async function main() {
             session.currentTurnOpenedAt = null;
             session.currentTurnUpdatedAt = null;
             session.currentTurnCanUseCodexAppTools = false;
-            session.currentTurnCanUseCodexCanonTools = false;
-            session.currentTurnReplyContactTarget = null;
+            session.currentReplyAuthority = null;
             session.currentTurnSilenced = false;
             session.lastAcceptedIntent = null;
             session.resetRequested = false;
@@ -2479,6 +2424,7 @@ export async function main() {
     });
     let codexSkills = [];
     const buildCurrentRuntimeDescriptor = () => ({
+        defaultExecutionMode,
         ...(serviceAgentMode
             ? {}
             : {
@@ -2498,31 +2444,18 @@ export async function main() {
             workspaces: buildPublicWorkspaceOptions(workspaceOptions),
             workspaceRoots: workspaceRootMetadata,
             executionModes: hostAvailableExecutionModes,
+            defaultExecutionMode,
             permissionModes: [...codexPermissionEnvelope.availablePermissionModes],
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
             supportsPlanMode: useAppServer,
             supportsCompact: useAppServer,
             supportsRichCards: useAppServer,
-            supportsCanonCommunicationTools: useAppServer,
             skills: codexSkills,
             serviceAgentMode,
         }),
     });
     let runtimeDescriptor = buildCurrentRuntimeDescriptor();
-    const resolveInboundContentRenderOptions = (isOwnerTurn) => {
-        const descriptorActions = runtimeDescriptor.runtimeDescriptor?.admissionActions
-            ?? HOST_ADMISSION_ACTIONS_DISABLED;
-        const admissionActions = isOwnerTurn && useAppServer && !serviceAgentMode
-            ? descriptorActions
-            : HOST_ADMISSION_ACTIONS_DISABLED;
-        return {
-            admissionActions,
-            ...(admissionActions.reachOut
-                ? { reachOutToolName: 'codex_app.canon_send_to' }
-                : {}),
-        };
-    };
     async function refreshCodexSkillInventory(forceReload = false) {
         if (!useAppServer)
             return;
@@ -2561,64 +2494,6 @@ export async function main() {
             probe.close();
         }
     }
-    function applySessionControl(conversationId, control) {
-        const session = sessions.get(conversationId);
-        if (!session || session.closed)
-            return;
-        if (serviceAgentMode) {
-            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring user session controls for service-agent runtime`);
-            writeState(session);
-            return;
-        }
-        let modelChanged = false;
-        if (control.model && control.model !== session.state.model) {
-            if (codexModelOptions.length > 0 && !codexModelOptions.some((option) => option.value === control.model)) {
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Ignoring model outside the discovered Codex catalog (${control.model})`);
-                writeState(session);
-                return;
-            }
-            const modelGuard = buildCodexModelGuardMessage(control.model, codexCliStatus);
-            if (modelGuard) {
-                session.state.lastError = modelGuard;
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${modelGuard}`);
-                writeState(session);
-                // The poller consumes the node; skip effort handling for this pass,
-                // matching the legacy loop.
-                return;
-            }
-            session.adapter.setModel(control.model);
-            session.state.model = control.model;
-            modelChanged = true;
-            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Model set for next turn -> ${control.model}`);
-        }
-        if (control.permissionMode) {
-            console.error(`[canon-codex] [${conversationId.slice(0, 8)}] approval mode is session-creation-only; ignoring mid-session change request (${control.permissionMode})`);
-            // Convergence contract: a consumed session control must always be
-            // answered. Re-publish the currently applied state so clients settle on
-            // the authoritative value instead of holding the composer until timeout.
-        }
-        if (control.effort || modelChanged) {
-            const effortResolution = resolveCodexEffortForModel({
-                models: codexModels,
-                model: session.state.model,
-                requestedEffort: control.effort ?? session.state.effort,
-            });
-            if (effortResolution.value !== session.state.effort) {
-                session.adapter.setReasoningEffort(effortResolution.value);
-                session.state.effort = effortResolution.value ?? undefined;
-            }
-            if (control.effort && !effortResolution.accepted) {
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${control.effort} is unsupported by ${session.state.model ?? 'the active model'}; reset to ${effortResolution.value ?? 'the model default'}`);
-            }
-            else if (control.effort) {
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Reasoning effort set for next turn -> ${control.effort}`);
-            }
-            else if (modelChanged && effortResolution.value) {
-                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Reasoning effort for ${session.state.model} -> ${effortResolution.value}`);
-            }
-        }
-        writeState(session);
-    }
     async function handleControlSignal(event) {
         const { conversationId, type } = event;
         const session = sessions.get(conversationId);
@@ -2684,9 +2559,6 @@ export async function main() {
         conversationIds: () => sessions.keys(),
         hasActiveWork: () => [...sessions.values()].some((session) => !session.closed
             && (session.running || session.queue.length > 0 || session.turnState === 'waiting_input')),
-        onSessionControl: ({ conversationId, control }) => {
-            applySessionControl(conversationId, control);
-        },
         onSignal: handleControlSignal,
         onPrimitive: handleControlPrimitive,
         onError: (error) => {
@@ -2722,41 +2594,6 @@ export async function main() {
                 agentId,
                 rtdb,
                 clientType: 'codex',
-                runtime: runtimeDescriptor,
-                workspaceOptions,
-                defaultCwd: workingDir,
-                extraSessionConfigFields: CODEX_SESSION_CONFIG_FIELDS,
-                liveSessionConfigByConversation: new Map(Array.from(serviceAgentMode ? knownConversationIds : sessions.keys()).map((conversationId) => {
-                    const session = sessions.get(conversationId);
-                    if (serviceAgentMode) {
-                        return [
-                            conversationId,
-                            buildCodexServiceSnapshotConfig({
-                                model: codexDefaultModel ?? session?.state.model ?? undefined,
-                                permissionMode: codexPermissionEnvelope.defaultPermissionMode,
-                                effort: codexDefaultEffort ?? session?.state.effort ?? undefined,
-                                workspaceId: resolveWorkspaceIdForBaseCwd(workingDir) ?? undefined,
-                            }),
-                        ];
-                    }
-                    if (!session) {
-                        // Non-service snapshots are published only for live sessions,
-                        // but keep this branch total if that invariant changes.
-                        return [conversationId, {}];
-                    }
-                    const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
-                    return [
-                        conversationId,
-                        buildCodexLiveSessionConfig({
-                            model: session.state.model,
-                            permissionMode: session.state.permissionMode,
-                            effort: session.state.effort,
-                            workspaceId,
-                            executionMode: session.environment.mode,
-                            executionBranch: session.environment.branch ?? null,
-                        }),
-                    ];
-                })),
             }).catch((error) => {
                 console.error('[canon-codex] Failed to publish session snapshots:', error);
             });
@@ -2844,12 +2681,6 @@ export async function main() {
         const conversationsDiscoveredWhileOffline = startupRecoveryComplete
             ? new Set([...knownConversationIds].filter((id) => !knownBeforeRefresh.has(id)))
             : new Set();
-        try {
-            await reconcileContactLifecycleInbox();
-        }
-        catch (error) {
-            console.error('[canon-codex] Contact lifecycle recovery failed:', error instanceof Error ? error.message : error);
-        }
         for (const conversationId of knownConversationIds) {
             const recoveryCheckpoints = recoveryCheckpointsFor(conversationId);
             const recoveryBatch = recoveryCheckpoints.reserveBatch();
@@ -2946,6 +2777,7 @@ export async function main() {
                     selfContexts: payload.selfContexts,
                     provenance: payload.provenance,
                     turnDispatch: payload.turnDispatch,
+                    replyAuthority: payload.replyAuthority,
                 }).then(() => settleInboundMessageId(message.id, true), (error) => {
                     settleInboundMessageId(message.id, false);
                     console.error(`[canon-codex] [${payload.conversationId.slice(0, 8)}] Failed to queue inbound message:`, error instanceof Error ? error.message : error);
@@ -2957,8 +2789,11 @@ export async function main() {
             onConversationUpdated: (payload) => {
                 handleConversationUpdated(payload);
             },
-            onContactRequestUpdated: (payload) => {
-                recordContactLifecycleEvent(payload);
+            onAgentContext: (context) => {
+                ownerId = context.ownerId;
+                ownerName = context.ownerName;
+                outboundPolicy = context.outboundPolicy;
+                codexDynamicTools = filterCodexCommunicationTools(baseCodexDynamicTools, outboundPolicy);
             },
             onConnected: () => {
                 streamConnected = true;