@borgee/agents-host 0.2.101 → 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';
@@ -7,6 +8,8 @@ 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';
@@ -15,7 +18,7 @@ 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 { 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';
@@ -118,6 +121,18 @@ class DefaultHostRuntime {
                             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,
@@ -141,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,
@@ -158,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);
@@ -178,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);
@@ -294,6 +319,8 @@ const MAX_AUTONOMOUS_REPLY_DEDUPLICATION_KEYS = 256;
  */
 export class AgentsHost {
     config;
+    executionTelemetry;
+    normalizedStateOwners = new Map();
     runtime;
     provider;
     borgee;
@@ -408,6 +435,15 @@ export class AgentsHost {
         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;
@@ -417,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);
@@ -478,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) {
@@ -497,6 +552,9 @@ export class AgentsHost {
         });
     }
     dispatchMessage(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)
@@ -505,9 +563,15 @@ export class AgentsHost {
             this.trackActiveTurn(existing);
             return;
         }
-        const run = () => this.collaborationEnabled
-            ? this.handleCollaborationMessage(message)
-            : this.enqueueChannelTurn(message.channel_id, () => this.handleLegacyMessage(message));
+        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) => {
@@ -625,6 +689,17 @@ export class AgentsHost {
             ...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
@@ -2453,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;
@@ -2460,6 +2783,8 @@ 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
@@ -2478,7 +2803,7 @@ export class AgentsHost {
         };
         const turnStartedAt = Date.now();
         this.logger.debug('starting turn', turnContext);
-        const executionTelemetry = msg.execution_grant
+        const executionTelemetry = this.provider.outputMode !== 'normalized' && msg.execution_grant
             ? this.executionTelemetryByExecutionId.get(msg.execution_grant.executionId)
             : undefined;
         let executionSucceeded = false;
@@ -2488,6 +2813,11 @@ export class AgentsHost {
         let visibleReplyBody;
         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));
@@ -2516,6 +2846,7 @@ export class AgentsHost {
             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) {
@@ -2539,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,
@@ -2561,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 }
                                 : {}),
                         },
@@ -2570,8 +2903,9 @@ export class AgentsHost {
                             : { taskAssignmentContextOverridePersistence: 'ephemeral' }),
                     }
                     : {}),
-            }, observeProviderProgress || executionTelemetry
+            }, observeProviderProgress || executionTelemetry || this.provider.outputMode === 'normalized'
                 ? {
+                    ...normalizedExecution?.options,
                     ...(executionTelemetry
                         ? {
                             onUsage: (usage) => {
@@ -2595,7 +2929,7 @@ export class AgentsHost {
                                         return;
                                     }
                                 }
-                                if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
+                                if ((selectedSourceCurrent && !selectedSourceCurrent()) || !this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
                                     return;
                                 }
                                 if (update.type === 'text'
@@ -2610,7 +2944,7 @@ export class AgentsHost {
                                     return;
                                 }
                                 const reportedActivity = toReportedActivity(update);
-                                if (reportsProviderActivity && reportedActivity) {
+                                if (this.provider.outputMode !== 'normalized' && reportsProviderActivity && reportedActivity) {
                                     activityReporter?.progress(reportedActivity);
                                 }
                                 if (!supportsProviderProgress ||
@@ -2642,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,
@@ -2694,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,
@@ -2756,6 +3086,10 @@ export class AgentsHost {
             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 &&
@@ -2763,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,
@@ -2838,6 +3169,7 @@ export class AgentsHost {
             }
             typingLease?.stop();
             activityReporter?.end();
+            normalizedExecution?.close();
         }
     }
     /**

package/dist/catalog-worker.js

@@ -0,0 +1,21 @@
+import { createRequire as __nodeCreateRequire } from 'node:module';
+const require = __nodeCreateRequire(import.meta.url);
+
+// ../agent-provider-claude/src/catalog-worker.ts
+import { getSessionInfo, getSessionMessages, listSessions, listSubagents, getSubagentMessages } from "@borgee/claude-native-sdk";
+var [operation, sessionId, childId] = process.argv.slice(2);
+try {
+  const result = operation === "list" ? await listSessions() : operation === "info" && sessionId ? await getSessionInfo(sessionId) : operation === "messages" && sessionId ? await getSessionMessages(sessionId) : operation === "child-messages" && sessionId && childId ? await getSubagentMessages(sessionId, childId) : operation === "children" && sessionId ? await readChildren(sessionId) : (() => {
+    throw new Error("Unknown catalog operation.");
+  })();
+  process.stdout.write(JSON.stringify(result ?? null));
+} catch {
+  process.stderr.write("Claude native catalog could not be read.\n");
+  process.exitCode = 1;
+}
+async function readChildren(parentId) {
+  const children = [];
+  for (const id of await listSubagents(parentId)) children.push({ id, messages: await getSubagentMessages(parentId, id) });
+  return children;
+}
+//# sourceMappingURL=catalog-worker.js.map

package/dist/catalog-worker.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../agent-provider-claude/src/catalog-worker.ts"],
+  "sourcesContent": ["import { getSessionInfo, getSessionMessages, listSessions, listSubagents, getSubagentMessages } from '@anthropic-ai/claude-agent-sdk';\n\nconst [operation, sessionId, childId] = process.argv.slice(2);\ntry {\n  const result = operation === 'list' ? await listSessions() : operation === 'info' && sessionId ? await getSessionInfo(sessionId)\n    : operation === 'messages' && sessionId ? await getSessionMessages(sessionId)\n    : operation === 'child-messages' && sessionId && childId ? await getSubagentMessages(sessionId, childId)\n    : operation === 'children' && sessionId ? await readChildren(sessionId)\n    : (() => { throw new Error('Unknown catalog operation.'); })();\n  process.stdout.write(JSON.stringify(result ?? null));\n} catch {\n  process.stderr.write('Claude native catalog could not be read.\\n');\n  process.exitCode = 1;\n}\n\nasync function readChildren(parentId: string) {\n  const children = [];\n  for (const id of await listSubagents(parentId)) children.push({ id, messages: await getSubagentMessages(parentId, id) });\n  return children;\n}\n"],
+  "mappings": ";;;;AAAA,SAAS,gBAAgB,oBAAoB,cAAc,eAAe,2BAA2B;AAErG,IAAM,CAAC,WAAW,WAAW,OAAO,IAAI,QAAQ,KAAK,MAAM,CAAC;AAC5D,IAAI;AACF,QAAM,SAAS,cAAc,SAAS,MAAM,aAAa,IAAI,cAAc,UAAU,YAAY,MAAM,eAAe,SAAS,IAC3H,cAAc,cAAc,YAAY,MAAM,mBAAmB,SAAS,IAC1E,cAAc,oBAAoB,aAAa,UAAU,MAAM,oBAAoB,WAAW,OAAO,IACrG,cAAc,cAAc,YAAY,MAAM,aAAa,SAAS,KACnE,MAAM;AAAE,UAAM,IAAI,MAAM,4BAA4B;AAAA,EAAG,GAAG;AAC/D,UAAQ,OAAO,MAAM,KAAK,UAAU,UAAU,IAAI,CAAC;AACrD,QAAQ;AACN,UAAQ,OAAO,MAAM,4CAA4C;AACjE,UAAQ,WAAW;AACrB;AAEA,eAAe,aAAa,UAAkB;AAC5C,QAAM,WAAW,CAAC;AAClB,aAAW,MAAM,MAAM,cAAc,QAAQ,EAAG,UAAS,KAAK,EAAE,IAAI,UAAU,MAAM,oBAAoB,UAAU,EAAE,EAAE,CAAC;AACvH,SAAO;AACT;",
+  "names": []
+}

package/dist/chat/chat-control-plane.d.ts

@@ -1,12 +1,16 @@
-import type { AgentActivity, ExecutionTelemetryFrame, ReportTaskFinishedInput, ReportTurnActivityInput, StopBackgroundRunHandler, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
+import type { AgentActivity, ExecutionTelemetryFrame, ServerRequestHandler, ReportTaskFinishedInput, ReportTurnActivityInput, StopBackgroundRunHandler, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelFileEntry, ChannelFileContent, PublishChannelFileInput, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 export interface ChatControlPlane {
+    reportExecutionTelemetryFrame?(frame: ExecutionTelemetryFrame): void;
+    onExecutionTelemetryAck?(handler: (ack: import('../plugin-sdk.js').ExecutionTelemetryAck) => void): () => void;
+    onExecutionTransportReady?(handler: () => void): () => void;
+    onServerRequest?(handler: ServerRequestHandler | undefined): void;
     onStopTurn?(handler: StopTurnHandler | undefined): void;
     onStopBackgroundRun?(handler: StopBackgroundRunHandler | undefined): void;
     onActivityTransportReady?(handler: (() => void) | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
-    postMessage(input: PostMessageInput): Promise<PostedMessage>;
+    postMessage(input: PostMessageInput, source?: Pick<import('../plugin-sdk.js').ServerRequestContext, 'isConnectionCurrent'>): Promise<PostedMessage>;
     editMessage(messageId: string, content: string): Promise<void>;
     deleteMessage(messageId: string): Promise<void>;
     reportTyping(channelId: string): void;
@@ -14,6 +18,7 @@ export interface ChatControlPlane {
     reportTurnActivity(input: ReportTurnActivityInput): TurnActivityReporter;
     reportExecutionTelemetry?(frame: ExecutionTelemetryFrame): Promise<void>;
     reportTaskFinished?(input: ReportTaskFinishedInput): void;
+    readonly sessionBindingsSupported?: boolean;
     reportActivity?(input: {
         channelId: string;
         activity: AgentActivity;