@borgee/agents-host 0.2.97 → 0.2.110

package/dist/agents-host.js

@@ -1,3 +1,4 @@
+import { readNormalizedInputText, readDurableInputText } from './chat/normalized-input.js';
 import { randomUUID } from 'node:crypto';
 import { chmod, link, mkdir, readFile, readdir, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -5,6 +6,10 @@ import { SdkChatControlPlane } from './chat/sdk-chat-control-plane.js';
 import { HostLogger, summarizeError } from './debug.js';
 import { toReportedActivity } from './progress-to-activity.js';
 import { BackgroundRunTracker } from './background-runs.js';
+import { ExecutionDeliveryJournal, ExecutionTelemetryReporter, } from './execution-telemetry.js';
+import { startTypingLease } from './typing-lease.js';
+import { recordProtocolTrace, NormalizedActivityPublisher, NormalizedExecutionTelemetry, sessionControlResponse, parseSessionControlRequest } from './plugin-sdk.js';
+import { respondToHostedInteraction } from './providers/normalized/interactions.js';
 import { ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE, COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE, COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE, COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, TASK_THREAD_COLLABORATION_CONTRACT_COMPATIBILITY_GATE, TOKEN_BINDING_COMPATIBILITY_GATE, } from './compatibility-gates.js';
 import { buildNormalizedAttentionSnapshot, parsePersistedAttentionSnapshot, } from './context/attention.js';
 import { mergeCompactionSnapshot, parsePersistedCompactionSnapshot, } from './context/compaction.js';
@@ -13,8 +18,8 @@ import { createLocalhostGatewayController, LOCALHOST_GATEWAY_COLLABORATION_TARGE
 import { extractTaskIdFromTaskAssignmentContent, resolveTaskAssignmentStatePath, } from './context/injection.js';
 import { AuthorizationAuditSink, } from './policy/authorization-audit.js';
 import { createProvider } from './providers/create-provider.js';
-import { ProviderTurnCancelledError } from './providers/provider-adapter.js';
-import { resolveAttentionStatePath, resolveCompactionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
+import { ProviderInputRejectedError, ProviderTurnCancelledError } from './providers/provider-adapter.js';
+import { resolveAttentionStatePath, resolveCompactionStatePath, resolveExecutionDeliveryJournalPath, resolveExecutionTelemetryOutboxPath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
 import { appendVisibleMention as appendVisibleBodyMention, extractVisibleMentionIds as extractCanonicalMentionIds, } from './visible-mentions.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts, extractHostedMessageAttachments, normalizeHostedMessageAttachment, } from './hosted-turn-content.js';
 import { waitForTaskForThread } from './task-thread-resolution.js';
@@ -110,6 +115,24 @@ class DefaultHostRuntime {
             deps.borgee ??
                 new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, {
                     pluginId: `agents-host:${config.agent.provider}`,
+                    executionTelemetryOutboxPath: resolveExecutionTelemetryOutboxPath(config.stateRootDir),
+                    onExecutionTelemetryError: (error) => {
+                        deps.logger.error('execution telemetry transport failed', {
+                            error: summarizeError(error),
+                        });
+                    },
+                    providerOutputMode: () => this.provider.outputMode ?? 'legacy',
+                    connectionLiveness: () => config.agent.provider === 'codex' && this.provider.outputMode === 'normalized'
+                        ? { probeIntervalMs: 30_000, pongTimeoutMs: 10_000, connectTimeoutMs: 30_000 }
+                        : undefined,
+                    normalizedActivitySync: () => this.provider.outputMode === 'normalized' && !!this.provider.syncNormalizedActivity,
+                    sessionControl: () => this.provider.outputMode === 'normalized' && !!this.provider.controlSession,
+                    sessionBindings: () => this.provider.outputMode === 'normalized' && !!this.provider.setSessionPublication,
+                    sessionRelations: () => this.provider.outputMode === 'normalized' && !!this.provider.describeSession,
+                    sessionManagement: () => this.provider.outputMode === 'normalized' && this.provider.supportsSessionManagement === true,
+                    sessionDirectory: () => this.provider.outputMode === 'normalized' && !!this.provider.listSessions,
+                    sessionObservation: () => this.provider.outputMode === 'normalized' && !!this.provider.observeSession,
+                    sessionInputOperations: () => this.provider.outputMode === 'normalized' ? this.provider.sessionInputOperations ?? [] : [],
                 });
         this.gateway = createLocalhostGatewayController({
             gateEnabled: localhostGatewayGateEnabled,
@@ -133,6 +156,12 @@ class DefaultHostRuntime {
                     stateRootDir: config.stateRootDir,
                     agentApiKey: config.agent.agentApiKey,
                     resolveStableAgentId: deps.resolveStableAgentId,
+                    providerOutputMode: config.providerOutputMode,
+                    nativeProviderCommand: config.nativeProviderCommand,
+                    sessionWorkspaceRoot: config.sessionWorkspaceRoot,
+                    codexConnectionMode: config.codexConnectionMode,
+                    codexSharedSocketPath: config.codexSharedSocketPath,
+                    codexTrustShared: config.codexTrustShared,
                     claudeCommand: config.claudeCommand,
                     claudeArgs: config.claudeArgs,
                     codexCommand: config.codexCommand,
@@ -150,16 +179,19 @@ class DefaultHostRuntime {
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
     }
-    async start(onMessage, onStopTurn, onStopBackgroundRun, onActivityTransportReady) {
+    async start(onMessage, onStopTurn, onStopBackgroundRun, onActivityTransportReady, onSessionControl) {
         await this.ensureStateRoot(this.config.stateRootDir);
         await this.gateway.start();
         try {
+            if (this.provider.outputMode === 'normalized')
+                this.controlPlane.onServerRequest?.((action, params, context) => action === 'session_control' && onSessionControl && context ? onSessionControl(parseSessionControlRequest(params), context) : respondToHostedInteraction(this.provider, action, params, context));
             this.controlPlane.onStopTurn?.(onStopTurn);
             this.controlPlane.onStopBackgroundRun?.(onStopBackgroundRun);
             this.controlPlane.onActivityTransportReady?.(onActivityTransportReady);
             await this.controlPlane.connect(onMessage);
         }
         catch (error) {
+            this.controlPlane.onServerRequest?.(undefined);
             this.controlPlane.onStopTurn?.(undefined);
             this.controlPlane.onStopBackgroundRun?.(undefined);
             this.controlPlane.onActivityTransportReady?.(undefined);
@@ -170,6 +202,7 @@ class DefaultHostRuntime {
     async stop() {
         let thrown;
         try {
+            this.controlPlane.onServerRequest?.(undefined);
             this.controlPlane.onStopTurn?.(undefined);
             this.controlPlane.onStopBackgroundRun?.(undefined);
             this.controlPlane.onActivityTransportReady?.(undefined);
@@ -286,11 +319,14 @@ const MAX_AUTONOMOUS_REPLY_DEDUPLICATION_KEYS = 256;
  */
 export class AgentsHost {
     config;
+    executionTelemetry;
+    normalizedStateOwners = new Map();
     runtime;
     provider;
     borgee;
     backgroundRuns;
     logger;
+    executionDeliveryJournal;
     contextInjectionEnabled;
     collaborationEnabled;
     collaborationOutcomeModelEnabled;
@@ -298,6 +334,8 @@ export class AgentsHost {
     taskThreadCollaborationContractEnabled;
     collaborationCapabilitiesDiagnosticsEnabled;
     activeTurns = new Set();
+    executionTelemetryByExecutionId = new Map();
+    executionDispatches = new Map();
     awaitingUserByChannel = new Map();
     collaborationOutcomeByChannel = new Map();
     /**
@@ -328,6 +366,9 @@ export class AgentsHost {
     constructor(config, deps) {
         this.config = config;
         this.logger = new HostLogger(deps?.runtimeOptions);
+        this.executionDeliveryJournal =
+            deps?.executionDeliveryJournal ??
+                new ExecutionDeliveryJournal(resolveExecutionDeliveryJournalPath(config.stateRootDir));
         const compatibilityGates = resolveInternalCompatibilityGates();
         const contextInjectionGateEnabled = compatibilityGates.has(CONTEXT_INJECTION_COMPATIBILITY_GATE);
         this.contextInjectionEnabled = contextInjectionGateEnabled;
@@ -392,7 +433,17 @@ export class AgentsHost {
         const bufferedMessages = [];
         let bufferingMessages = true;
         try {
+            await this.executionDeliveryJournal.load();
             this.provider.onAutonomousReply?.((reply) => this.dispatchAutonomousReply(reply));
+            this.provider.setSessionPublication?.({
+                supported: () => this.started && !this.controlPlaneClosed && this.borgee.sessionBindingsSupported === true,
+                publish: (channelId, activity) => {
+                    if (!this.started || this.controlPlaneClosed || !this.borgee.sessionBindingsSupported || !this.borgee.reportActivity)
+                        return false;
+                    this.borgee.reportActivity({ channelId, activity });
+                    return true;
+                },
+            });
             await this.runtime.start((message) => {
                 if (!this.started) {
                     return;
@@ -402,8 +453,24 @@ export class AgentsHost {
                     return;
                 }
                 this.dispatchMessage(message);
-            }, async (channelId) => this.stopTurn(channelId), async (channelId, runId) => this.backgroundRuns.stop(channelId, runId), () => this.backgroundRuns.replay());
+            }, async (channelId) => this.stopTurn(channelId), async (channelId, runId) => this.backgroundRuns.stop(channelId, runId), () => { this.provider.publishSessionBindings?.(); this.backgroundRuns.replay(); }, (request, context) => this.handleSessionControl(request, context));
             const agentId = await this.ensureSelfAgentId();
+            if (this.provider.outputMode === 'normalized' && this.borgee.reportExecutionTelemetryFrame && this.borgee.onExecutionTelemetryAck) {
+                try {
+                    this.executionTelemetry = new NormalizedExecutionTelemetry({
+                        outboxPath: join(this.config.stateRootDir, 'execution-telemetry.json'),
+                        scope: { serverUrl: this.config.borgeeBaseUrl, agentId },
+                        transport: {
+                            report: frame => this.borgee.reportExecutionTelemetryFrame(frame),
+                            onAck: handler => this.borgee.onExecutionTelemetryAck(handler),
+                            onReady: handler => this.borgee.onExecutionTransportReady?.(handler) ?? (() => { }),
+                        },
+                    });
+                }
+                catch (error) {
+                    this.logger.error('normalized accounting unavailable', { error: summarizeError(error) });
+                }
+            }
             bufferingMessages = false;
             while (bufferedMessages.length > 0) {
                 const pendingMessages = bufferedMessages.splice(0, bufferedMessages.length);
@@ -463,6 +530,9 @@ export class AgentsHost {
             runtimeStopError = error;
         }
         await Promise.allSettled([...this.activeTurns]);
+        this.executionTelemetry?.dispose();
+        this.executionTelemetry = undefined;
+        this.normalizedStateOwners.clear();
         await Promise.allSettled(pendingCompactionSnapshotWrites);
         this.compactionSnapshotWriteQueueByChannel.clear();
         if (runtimeStopError) {
@@ -471,16 +541,165 @@ export class AgentsHost {
     }
     trackActiveTurn(task) {
         this.activeTurns.add(task);
-        void task.finally(() => {
+        void task
+            .catch((error) => {
+            this.logger.error('dispatched turn failed', {
+                error: summarizeError(error),
+            });
+        })
+            .finally(() => {
             this.activeTurns.delete(task);
         });
     }
     dispatchMessage(message) {
-        const task = this.collaborationEnabled
-            ? this.handleCollaborationMessage(message)
-            : this.enqueueChannelTurn(message.channel_id, () => this.handleLegacyMessage(message));
+        // Self echoes must not occupy the channel queue before explicit control admission.
+        if (this.selfAgentId && String(message.user_id ?? message.sender_id ?? '') === this.selfAgentId && message.message_type !== 'task_assignment')
+            return;
+        const executionId = message.execution_grant?.executionId;
+        const existing = executionId
+            ? this.executionDispatches.get(executionId)
+            : undefined;
+        if (existing) {
+            this.trackActiveTurn(existing);
+            return;
+        }
+        const run = () => message.sessionTarget
+            ? this.handleSelectedSessionMessage(message)
+            : this.collaborationEnabled
+                ? this.handleCollaborationMessage(message)
+                : this.enqueueChannelTurn(message.channel_id, () => this.handleLegacyMessage(message));
+        if (this.provider.outputMode === 'normalized') {
+            this.trackActiveTurn(run());
+            return;
+        }
+        const work = executionId
+            ? this.runClaimedExecution(message, run)
+            : this.runMessageWithExecutionTelemetry(message, run).then((result) => {
+                if (result.error)
+                    throw result.error;
+            });
+        const task = executionId
+            ? work.finally(() => {
+                this.executionDispatches.delete(executionId);
+            })
+            : work;
+        if (executionId)
+            this.executionDispatches.set(executionId, task);
         this.trackActiveTurn(task);
     }
+    async runClaimedExecution(message, run) {
+        const grant = message.execution_grant;
+        const claim = await this.executionDeliveryJournal.claim(grant.executionId);
+        if (claim === 'completed')
+            return;
+        if (claim === 'recovering') {
+            if (this.borgee.reportExecutionTelemetry) {
+                let reporter = this.executionTelemetryByExecutionId.get(grant.executionId);
+                const restoredReporter = !reporter;
+                reporter ??= this.createExecutionTelemetryReporter(grant);
+                this.executionTelemetryByExecutionId.set(grant.executionId, reporter);
+                await reporter.start();
+                if (restoredReporter) {
+                    const persistedUsage = await this.executionDeliveryJournal.readUsage(grant.executionId);
+                    if (persistedUsage) {
+                        const { provider, ...usage } = persistedUsage;
+                        await reporter.usage(provider, usage);
+                    }
+                }
+                reporter.noteFailure();
+                let finishError;
+                try {
+                    await reporter.finish(false);
+                }
+                catch (error) {
+                    finishError = error;
+                }
+                if (reporter.allRequiredFramesDurable) {
+                    await this.executionDeliveryJournal.complete(grant.executionId);
+                    this.executionTelemetryByExecutionId.delete(grant.executionId);
+                }
+                if (finishError)
+                    throw finishError;
+                return;
+            }
+            throw new Error('Execution telemetry is unavailable for interrupted delivery recovery');
+        }
+        const result = await this.runMessageWithExecutionTelemetry(message, run);
+        if (result.allRequiredFramesDurable) {
+            await this.executionDeliveryJournal.complete(grant.executionId);
+        }
+        if (result.error)
+            throw result.error;
+    }
+    async runMessageWithExecutionTelemetry(message, run) {
+        const grant = message.execution_grant;
+        const reporter = grant && this.borgee.reportExecutionTelemetry
+            ? this.executionTelemetryByExecutionId.get(grant.executionId) ??
+                this.createExecutionTelemetryReporter(grant)
+            : undefined;
+        if (grant && !reporter) {
+            return {
+                allRequiredFramesDurable: false,
+                error: new Error('Execution telemetry is unavailable for admitted delivery'),
+            };
+        }
+        if (grant && reporter) {
+            this.executionTelemetryByExecutionId.set(grant.executionId, reporter);
+        }
+        let runError;
+        try {
+            await run();
+        }
+        catch (error) {
+            reporter?.noteFailure();
+            runError = error;
+        }
+        let finishError;
+        if (reporter) {
+            try {
+                await reporter.finish();
+            }
+            catch (error) {
+                finishError = error;
+                this.logger.error('execution telemetry finish failed', {
+                    error: summarizeError(error),
+                });
+            }
+            finally {
+                if (reporter.allRequiredFramesDurable &&
+                    grant &&
+                    this.executionTelemetryByExecutionId.get(grant.executionId) === reporter) {
+                    this.executionTelemetryByExecutionId.delete(grant.executionId);
+                }
+            }
+        }
+        const error = runError && finishError
+            ? new AggregateError([runError, finishError], 'Execution and telemetry finalization both failed')
+            : runError ?? finishError;
+        return {
+            allRequiredFramesDurable: reporter?.allRequiredFramesDurable ?? grant === undefined,
+            ...(error ? { error } : {}),
+        };
+    }
+    createExecutionTelemetryReporter(grant) {
+        return new ExecutionTelemetryReporter(grant, {
+            reportExecutionTelemetry: (frame) => this.borgee.reportExecutionTelemetry(frame),
+        }, Date.now, (provider, usage) => this.executionDeliveryJournal.recordUsage(grant.executionId, {
+            provider,
+            ...usage,
+        }));
+    }
+    async handleSelectedSessionMessage(msg) {
+        if (!msg.sessionTarget || !msg.sourceCurrent?.())
+            return;
+        const normalized = await this.normalizeMessage(msg);
+        if (!normalized || !msg.sourceCurrent())
+            return;
+        await this.executeTurn(msg, normalized.authorId, normalized.content, {
+            incomingParts: normalized.incomingParts,
+            selectedSession: { ...msg.sessionTarget, sourceCurrent: msg.sourceCurrent },
+        });
+    }
     dispatchAutonomousReply(reply) {
         if (!this.started
             || this.controlPlaneClosed
@@ -2309,6 +2528,254 @@ export class AgentsHost {
                 : {}),
         });
     }
+    async handleSessionControl(request, context) {
+        const response = (status, reason) => sessionControlResponse(request, status, reason);
+        if (!this.started || this.controlPlaneClosed || context.signal.aborted || Date.now() >= request.deadline_at)
+            return response('unconfirmed', 'session_control_expired');
+        if (this.provider.outputMode !== 'normalized' || !this.provider.controlSession)
+            return response('unsupported', 'session_control_not_supported');
+        if (request.operation.kind === 'send_input')
+            return this.handleNativeInput(request, context);
+        if (this.borgee.sessionBindingsSupported)
+            return this.handleRetainedControl(request, context);
+        if (request.operation.kind === 'list_pending_inputs') {
+            if (!this.provider.supportsSessionInput || !context.isConnectionCurrent)
+                return response('unsupported', 'native_queue_inventory_not_supported');
+            const connected = () => this.started && !this.controlPlaneClosed && this.selfAgentId === request.agent_id && context.isConnectionCurrent();
+            if (!connected())
+                return response('unconfirmed', 'session_control_expired');
+            try {
+                return (await this.provider.controlSession(request, { signal: context.signal, isConnectionCurrent: connected })).response;
+            }
+            catch {
+                return response('unconfirmed', 'native_queue_inventory_unavailable');
+            }
+        }
+        if (request.operation.kind === 'list_commands') {
+            try {
+                return (await this.provider.controlSession(request, { signal: context.signal })).response;
+            }
+            catch {
+                return response('unconfirmed', 'command_directory_unavailable');
+            }
+        }
+        const channelId = request.channel_id;
+        const state = this.ensureCollaborationChannelState(channelId);
+        if (state.processor || state.running || state.activeTurn || state.queue.length || this.channelTurnQueues.has(channelId))
+            return response('rejected', 'session_busy');
+        let finish;
+        const ownership = new Promise(resolve => { finish = resolve; });
+        state.processor = ownership;
+        state.running = true;
+        this.channelTurnQueues.set(channelId, ownership);
+        let execution;
+        let active;
+        let retained = false;
+        const release = () => {
+            execution?.close();
+            if (state.activeTurn === active)
+                state.activeTurn = undefined;
+            state.running = false;
+            if (state.processor === ownership)
+                state.processor = undefined;
+            if (this.channelTurnQueues.get(channelId) === ownership)
+                this.channelTurnQueues.delete(channelId);
+            finish();
+        };
+        this.trackActiveTurn(ownership);
+        try {
+            if (request.operation.kind === 'execute_command') {
+                if (!request.admission)
+                    return response('rejected', 'command_admission_required');
+                const admission = request.admission;
+                active = { generation: ++state.generation, turnExecutionId: admission.input_message_id, superseded: false, collaborationMessagesSent: 0, targetCooldowns: new Map() };
+                state.activeTurn = active;
+                const inputText = await readDurableInputText(this.borgee, { channelId, inputMessageId: admission.input_message_id, createdAt: admission.input_created_at });
+                if (context.signal.aborted || Date.now() >= request.deadline_at)
+                    return response('unconfirmed', 'session_control_expired');
+                execution = this.beginNormalizedExecution({ channelId, taskId: admission.input_message_id, inputMessageId: admission.input_message_id, inputText, activeTurn: active });
+            }
+            const result = await this.provider.controlSession(request, {
+                signal: context.signal, execution: execution?.options,
+                onCompletion: pending => {
+                    retained = true;
+                    const owner = active;
+                    const completion = pending.then(async (reply) => {
+                        if (!reply || !hasVisibleText(reply.text) || !(await this.canAcceptCompletedTurnOutput(channelId, owner)))
+                            return;
+                        await this.postTurnReply({ channelId, body: reply.text, inputMessageId: request.admission?.input_message_id, replyToId: request.admission?.input_message_id, taskId: request.admission.input_message_id, activeTurn: owner });
+                    }).catch(error => { this.logger.error('native command completion unavailable', { channelId, error: summarizeError(error) }); }).finally(release);
+                    this.trackActiveTurn(completion);
+                },
+            });
+            return result.response;
+        }
+        catch (error) {
+            this.logger.error('native session control unavailable', { channelId, error: summarizeError(error) });
+            return response('unconfirmed', 'native_confirmation_unavailable');
+        }
+        finally {
+            if (!retained)
+                release();
+        }
+    }
+    async handleRetainedControl(request, context) {
+        const response = (status, reason) => sessionControlResponse(request, status, reason);
+        const connected = () => this.started && !this.controlPlaneClosed && this.selfAgentId === request.agent_id && !!context.isConnectionCurrent?.();
+        let execution;
+        let canPublish = () => false;
+        let retained = false;
+        try {
+            const admission = request.admission;
+            let inputText = null;
+            if (request.operation.kind === 'execute_command') {
+                if (!admission)
+                    return response('rejected', 'command_admission_required');
+                inputText = await readDurableInputText(this.borgee, { channelId: request.channel_id, inputMessageId: admission.input_message_id, createdAt: admission.input_created_at });
+            }
+            if (!connected() || context.signal.aborted || Date.now() >= request.deadline_at)
+                return response('unconfirmed', 'session_control_expired');
+            const result = await this.provider.controlSession(request, {
+                signal: context.signal, connectionSignal: context.connectionSignal, isConnectionCurrent: connected,
+                activateExecution: nativeCurrent => {
+                    if (!admission)
+                        throw new Error('Native command has no admitted input.');
+                    canPublish = () => connected() && nativeCurrent();
+                    execution = this.beginNormalizedExecution({ channelId: request.channel_id, taskId: admission.input_message_id, inputMessageId: admission.input_message_id, inputText, publicationGuard: canPublish });
+                    return execution.options;
+                },
+                onCompletion: pending => {
+                    retained = true;
+                    const completion = pending.then(async (reply) => {
+                        if (!reply || !hasVisibleText(reply.text) || !canPublish())
+                            return;
+                        await this.postTurnReply({ channelId: request.channel_id, body: reply.text, inputMessageId: admission.input_message_id, replyToId: admission.input_message_id, taskId: admission.input_message_id });
+                    }).catch(error => this.logger.error('native command completion unavailable', { channelId: request.channel_id, error: summarizeError(error) })).finally(() => execution?.close());
+                    this.trackActiveTurn(completion);
+                },
+            });
+            return result.response;
+        }
+        catch (error) {
+            this.logger.error('native session control unavailable', { channelId: request.channel_id, error: summarizeError(error) });
+            return response('unconfirmed', 'native_confirmation_unavailable');
+        }
+        finally {
+            if (!retained)
+                execution?.close();
+        }
+    }
+    async handleNativeInput(request, context) {
+        const operation = request.operation;
+        const admission = request.admission;
+        const response = (status, reason) => sessionControlResponse(request, status, reason);
+        if (operation.kind !== 'send_input' || !admission || !context.isConnectionCurrent || !this.provider.supportsSessionInput)
+            return response('unsupported', 'native_input_not_supported');
+        const connected = () => this.started && !this.controlPlaneClosed && this.selfAgentId === request.agent_id && context.isConnectionCurrent();
+        let execution;
+        let canPublish = () => false;
+        let retained = false;
+        try {
+            const inputText = await readDurableInputText(this.borgee, { channelId: request.channel_id, inputMessageId: admission.input_message_id, createdAt: admission.input_created_at });
+            if (inputText !== operation.text || !connected() || context.signal.aborted)
+                return response('unconfirmed', 'native_input_admission_unavailable');
+            const result = await this.provider.controlSession(request, {
+                signal: context.signal, connectionSignal: context.connectionSignal, isConnectionCurrent: connected,
+                activateExecution: async (nativeCurrent) => {
+                    canPublish = () => connected() && nativeCurrent();
+                    if (!canPublish())
+                        throw new Error('Native queued input connection ownership ended.');
+                    execution = this.beginNormalizedExecution({ channelId: request.channel_id, taskId: admission.input_message_id, inputMessageId: admission.input_message_id, inputText, publicationGuard: canPublish });
+                    return execution.options;
+                },
+                onCompletion: pending => {
+                    retained = true;
+                    const completion = pending.then(async (reply) => {
+                        if (!reply || !hasVisibleText(reply.text) || !canPublish())
+                            return;
+                        await this.postTurnReply({ channelId: request.channel_id, body: reply.text, inputMessageId: admission.input_message_id, replyToId: admission.input_message_id, taskId: admission.input_message_id });
+                    }).catch(error => this.logger.error('native input completion unavailable', { channelId: request.channel_id, error: summarizeError(error) })).finally(() => execution?.close());
+                    this.trackActiveTurn(completion);
+                },
+            });
+            return result.response;
+        }
+        catch (error) {
+            this.logger.error('native input confirmation unavailable', { channelId: request.channel_id, error: summarizeError(error) });
+            return response('unconfirmed', 'native_confirmation_unavailable');
+        }
+        finally {
+            if (!retained)
+                execution?.close();
+        }
+    }
+    async postTurnReply(input, source) {
+        const message = { channelId: input.channelId, body: input.body, replyToId: input.replyToId ?? input.activeTurn?.delivery?.replyToId };
+        const posted = source ? await this.borgee.postMessage(message, source) : await this.borgee.postMessage(message);
+        recordProtocolTrace({ stage: 'host.delivery', kind: 'correlation', correlation: { channelId: input.channelId, agentId: this.selfAgentId ?? undefined, inputMessageId: input.inputMessageId, taskId: input.taskId, turnExecutionId: input.activeTurn?.turnExecutionId ?? undefined, outputMessageId: posted.messageId }, payload: { delivery: 'posted' } });
+        return posted;
+    }
+    beginNormalizedExecution(input) {
+        const { channelId, taskId, activeTurn } = input;
+        let execution;
+        try {
+            execution = this.executionTelemetry?.bind({ bindingId: taskId, channelId, inputMessageId: input.inputMessageId, grant: input.grant });
+        }
+        catch (error) {
+            this.logger.error('normalized accounting binding unavailable', { error: summarizeError(error) });
+        }
+        let publisher;
+        let statePublisher;
+        let stateClosed = false;
+        const owner = Symbol('normalized-state');
+        const stateOwnerKey = input.publicationGuard ? JSON.stringify([channelId, taskId]) : channelId;
+        this.normalizedStateOwners.set(stateOwnerKey, owner);
+        const canPublishState = () => {
+            const current = this.collaborationChannels.get(channelId)?.activeTurn;
+            return !stateClosed && this.started && !this.controlPlaneClosed && this.normalizedStateOwners.get(stateOwnerKey) === owner && (input.publicationGuard ? input.publicationGuard() : !activeTurn?.superseded && (!current || current.generation === activeTurn?.generation));
+        };
+        return {
+            options: {
+                normalizedTaskId: taskId, normalizedInputMessageId: input.inputMessageId, normalizedInputText: input.inputText,
+                normalizedStateSink: input.silent ? undefined : {
+                    snapshot: (snapshot, bindingId, timelineEpoch) => {
+                        if (!canPublishState())
+                            return false;
+                        statePublisher ??= new NormalizedActivityPublisher({ client: { reportActivity: value => { this.borgee.reportActivity?.(value); } }, channelId, taskId, agentId: snapshot.payload.id });
+                        statePublisher.publish(snapshot, Date.now(), snapshot.payload.providerId, snapshot.payload.capabilities, bindingId, timelineEpoch);
+                        return true;
+                    },
+                    sessionActivity: activity => { if (!canPublishState() || !this.borgee.reportActivity)
+                        return false; this.borgee.reportActivity({ channelId, activity }); return true; },
+                    observe: (observation, agentId, capabilities, bindingId, timelineEpoch) => {
+                        if (observation.event.type !== 'runtime_updated' || !canPublishState() || this.borgee.sessionBindingsSupported)
+                            return;
+                        statePublisher ??= new NormalizedActivityPublisher({ client: { reportActivity: value => { this.borgee.reportActivity?.(value); } }, channelId, taskId, agentId });
+                        statePublisher.observe(observation, capabilities, bindingId, timelineEpoch);
+                    },
+                    close: () => { stateClosed = true; statePublisher?.close(); if (this.normalizedStateOwners.get(stateOwnerKey) === owner)
+                        this.normalizedStateOwners.delete(stateOwnerKey); },
+                },
+                onNormalizedObservation: (event, agentId, observation, capabilities, bindingId, timelineEpoch, sessionPublished) => {
+                    if (input.publicationGuard && !input.publicationGuard())
+                        return;
+                    try {
+                        execution?.observe(event, observation?.occurredAt);
+                    }
+                    catch (error) {
+                        this.logger.error('normalized accounting rejected', { error: summarizeError(error) });
+                    }
+                    const acceptsOutput = !input.silent && this.canAcceptTurnOutput(channelId, activeTurn?.generation);
+                    recordProtocolTrace({ stage: 'host.dispatch', kind: 'correlation', correlation: { channelId, agentId, inputMessageId: input.inputMessageId, taskId, turnExecutionId: activeTurn?.turnExecutionId ?? undefined }, payload: { eventType: event.type }, outcome: acceptsOutput ? 'forwarded' : 'suppressed' });
+                    if (sessionPublished || !acceptsOutput || event.type === 'runtime_updated' && this.borgee.sessionBindingsSupported)
+                        return;
+                    publisher ??= new NormalizedActivityPublisher({ client: { reportActivity: value => { this.borgee.reportActivity?.(value); } }, channelId, taskId, agentId });
+                    publisher.observe(observation ?? event, capabilities, bindingId, timelineEpoch);
+                },
+            },
+            close: () => { publisher?.close(); execution?.close(); },
+        };
+    }
     async executeTurn(msg, authorId, content, options) {
         const channelId = msg.channel_id;
         const activeTurn = options?.activeTurn;
@@ -2316,23 +2783,14 @@ export class AgentsHost {
         const taskThreadContext = options?.taskThreadContext ?? { state: 'inactive' };
         const silentTurn = options?.silent === true;
         const deferDelivery = options?.deferDelivery === true;
+        const selectedSourceCurrent = options?.selectedSession?.sourceCurrent;
+        const selectedWriteSource = selectedSourceCurrent ? { isConnectionCurrent: selectedSourceCurrent } : undefined;
         const collaborationTurnMode = activeTurn?.protocol
             ? 'protocol-managed'
             : options?.kickoff
                 ? 'silent-kickoff'
                 : undefined;
         const turnExecutionId = activeTurn?.turnExecutionId ?? null;
-        const stopTyping = silentTurn ? () => { } : this.borgee.startTyping(channelId);
-        const collaborationGrounding = await this.buildCollaborationGrounding(authorId, options?.incomingAuthorKind, activeTurn, options?.kickoff);
-        const publishesCollaborationDraft = !silentTurn &&
-            !deferDelivery &&
-            this.collaborationEnabled &&
-            turnExecutionId != null &&
-            activeTurn?.protocol === undefined;
-        const supportsProviderProgress = this.provider.capabilities?.progressUpdates?.support === 'supported';
-        const supportsBackgroundRunLifecycle = this.provider.capabilities?.backgroundRuns?.lifecycle === 'supported';
-        const reportsProviderActivity = !silentTurn && supportsProviderProgress;
-        const observeProviderProgress = supportsProviderProgress || supportsBackgroundRunLifecycle;
         const turnContext = {
             eventType: msg.type,
             channelId,
@@ -2345,26 +2803,64 @@ export class AgentsHost {
         };
         const turnStartedAt = Date.now();
         this.logger.debug('starting turn', turnContext);
+        const executionTelemetry = this.provider.outputMode !== 'normalized' && msg.execution_grant
+            ? this.executionTelemetryByExecutionId.get(msg.execution_grant.executionId)
+            : undefined;
+        let executionSucceeded = false;
+        let executionTelemetryStartFailed = false;
         let reply;
         let publicReplyText;
         let visibleReplyBody;
-        const taskThreadCollaborationContract = this.resolveTaskThreadCollaborationContractForTurn(msg, taskThreadContext);
-        const collaborationOutcome = this.collaborationOutcomeModelEnabled
-            ? this.collaborationOutcomeByChannel.get(channelId)
-            : undefined;
-        const missedCollaborationDiagnostic = this.resolveMissedCollaborationDiagnosticForTurn(channelId);
-        const collaborationCapabilities = this.resolveCollaborationCapabilityDeclarationForTurn(taskThreadContext);
-        const incomingParts = options?.incomingParts
-            ?? buildHostedTurnContentParts({
-                text: String(msg.content ?? msg.body ?? content),
-                attachments: msg.attachments,
-            });
-        const activityReporter = silentTurn
-            ? undefined
-            : this.beginTurnActivity(channelId, activeTurn?.generation);
-        await this.ensureCompactionSnapshotLoaded(channelId);
-        const compactionSnapshot = this.compactionSnapshotByChannel.get(channelId);
+        let activityReporter;
+        let typingLease;
+        const normalizedTaskId = turnExecutionId ?? randomUUID();
+        recordProtocolTrace({ stage: 'host.dispatch', kind: 'correlation',
+            correlation: { channelId, agentId: this.selfAgentId ?? undefined, inputMessageId: msg.message_id, taskId: normalizedTaskId, turnExecutionId: turnExecutionId ?? undefined },
+            payload: { silentTurn } });
+        let normalizedExecution;
         try {
+            if (!silentTurn) {
+                typingLease = startTypingLease(() => this.borgee.reportTyping(channelId));
+            }
+            const collaborationGrounding = await this.buildCollaborationGrounding(authorId, options?.incomingAuthorKind, activeTurn, options?.kickoff);
+            const publishesCollaborationDraft = !silentTurn &&
+                !deferDelivery &&
+                this.collaborationEnabled &&
+                turnExecutionId != null &&
+                activeTurn?.protocol === undefined;
+            const supportsProviderProgress = this.provider.capabilities?.progressUpdates?.support === 'supported';
+            const supportsBackgroundRunLifecycle = this.provider.capabilities?.backgroundRuns?.lifecycle === 'supported';
+            const reportsProviderActivity = !silentTurn && supportsProviderProgress;
+            const observeProviderProgress = supportsProviderProgress || supportsBackgroundRunLifecycle;
+            const taskThreadCollaborationContract = this.resolveTaskThreadCollaborationContractForTurn(msg, taskThreadContext);
+            const collaborationOutcome = this.collaborationOutcomeModelEnabled
+                ? this.collaborationOutcomeByChannel.get(channelId)
+                : undefined;
+            const missedCollaborationDiagnostic = this.resolveMissedCollaborationDiagnosticForTurn(channelId);
+            const collaborationCapabilities = this.resolveCollaborationCapabilityDeclarationForTurn(taskThreadContext);
+            const incomingParts = options?.incomingParts
+                ?? buildHostedTurnContentParts({
+                    text: String(msg.content ?? msg.body ?? content),
+                    attachments: msg.attachments,
+                });
+            activityReporter = silentTurn
+                ? undefined
+                : this.beginTurnActivity(channelId, activeTurn?.generation);
+            normalizedExecution = this.provider.outputMode === 'normalized' ? this.beginNormalizedExecution({ channelId, taskId: normalizedTaskId, inputMessageId: msg.message_id, inputText: await readNormalizedInputText(this.borgee, msg), grant: msg.execution_grant, activeTurn, silent: silentTurn, ...(selectedSourceCurrent ? { publicationGuard: selectedSourceCurrent } : {}) }) : undefined;
+            await this.ensureCompactionSnapshotLoaded(channelId);
+            const compactionSnapshot = this.compactionSnapshotByChannel.get(channelId);
+            if (executionTelemetry) {
+                try {
+                    await executionTelemetry.start();
+                }
+                catch (error) {
+                    executionTelemetryStartFailed = true;
+                    this.logger.error('execution telemetry start failed', {
+                        error: summarizeError(error),
+                    });
+                    throw error;
+                }
+            }
             reply = await this.provider.generateReply({
                 agentName: this.config.agent.agentName,
                 provider: this.config.agent.provider,
@@ -2374,6 +2870,7 @@ export class AgentsHost {
                 incomingParts,
                 incomingEventKind: msg.type,
                 incomingMessageType: msg.message_type,
+                ...(options?.selectedSession ? { selectedSession: options.selectedSession } : {}),
                 collaboration: turnExecutionId || options?.kickoff
                     ? {
                         enabled: this.collaborationEnabled,
@@ -2396,7 +2893,8 @@ export class AgentsHost {
                     ? {
                         taskAssignmentContextOverride: {
                             active: true,
-                            ...(taskThreadContext.state === 'active' && taskThreadContext.currentTaskId
+                            ...((taskThreadContext.state === 'active'
+                                || taskThreadContext.state === 'recovered') && taskThreadContext.currentTaskId
                                 ? { currentTaskId: taskThreadContext.currentTaskId }
                                 : {}),
                         },
@@ -2405,42 +2903,62 @@ export class AgentsHost {
                             : { taskAssignmentContextOverridePersistence: 'ephemeral' }),
                     }
                     : {}),
-            }, observeProviderProgress
+            }, observeProviderProgress || executionTelemetry || this.provider.outputMode === 'normalized'
                 ? {
-                    onProgress: (update) => {
-                        if (supportsBackgroundRunLifecycle) {
-                            this.backgroundRuns.observe(channelId, update);
-                            if (update.type === 'activity' && update.activity.background === true) {
-                                this.borgee.reportActivity?.({
-                                    channelId,
-                                    activity: { shape: 'activity', ...update.activity },
-                                });
-                                return;
-                            }
-                        }
-                        if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
-                            return;
-                        }
-                        if (supportsProviderProgress && update.type === 'compaction') {
-                            this.noteCompactionProgress(channelId, update.compaction, {
-                                turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
-                            });
-                            return;
+                    ...normalizedExecution?.options,
+                    ...(executionTelemetry
+                        ? {
+                            onUsage: (usage) => {
+                                void executionTelemetry.usage(this.config.agent.provider, usage);
+                            },
+                            onExecutionContinuation: (completion) => {
+                                executionTelemetry.hold(completion);
+                            },
                         }
-                        const reportedActivity = toReportedActivity(update);
-                        if (reportsProviderActivity && reportedActivity) {
-                            activityReporter?.progress(reportedActivity);
-                        }
-                        if (!supportsProviderProgress
-                            || update.type !== 'text'
-                            || update.stream !== 'answer') {
-                            return;
-                        }
-                        if (!publishesCollaborationDraft) {
-                            return;
+                        : {}),
+                    ...(observeProviderProgress
+                        ? {
+                            onProgress: (update) => {
+                                if (supportsBackgroundRunLifecycle) {
+                                    this.backgroundRuns.observe(channelId, update);
+                                    if (update.type === 'activity' && update.activity.background === true) {
+                                        this.borgee.reportActivity?.({
+                                            channelId,
+                                            activity: { shape: 'activity', ...update.activity },
+                                        });
+                                        return;
+                                    }
+                                }
+                                if ((selectedSourceCurrent && !selectedSourceCurrent()) || !this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
+                                    return;
+                                }
+                                if (update.type === 'text'
+                                    && update.stream === 'answer'
+                                    && hasVisibleText(update.text)) {
+                                    typingLease?.renew();
+                                }
+                                if (supportsProviderProgress && update.type === 'compaction') {
+                                    this.noteCompactionProgress(channelId, update.compaction, {
+                                        turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
+                                    });
+                                    return;
+                                }
+                                const reportedActivity = toReportedActivity(update);
+                                if (this.provider.outputMode !== 'normalized' && reportsProviderActivity && reportedActivity) {
+                                    activityReporter?.progress(reportedActivity);
+                                }
+                                if (!supportsProviderProgress ||
+                                    update.type !== 'text' ||
+                                    update.stream !== 'answer') {
+                                    return;
+                                }
+                                if (!publishesCollaborationDraft) {
+                                    return;
+                                }
+                                this.publishCollaborationDraft(channelId, activeTurn, update.text);
+                            },
                         }
-                        this.publishCollaborationDraft(channelId, activeTurn, update.text);
-                    },
+                        : {}),
                 }
                 : undefined);
             publicReplyText = resolvePublicReplyText(reply);
@@ -2458,7 +2976,7 @@ export class AgentsHost {
                 observedAt: Date.now(),
                 turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
             });
-            if (!(await this.canAcceptCompletedTurnOutput(channelId, activeTurn))) {
+            if ((selectedSourceCurrent && !selectedSourceCurrent()) || !(await this.canAcceptCompletedTurnOutput(channelId, activeTurn))) {
                 if (activeTurn?.turnExecutionId) {
                     this.clearCollaborationDraft(channelId, {
                         generation: activeTurn.generation,
@@ -2468,6 +2986,7 @@ export class AgentsHost {
                 return { reply, stale: true, completed: false };
             }
             if (silentTurn) {
+                executionSucceeded = true;
                 this.logger.debug('completed turn', {
                     ...turnContext,
                     durationMs: Date.now() - turnStartedAt,
@@ -2488,6 +3007,7 @@ export class AgentsHost {
                 };
             }
             if (deferDelivery) {
+                executionSucceeded = true;
                 this.logger.debug('completed turn', {
                     ...turnContext,
                     durationMs: Date.now() - turnStartedAt,
@@ -2508,11 +3028,7 @@ export class AgentsHost {
                 };
             }
             if (this.started && !this.controlPlaneClosed && hasVisibleText(publicReplyText)) {
-                const posted = await this.borgee.postMessage({
-                    channelId,
-                    body: visibleReplyBody,
-                    replyToId: activeTurn?.delivery?.replyToId,
-                });
+                const posted = await this.postTurnReply({ channelId, body: visibleReplyBody, inputMessageId: msg.message_id, taskId: normalizedTaskId, activeTurn }, selectedWriteSource);
                 this.logger.debug('completed turn', {
                     ...turnContext,
                     durationMs: Date.now() - turnStartedAt,
@@ -2524,6 +3040,7 @@ export class AgentsHost {
                 if (publishesCollaborationDraft) {
                     this.finalizeCollaborationDraft(channelId, activeTurn, posted.messageId, visibleReplyBody);
                 }
+                executionSucceeded = true;
                 return {
                     reply,
                     deliveredMessageId: posted.messageId,
@@ -2547,6 +3064,7 @@ export class AgentsHost {
                     turnExecutionId: activeTurn.turnExecutionId,
                 });
             }
+            executionSucceeded = true;
             return {
                 reply,
                 deliveredMessageId: null,
@@ -2565,6 +3083,13 @@ export class AgentsHost {
                     turnExecutionId: activeTurn.turnExecutionId,
                 });
             }
+            if (executionTelemetryStartFailed) {
+                throw error;
+            }
+            if (error instanceof ProviderInputRejectedError && !silentTurn && !deferDelivery && (!selectedSourceCurrent || selectedSourceCurrent()) && this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
+                const posted = await this.postTurnReply({ channelId, body: error.publicReplyText, replyToId: activeTurn?.delivery?.replyToId, inputMessageId: msg.message_id, taskId: normalizedTaskId, activeTurn }, selectedWriteSource);
+                return { reply: { text: error.publicReplyText }, publicReplyText: error.publicReplyText, visibleReplyBody: error.publicReplyText, deliveredMessageId: posted.messageId, deliveryState: 'posted', stale: false, completed: false };
+            }
             if (error instanceof ProviderTurnCancelledError) {
                 const cancelledReplyText = error.publicReplyText?.trim();
                 if (!silentTurn &&
@@ -2572,16 +3097,13 @@ export class AgentsHost {
                     typeof cancelledReplyText === 'string' &&
                     cancelledReplyText.length > 0 &&
                     this.started &&
-                    !this.controlPlaneClosed) {
+                    !this.controlPlaneClosed &&
+                    (!selectedSourceCurrent || selectedSourceCurrent())) {
                     reply = { text: cancelledReplyText };
                     publicReplyText = cancelledReplyText;
                     visibleReplyBody = this.resolveVisibleTurnBody(activeTurn, reply, publicReplyText);
                     try {
-                        const posted = await this.borgee.postMessage({
-                            channelId,
-                            body: visibleReplyBody,
-                            replyToId: activeTurn?.delivery?.replyToId,
-                        });
+                        const posted = await this.postTurnReply({ channelId, body: visibleReplyBody, replyToId: activeTurn?.delivery?.replyToId, inputMessageId: msg.message_id, taskId: normalizedTaskId, activeTurn }, selectedWriteSource);
                         this.logger.debug('posted cancelled turn feedback', {
                             ...turnContext,
                             durationMs: Date.now() - turnStartedAt,
@@ -2642,8 +3164,12 @@ export class AgentsHost {
             };
         }
         finally {
-            stopTyping();
+            if (executionTelemetry) {
+                executionTelemetry.noteAttempt(executionSucceeded);
+            }
+            typingLease?.stop();
             activityReporter?.end();
+            normalizedExecution?.close();
         }
     }
     /**