@borgee/agents-host 0.2.44 → 0.2.62

package/dist/agents-host.js

@@ -3,20 +3,20 @@ import { chmod, link, mkdir, readFile, readdir, rename, unlink, writeFile } from
 import { dirname, join, resolve } from 'node:path';
 import { SdkChatControlPlane } from './chat/sdk-chat-control-plane.js';
 import { HostLogger, summarizeError } from './debug.js';
-import { createDurableCursorStore } from './durable-cursor-store.js';
+import { toReportedActivity } from './progress-to-activity.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';
 import { projectTaskThreadCollaborationContract } from './context/task-thread-collaboration.js';
 import { createLocalhostGatewayController, LOCALHOST_GATEWAY_COLLABORATION_TARGET_COOLDOWN_MS, } from './gateway/localhost-gateway.js';
-import { extractTaskIdFromTaskAssignmentContent, resolveChannelContextPayloadPath, } from './context/injection.js';
+import { extractTaskIdFromTaskAssignmentContent, resolveTaskAssignmentStatePath, } from './context/injection.js';
 import { AuthorizationAuditSink, } from './policy/authorization-audit.js';
 import { createProvider } from './providers/create-provider.js';
-import { resolveAttentionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
+import { resolveAttentionStatePath, resolveCompactionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
 import { appendVisibleMention as appendVisibleBodyMention, extractVisibleMentionIds as extractCanonicalMentionIds, } from './visible-mentions.js';
-import { waitForTaskForThread } from './task-thread-resolution.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts, extractHostedMessageAttachments, normalizeHostedMessageAttachment, } from './hosted-turn-content.js';
+import { waitForTaskForThread } from './task-thread-resolution.js';
 const PRIVATE_STATE_ROOT_MODE = 0o700;
-const STREAM_PROGRESS_EDIT_THROTTLE_MS = 150;
 const PROTOCOL_STATE_DIRNAME = 'protocol-state';
 const PROTOCOL_PROVIDER_TURN_TIMEOUT_MS = 120_000;
 const PROTOCOL_KICKOFF_DECISION_TIMEOUT_MS = PROTOCOL_PROVIDER_TURN_TIMEOUT_MS;
@@ -104,9 +104,6 @@ class DefaultHostRuntime {
         this.controlPlane =
             deps.borgee ??
                 new SdkChatControlPlane(config.borgeeBaseUrl, config.agent.agentApiKey, undefined, {
-                    cursorStore: createDurableCursorStore({
-                        stateRootDir: config.stateRootDir,
-                    }),
                     pluginId: `agents-host:${config.agent.provider}`,
                 });
         this.gateway = createLocalhostGatewayController({
@@ -139,9 +136,11 @@ class DefaultHostRuntime {
                     copilotArgs: config.copilotArgs,
                     copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
                     providerIdleShutdownMinutes: config.providerIdleShutdownMinutes,
+                    allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
                 }, deps.logger, {
                     compatibilityGates,
                     authorizationAuditSink: this.authorizationAuditSink,
+                    controlPlane: this.controlPlane,
                     localhostGateway: localhostGatewayGateEnabled ? this.gateway.contextPublisher : undefined,
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
@@ -258,113 +257,6 @@ function resolvePublicReplyText(reply) {
     }
     return reply.awaitingUser?.question ?? '';
 }
-function providerUsesDraftProgress(provider) {
-    return provider === 'claude' || provider === 'codex' || provider === 'copilot';
-}
-class DraftMessageController {
-    borgee;
-    channelId;
-    canWrite;
-    logger;
-    creationMetadata;
-    messageId = null;
-    currentBody = '';
-    pendingBody = null;
-    timer = null;
-    sealed = false;
-    writeChain = Promise.resolve();
-    constructor(borgee, channelId, canWrite, logger, creationMetadata) {
-        this.borgee = borgee;
-        this.channelId = channelId;
-        this.canWrite = canWrite;
-        this.logger = logger;
-        this.creationMetadata = creationMetadata;
-    }
-    update(text) {
-        if (this.sealed || !hasVisibleText(text)) {
-            return;
-        }
-        this.pendingBody = text;
-        if (this.timer) {
-            return;
-        }
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            void this.flushPending().catch((error) => {
-                this.logger.error('failed to flush draft progress', error);
-            });
-        }, STREAM_PROGRESS_EDIT_THROTTLE_MS);
-    }
-    cancelProgress() {
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        this.sealed = true;
-    }
-    async finalize(finalText) {
-        this.sealed = true;
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        if (hasVisibleText(finalText)) {
-            this.pendingBody = finalText;
-            await this.flushPending();
-            return this.messageId;
-        }
-        await this.enqueueWrite(async () => {
-            if (!this.canWrite() || !this.messageId) {
-                return;
-            }
-            await this.borgee.deleteMessage(this.messageId);
-            this.messageId = null;
-            this.currentBody = '';
-            this.pendingBody = null;
-        });
-        return null;
-    }
-    async discard() {
-        this.sealed = true;
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-        this.pendingBody = null;
-        await this.enqueueWrite(async () => {
-            if (!this.messageId) {
-                return;
-            }
-            await this.borgee.deleteMessage(this.messageId);
-            this.messageId = null;
-            this.currentBody = '';
-        });
-    }
-    async flushPending() {
-        await this.enqueueWrite(async () => {
-            const body = this.pendingBody;
-            if (!this.canWrite() || !body || body === this.currentBody) {
-                return;
-            }
-            if (this.messageId) {
-                await this.borgee.editMessage(this.messageId, body);
-            }
-            else {
-                const posted = await this.borgee.postMessage({
-                    channelId: this.channelId,
-                    body,
-                    replyToId: this.creationMetadata?.replyToId,
-                });
-                this.messageId = posted.messageId;
-            }
-            this.currentBody = body;
-        });
-    }
-    enqueueWrite(operation) {
-        this.writeChain = this.writeChain.then(operation, operation);
-        return this.writeChain;
-    }
-}
 /**
  * The registered task property agents-host writes to record which provider
  * session worked a task. It matches the server's registry key.
@@ -398,9 +290,12 @@ export class AgentsHost {
      */
     recordedAgentSessionByTask = new Map();
     attentionSnapshotByChannel = new Map();
+    compactionSnapshotByChannel = new Map();
+    activeCompactionByChannel = new Map();
+    compactionSnapshotLoadedChannels = new Set();
+    compactionSnapshotWriteQueueByChannel = new Map();
     missedCollaborationDiagnosticByChannel = new Map();
-    progressChannelQueues = new Map();
-    progressDrafts = new Map();
+    channelTurnQueues = new Map();
     collaborationDrafts = new Map();
     collaborationChannels = new Map();
     participantDirectoryByUserId = new Map();
@@ -508,20 +403,32 @@ export class AgentsHost {
             this.invalidateChannelTurn(channelId);
             this.clearProtocolFallback(this.collaborationChannels.get(channelId));
         }
-        for (const draft of this.progressDrafts.values()) {
-            draft.cancelProgress();
-        }
         for (const channelId of [...this.collaborationDrafts.keys()]) {
             this.clearCollaborationDraft(channelId);
         }
         this.awaitingUserByChannel.clear();
         this.collaborationOutcomeByChannel.clear();
         this.attentionSnapshotByChannel.clear();
+        this.compactionSnapshotByChannel.clear();
+        this.activeCompactionByChannel.clear();
+        this.compactionSnapshotLoadedChannels.clear();
         this.missedCollaborationDiagnosticByChannel.clear();
         this.recordedAgentSessionByTask.clear();
         this.controlPlaneClosed = true;
-        await this.runtime.stop();
+        const pendingCompactionSnapshotWrites = [...this.compactionSnapshotWriteQueueByChannel.values()];
+        let runtimeStopError;
+        try {
+            await this.runtime.stop();
+        }
+        catch (error) {
+            runtimeStopError = error;
+        }
         await Promise.allSettled([...this.activeTurns]);
+        await Promise.allSettled(pendingCompactionSnapshotWrites);
+        this.compactionSnapshotWriteQueueByChannel.clear();
+        if (runtimeStopError) {
+            throw runtimeStopError;
+        }
     }
     trackActiveTurn(task) {
         this.activeTurns.add(task);
@@ -532,9 +439,7 @@ export class AgentsHost {
     dispatchMessage(message) {
         const task = this.collaborationEnabled
             ? this.handleCollaborationMessage(message)
-            : providerUsesDraftProgress(this.config.agent.provider)
-                ? this.enqueueProgressChannelTurn(message.channel_id, () => this.handleLegacyMessage(message))
-                : this.handleLegacyMessage(message);
+            : this.enqueueChannelTurn(message.channel_id, () => this.handleLegacyMessage(message));
         this.trackActiveTurn(task);
     }
     async handleLegacyMessage(msg) {
@@ -557,6 +462,9 @@ export class AgentsHost {
                 const authorKind = await this.classifyAuthor(normalized.authorId, false);
                 await this.ensureAttentionSnapshotLoaded(msg.channel_id, channelState);
                 attentionSnapshot = this.getAttentionSnapshotForTurn(msg.channel_id, taskThreadContext);
+                if (this.isOrdinaryAgentWakeFiltered(msg, authorKind)) {
+                    return;
+                }
                 if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
                     return;
                 }
@@ -649,6 +557,9 @@ export class AgentsHost {
                 }
             }
         }
+        if (this.isOrdinaryAgentWakeFiltered(msg, authorKind)) {
+            return;
+        }
         if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
             return;
         }
@@ -1791,12 +1702,92 @@ export class AgentsHost {
     resolveAttentionStatePath(channelId) {
         return resolveAttentionStatePath(this.config.stateRootDir, channelId);
     }
+    resolveCompactionStatePath(channelId) {
+        return resolveCompactionStatePath(this.config.stateRootDir, channelId);
+    }
     buildDefaultAttentionSnapshot(options) {
         return buildNormalizedAttentionSnapshot({
             observedAt: options?.observedAt,
             turnExecutionId: options?.turnExecutionId,
         });
     }
+    async ensureCompactionSnapshotLoaded(channelId) {
+        if (this.compactionSnapshotLoadedChannels.has(channelId)) {
+            return;
+        }
+        this.compactionSnapshotLoadedChannels.add(channelId);
+        try {
+            const content = await readFile(this.resolveCompactionStatePath(channelId), 'utf8');
+            const snapshot = parsePersistedCompactionSnapshot(JSON.parse(content));
+            if (snapshot) {
+                this.compactionSnapshotByChannel.set(channelId, snapshot);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                this.logger.error('failed to load compaction state', {
+                    channelId,
+                    error: summarizeError(error),
+                });
+            }
+            this.compactionSnapshotByChannel.delete(channelId);
+        }
+    }
+    async commitCompactionSnapshot(channelId, snapshot) {
+        if (snapshot.stage === 'started') {
+            return;
+        }
+        await writePrivateJsonFile(this.resolveCompactionStatePath(channelId), snapshot);
+    }
+    enqueueCompactionSnapshotCommit(channelId, snapshot) {
+        const previous = this.compactionSnapshotWriteQueueByChannel.get(channelId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => { })
+            .then(() => this.commitCompactionSnapshot(channelId, snapshot));
+        this.compactionSnapshotWriteQueueByChannel.set(channelId, next);
+        void next.catch((error) => {
+            this.logger.error('failed to persist compaction state', {
+                channelId,
+                error: summarizeError(error),
+            });
+        }).finally(() => {
+            if (this.compactionSnapshotWriteQueueByChannel.get(channelId) === next) {
+                this.compactionSnapshotWriteQueueByChannel.delete(channelId);
+            }
+        });
+    }
+    noteCompactionProgress(channelId, update, options) {
+        const baseline = update.stage === 'started'
+            ? undefined
+            : this.activeCompactionByChannel.get(channelId)
+                ?? this.compactionSnapshotByChannel.get(channelId);
+        const nextSnapshot = mergeCompactionSnapshot(baseline, {
+            provider: update.provider,
+            stage: update.stage,
+            observedAt: Date.now(),
+            turnExecutionId: options?.turnExecutionId,
+            usedTokens: update.usedTokens,
+            contextWindowTokens: update.contextWindowTokens,
+            failureReason: update.failureReason,
+        });
+        this.logger.debug('provider compaction update', {
+            channelId,
+            provider: nextSnapshot.provider,
+            stage: nextSnapshot.stage,
+            usedTokens: nextSnapshot.usedTokens,
+            contextWindowTokens: nextSnapshot.contextWindowTokens,
+            failureReason: nextSnapshot.failureReason,
+            turnExecutionId: nextSnapshot.turnExecutionId,
+        });
+        if (nextSnapshot.stage === 'started') {
+            this.activeCompactionByChannel.set(channelId, nextSnapshot);
+            return;
+        }
+        this.activeCompactionByChannel.delete(channelId);
+        this.compactionSnapshotByChannel.set(channelId, nextSnapshot);
+        this.enqueueCompactionSnapshotCommit(channelId, nextSnapshot);
+    }
     /**
      * Record which provider session worked this task, as agent.session_id.
      *
@@ -1840,19 +1831,74 @@ export class AgentsHost {
         if (!this.contextInjectionEnabled) {
             return { state: 'inactive' };
         }
+        const recoverFromControlPlane = async (preferredTaskId) => {
+            try {
+                if (preferredTaskId) {
+                    try {
+                        const preferredTask = await this.borgee.getTask({ taskId: preferredTaskId });
+                        if (preferredTask.threadId === channelId) {
+                            return preferredTask.id.trim().length > 0
+                                ? { state: 'recovered', currentTaskId: preferredTask.id }
+                                : { state: 'recovered' };
+                        }
+                    }
+                    catch {
+                        // Fall through to the visibility-based scan.
+                    }
+                }
+                const channels = await this.borgee.listChannels();
+                const currentChannel = channels.find((channel) => channel.id === channelId);
+                if (currentChannel && currentChannel.kind !== 'thread') {
+                    return { state: 'inactive' };
+                }
+                let sawTaskListSuccess = false;
+                let sawTaskListFailure = false;
+                for (const channel of channels) {
+                    let tasks;
+                    try {
+                        tasks = await this.borgee.listTasks({ channelId: channel.id });
+                        sawTaskListSuccess = true;
+                    }
+                    catch {
+                        sawTaskListFailure = true;
+                        continue;
+                    }
+                    for (const task of tasks) {
+                        if (task.threadId === channelId) {
+                            return task.id.trim().length > 0 ? { state: 'recovered', currentTaskId: task.id } : { state: 'recovered' };
+                        }
+                    }
+                }
+                return sawTaskListSuccess && !sawTaskListFailure ? { state: 'inactive' } : { state: 'unavailable' };
+            }
+            catch {
+                return { state: 'unavailable' };
+            }
+        };
         try {
-            const content = await readFile(resolveChannelContextPayloadPath(this.config.stateRootDir, channelId), 'utf8');
+            const content = await readFile(resolveTaskAssignmentStatePath(this.config.stateRootDir, channelId), 'utf8');
             const payload = JSON.parse(content);
             if (payload.taskAssignmentContext?.active !== true) {
-                return { state: 'inactive' };
+                return await recoverFromControlPlane();
             }
             const currentTaskId = typeof payload.taskAssignmentContext.currentTaskId === 'string'
                 ? payload.taskAssignmentContext.currentTaskId.trim()
                 : '';
-            return currentTaskId ? { state: 'active', currentTaskId } : { state: 'active' };
+            if (currentTaskId) {
+                try {
+                    const task = await this.borgee.getTask({ taskId: currentTaskId });
+                    if (task.threadId === channelId) {
+                        return { state: 'active', currentTaskId: task.id };
+                    }
+                }
+                catch {
+                    // Fall through to the recovery scan below.
+                }
+            }
+            return await recoverFromControlPlane(currentTaskId || undefined);
         }
         catch {
-            return { state: 'unavailable' };
+            return await recoverFromControlPlane();
         }
     }
     async ensureAttentionSnapshotLoaded(channelId, channelState) {
@@ -1952,11 +1998,28 @@ export class AgentsHost {
         if (!ORDINARY_HUMAN_EVENT_KINDS.has(eventKind)) {
             return false;
         }
-        if (attentionSnapshot?.wakeMode === 'follow-visible-human') {
+        if (msg.channel_type === 'dm'
+            && attentionSnapshot?.wakeMode !== 'mute-non-mention') {
             return false;
         }
-        this.noteWakeSuppressedAttentionPolicy(msg, authorKind);
-        return true;
+        if (attentionSnapshot?.wakeMode === 'mute-non-mention') {
+            this.noteWakeSuppressedAttentionPolicy(msg, authorKind);
+            return true;
+        }
+        return false;
+    }
+    isOrdinaryAgentWakeFiltered(msg, authorKind) {
+        if (authorKind !== 'agent') {
+            return false;
+        }
+        if (msg.message_type === 'task_assignment') {
+            return false;
+        }
+        if (msg.type?.trim() === 'mention') {
+            return false;
+        }
+        const eventKind = msg.type?.trim() ?? '';
+        return ORDINARY_HUMAN_EVENT_KINDS.has(eventKind);
     }
     applyAttentionUpdate(channelId, baseSnapshot, attentionUpdate, taskThreadContext, options) {
         if (!this.attentionFollowSemanticsEnabled) {
@@ -2052,14 +2115,15 @@ export class AgentsHost {
             taskThreadContextActive: taskThreadContext.state === 'active',
         });
     }
-    resolveCollaborationCapabilityDeclarationForTurn() {
+    resolveCollaborationCapabilityDeclarationForTurn(taskThreadContext) {
         if (!this.collaborationCapabilitiesDiagnosticsEnabled) {
             return undefined;
         }
         return {
             ...(this.collaborationOutcomeModelEnabled ? { collaborationOutcome: true } : {}),
             ...(this.attentionFollowSemanticsEnabled ? { attentionSnapshot: true } : {}),
-            ...(this.taskThreadCollaborationContractEnabled
+            ...(this.contextInjectionEnabled ? { compactionSnapshot: true } : {}),
+            ...(this.taskThreadCollaborationContractEnabled && taskThreadContext.state === 'active'
                 ? { taskThreadCollaborationContract: true }
                 : {}),
             missedCollaborationDiagnostic: true,
@@ -2156,18 +2220,12 @@ export class AgentsHost {
         const turnExecutionId = activeTurn?.turnExecutionId ?? null;
         const stopTyping = silentTurn ? () => { } : this.borgee.startTyping(channelId);
         const collaborationGrounding = await this.buildCollaborationGrounding(authorId, options?.incomingAuthorKind, activeTurn, options?.kickoff);
-        const usePublicDraftProgress = !silentTurn &&
-            !deferDelivery &&
-            !this.collaborationEnabled &&
-            options?.incomingAuthorKind !== 'agent' &&
-            providerUsesDraftProgress(this.config.agent.provider) &&
-            activeTurn?.protocol === undefined;
-        const usePrivateCollaborationDraftProgress = !silentTurn &&
+        const publishesCollaborationDraft = !silentTurn &&
             !deferDelivery &&
             this.collaborationEnabled &&
             turnExecutionId != null &&
-            providerUsesDraftProgress(this.config.agent.provider) &&
             activeTurn?.protocol === undefined;
+        const observeProviderProgress = publishesCollaborationDraft || this.config.agent.provider === 'claude';
         const turnContext = {
             eventType: msg.type,
             channelId,
@@ -2188,12 +2246,15 @@ export class AgentsHost {
             ? this.collaborationOutcomeByChannel.get(channelId)
             : undefined;
         const missedCollaborationDiagnostic = this.resolveMissedCollaborationDiagnosticForTurn(channelId);
-        const collaborationCapabilities = this.resolveCollaborationCapabilityDeclarationForTurn();
+        const collaborationCapabilities = this.resolveCollaborationCapabilityDeclarationForTurn(taskThreadContext);
         const incomingParts = options?.incomingParts
             ?? buildHostedTurnContentParts({
                 text: String(msg.content ?? msg.body ?? content),
                 attachments: msg.attachments,
             });
+        const activityReporter = this.beginTurnActivity(channelId, activeTurn?.generation);
+        await this.ensureCompactionSnapshotLoaded(channelId);
+        const compactionSnapshot = this.compactionSnapshotByChannel.get(channelId);
         try {
             reply = await this.provider.generateReply({
                 agentName: this.config.agent.agentName,
@@ -2216,17 +2277,45 @@ export class AgentsHost {
                     : undefined,
                 collaborationOutcome,
                 attentionSnapshot,
+                compactionSnapshot,
                 ...(taskThreadCollaborationContract ? { taskThreadCollaborationContract } : {}),
                 ...(collaborationCapabilities ? { collaborationCapabilities } : {}),
                 ...(missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {}),
-            }, usePublicDraftProgress || usePrivateCollaborationDraftProgress
+                ...((taskThreadContext.state === 'active'
+                    || taskThreadContext.state === 'recovered'
+                    || taskThreadContext.state === 'unavailable')
+                    ? {
+                        taskAssignmentContextOverride: {
+                            active: true,
+                            ...(taskThreadContext.state === 'active' && taskThreadContext.currentTaskId
+                                ? { currentTaskId: taskThreadContext.currentTaskId }
+                                : {}),
+                        },
+                        ...(taskThreadContext.state === 'active'
+                            ? { taskAssignmentContextOverridePersistence: 'persist' }
+                            : { taskAssignmentContextOverridePersistence: 'ephemeral' }),
+                    }
+                    : {}),
+            }, observeProviderProgress
                 ? {
                     onProgress: (update) => {
                         if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
                             return;
                         }
-                        if (usePublicDraftProgress) {
-                            this.ensureProgressDraft(channelId, activeTurn?.generation, activeTurn?.delivery).update(update.text);
+                        if (update.type === 'compaction') {
+                            this.noteCompactionProgress(channelId, update.compaction, {
+                                turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
+                            });
+                            return;
+                        }
+                        const reportedActivity = toReportedActivity(update);
+                        if (reportedActivity) {
+                            activityReporter.progress(reportedActivity);
+                        }
+                        if (update.type !== 'text' || update.stream !== 'answer') {
+                            return;
+                        }
+                        if (!publishesCollaborationDraft) {
                             return;
                         }
                         this.publishCollaborationDraft(channelId, activeTurn, update.text);
@@ -2249,7 +2338,6 @@ export class AgentsHost {
                 turnExecutionId: activeTurn?.turnExecutionId ?? undefined,
             });
             if (!(await this.canAcceptCompletedTurnOutput(channelId, activeTurn))) {
-                await this.discardDraft(channelId);
                 if (activeTurn?.turnExecutionId) {
                     this.clearCollaborationDraft(channelId, {
                         generation: activeTurn.generation,
@@ -2298,35 +2386,7 @@ export class AgentsHost {
                     completed: true,
                 };
             }
-            if (usePublicDraftProgress) {
-                const draft = this.progressDrafts.get(channelId);
-                if (!this.started) {
-                    await draft?.discard().catch(() => { });
-                    this.progressDrafts.delete(channelId);
-                    return { reply, stale: true, completed: false };
-                }
-                const deliveredMessageId = await (draft ?? this.ensureProgressDraft(channelId, activeTurn?.generation, activeTurn?.delivery)).finalize(publicReplyText);
-                this.progressDrafts.delete(channelId);
-                this.logger.debug('completed turn', {
-                    ...turnContext,
-                    durationMs: Date.now() - turnStartedAt,
-                    replyLength: publicReplyText.length,
-                    controlKind: reply?.control?.kind ?? null,
-                    controlMalformed: reply?.controlMalformed ?? false,
-                    delivery: 'draft',
-                });
-                return {
-                    reply,
-                    deliveredMessageId,
-                    publicReplyText,
-                    visibleReplyBody,
-                    deliveryState: deliveredMessageId ? 'draft-finalized' : 'not-delivered',
-                    appliedAttentionSnapshot,
-                    stale: false,
-                    completed: true,
-                };
-            }
-            else if (this.started && !this.controlPlaneClosed && hasVisibleText(publicReplyText)) {
+            if (this.started && !this.controlPlaneClosed && hasVisibleText(publicReplyText)) {
                 const posted = await this.borgee.postMessage({
                     channelId,
                     body: visibleReplyBody,
@@ -2340,7 +2400,7 @@ export class AgentsHost {
                     controlMalformed: reply?.controlMalformed ?? false,
                     delivery: 'post',
                 });
-                if (usePrivateCollaborationDraftProgress) {
+                if (publishesCollaborationDraft) {
                     this.finalizeCollaborationDraft(channelId, activeTurn, posted.messageId, visibleReplyBody);
                 }
                 return {
@@ -2358,9 +2418,9 @@ export class AgentsHost {
                 ...turnContext,
                 durationMs: Date.now() - turnStartedAt,
                 replyLength: publicReplyText.length,
-                delivery: usePublicDraftProgress ? 'draft' : 'post',
+                delivery: 'post',
             });
-            if (usePrivateCollaborationDraftProgress && activeTurn?.turnExecutionId) {
+            if (publishesCollaborationDraft && activeTurn?.turnExecutionId) {
                 this.clearCollaborationDraft(channelId, {
                     generation: activeTurn.generation,
                     turnExecutionId: activeTurn.turnExecutionId,
@@ -2378,7 +2438,6 @@ export class AgentsHost {
             };
         }
         catch (error) {
-            await this.discardDraft(channelId);
             if (activeTurn?.turnExecutionId) {
                 this.clearCollaborationDraft(channelId, {
                     generation: activeTurn.generation,
@@ -2404,8 +2463,31 @@ export class AgentsHost {
         }
         finally {
             stopTyping();
+            activityReporter.end();
         }
     }
+    /**
+     * Opens this turn's report on the activity rail.
+     *
+     * The generation is captured here, where the turn's own is, and every report
+     * is checked against the channel's current turn before it leaves. That is what
+     * keeps a superseded turn from announcing a boundary for a turn that no longer
+     * exists — including its ending, which a window opened before it was replaced
+     * would otherwise carry out on its behalf.
+     *
+     * Every turn reports, including the silent and deferred ones that deliver
+     * nothing to the channel. The rail writes nothing anywhere, and the question
+     * it answers — whether anything is happening in this channel — is worth the
+     * same answer for a turn that keeps its reply to itself.
+     */
+    beginTurnActivity(channelId, generation) {
+        const reporter = this.borgee.reportTurnActivity({
+            channelId,
+            canReport: () => this.canAcceptTurnOutput(channelId, generation),
+        });
+        reporter.start();
+        return reporter;
+    }
     canAcceptTurnOutput(channelId, generation) {
         if (!this.started || this.controlPlaneClosed) {
             return false;
@@ -2448,27 +2530,19 @@ export class AgentsHost {
         this.clearProtocolFallback(channelState);
         return false;
     }
-    enqueueProgressChannelTurn(channelId, task) {
-        const previous = this.progressChannelQueues.get(channelId) ?? Promise.resolve();
+    enqueueChannelTurn(channelId, task) {
+        const previous = this.channelTurnQueues.get(channelId) ?? Promise.resolve();
         const next = previous
             .catch(() => { })
             .then(task)
             .finally(() => {
-            if (this.progressChannelQueues.get(channelId) === next) {
-                this.progressChannelQueues.delete(channelId);
+            if (this.channelTurnQueues.get(channelId) === next) {
+                this.channelTurnQueues.delete(channelId);
             }
         });
-        this.progressChannelQueues.set(channelId, next);
+        this.channelTurnQueues.set(channelId, next);
         return next;
     }
-    ensureProgressDraft(channelId, generation, creationMetadata) {
-        let draft = this.progressDrafts.get(channelId);
-        if (!draft) {
-            draft = new DraftMessageController(this.borgee, channelId, () => !this.controlPlaneClosed && this.canAcceptTurnOutput(channelId, generation), this.logger, creationMetadata);
-            this.progressDrafts.set(channelId, draft);
-        }
-        return draft;
-    }
     publishCollaborationDraft(channelId, activeTurn, body) {
         if (!activeTurn?.turnExecutionId || !hasVisibleText(body)) {
             return;
@@ -2557,14 +2631,6 @@ export class AgentsHost {
         }
         return { ...draft.snapshot };
     }
-    async discardDraft(channelId) {
-        const draft = this.progressDrafts.get(channelId);
-        if (!draft) {
-            return;
-        }
-        this.progressDrafts.delete(channelId);
-        await draft.discard().catch(() => { });
-    }
     supersedeActiveTurn(channelId, activeTurn) {
         if (activeTurn.superseded) {
             return;
@@ -2582,7 +2648,6 @@ export class AgentsHost {
         }
         activeTurn.superseded = true;
         activeTurn.turnExecutionId = null;
-        void this.discardDraft(channelId);
     }
     invalidateChannelTurn(channelId) {
         const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;