@borgee/agents-host 0.2.35 → 0.2.56

package/dist/agents-host.js

@@ -3,19 +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 { 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';
 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;
@@ -103,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({
@@ -126,7 +124,9 @@ class DefaultHostRuntime {
             deps.provider ??
                 createProvider({
                     provider: config.agent.provider,
+                    borgeeBaseUrl: config.borgeeBaseUrl,
                     stateRootDir: config.stateRootDir,
+                    agentApiKey: config.agent.agentApiKey,
                     resolveStableAgentId: deps.resolveStableAgentId,
                     claudeCommand: config.claudeCommand,
                     claudeArgs: config.claudeArgs,
@@ -139,6 +139,7 @@ class DefaultHostRuntime {
                 }, deps.logger, {
                     compatibilityGates,
                     authorizationAuditSink: this.authorizationAuditSink,
+                    controlPlane: this.controlPlane,
                     localhostGateway: localhostGatewayGateEnabled ? this.gateway.contextPublisher : undefined,
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
@@ -255,113 +256,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.
@@ -395,9 +289,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();
@@ -505,20 +402,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);
@@ -529,9 +438,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) {
@@ -559,7 +466,7 @@ export class AgentsHost {
                 }
             }
         }
-        await this.runUngatedTurn(msg, normalized.authorId, normalized.content, taskThreadContext, attentionSnapshot);
+        await this.runUngatedTurn(msg, normalized.authorId, normalized.content, taskThreadContext, attentionSnapshot, normalized.incomingParts);
     }
     async handleCollaborationMessage(msg) {
         const normalized = await this.normalizeMessage(msg);
@@ -608,6 +515,7 @@ export class AgentsHost {
                     authorId: normalized.authorId,
                     authorKind: 'unknown',
                     content: normalized.content,
+                    incomingParts: normalized.incomingParts,
                     attentionSnapshot,
                     taskThreadContext,
                 });
@@ -626,6 +534,7 @@ export class AgentsHost {
                     authorId: normalized.authorId,
                     authorKind: 'human',
                     content: normalized.content,
+                    incomingParts: normalized.incomingParts,
                     attentionSnapshot,
                     taskThreadContext,
                     wakeBlockedState,
@@ -658,6 +567,7 @@ export class AgentsHost {
             authorId: normalized.authorId,
             authorKind,
             content: normalized.content,
+            incomingParts: normalized.incomingParts,
             attentionSnapshot,
             taskThreadContext,
         });
@@ -752,6 +662,7 @@ export class AgentsHost {
         const executed = await this.executeTurn(msg, normalized.authorId, normalized.content, {
             kickoff: protocolCandidate,
             silent: true,
+            incomingParts: normalized.incomingParts,
         });
         if (executed.stale) {
             return null;
@@ -912,6 +823,7 @@ export class AgentsHost {
                 authorId: normalized.authorId,
                 authorKind: 'human',
                 content: normalized.content,
+                incomingParts: normalized.incomingParts,
             });
             await this.ensureCollaborationProcessor(msg.channel_id, channelState);
             return;
@@ -924,6 +836,7 @@ export class AgentsHost {
             ownerAgentId: selfAgentId,
             anchorAuthorId: normalized.authorId,
             anchorContent: normalized.content,
+            anchorIncomingParts: normalized.incomingParts,
             anchorMessageId: msg.message_id ?? randomUUID(),
             participantIds: protocolRequest.participantIds,
             issuerId: protocolRequest.issuerId,
@@ -946,6 +859,7 @@ export class AgentsHost {
                 authorId: normalized.authorId,
                 authorKind: 'human',
                 content: normalized.content,
+                incomingParts: normalized.incomingParts,
             });
             await this.ensureCollaborationProcessor(msg.channel_id, channelState);
             return;
@@ -1014,6 +928,7 @@ export class AgentsHost {
             authorId: normalized.authorId,
             authorKind: 'agent',
             content: normalized.content,
+            incomingParts: normalized.incomingParts,
         });
         await this.ensureCollaborationProcessor(msg.channel_id, channelState);
     }
@@ -1131,6 +1046,7 @@ export class AgentsHost {
         channelState.activeTurn = activeTurn;
         const executed = await this.executeTurn(message.raw, message.authorId, this.buildIncomingContent(message), {
             activeTurn,
+            incomingParts: message.incomingParts,
             incomingAuthorKind: message.authorKind,
             attentionSnapshot,
             taskThreadContext,
@@ -1234,6 +1150,7 @@ export class AgentsHost {
         channelState.activeTurn = activeTurn;
         const executed = await this.executeTurn(message.raw, message.authorId, this.buildIncomingContent(message), {
             activeTurn,
+            incomingParts: message.incomingParts,
             incomingAuthorKind: message.authorKind,
             attentionSnapshot,
             taskThreadContext,
@@ -1541,59 +1458,52 @@ export class AgentsHost {
     }
     async buildResumedProtocolMessage(channelId, protocolState) {
         if (protocolState.currentTurnIndex === 0) {
+            const anchorIncomingParts = await this.ensureProtocolAnchorIncomingParts(channelId, protocolState);
+            const anchorIncomingContent = buildHostedIncomingContentText(anchorIncomingParts);
             return {
                 kind: 'protocol-turn',
                 raw: {
                     channel_id: channelId,
                     message_id: protocolState.anchorMessageId,
                     user_id: protocolState.anchorAuthorId,
-                    content: protocolState.anchorContent,
-                    body: protocolState.anchorContent,
+                    content: anchorIncomingContent,
+                    body: anchorIncomingContent,
+                    attachments: extractHostedMessageAttachments(anchorIncomingParts),
                     type: 'message',
                 },
                 authorId: protocolState.anchorAuthorId,
                 authorKind: 'human',
-                content: protocolState.anchorContent,
+                content: anchorIncomingContent,
+                incomingParts: anchorIncomingParts,
             };
         }
         if (!protocolState.lastProtocolMessageId) {
             return null;
         }
-        let before;
-        for (;;) {
-            const history = await this.borgee.readChannelHistory({
-                channelId,
-                before,
-                limit: 200,
+        const priorMessage = await this.findChannelHistoryMessageById(channelId, protocolState.lastProtocolMessageId);
+        if (priorMessage) {
+            const incomingParts = buildHostedTurnContentParts({
+                text: priorMessage.body,
+                attachments: priorMessage.attachments,
             });
-            const priorMessage = history.find((entry) => entry.id === protocolState.lastProtocolMessageId);
-            if (priorMessage) {
-                return {
-                    kind: 'protocol-turn',
-                    raw: {
-                        channel_id: channelId,
-                        message_id: priorMessage.id,
-                        user_id: priorMessage.authorId,
-                        content: priorMessage.body,
-                        body: priorMessage.body,
-                        type: 'message',
-                        created_at: priorMessage.createdAt,
-                    },
-                    authorId: priorMessage.authorId,
-                    authorKind: 'agent',
-                    content: priorMessage.body,
-                };
-            }
-            if (history.length < 200) {
-                break;
-            }
-            const oldestCreatedAt = history.reduce((oldest, entry) => {
-                return oldest == null || entry.createdAt < oldest ? entry.createdAt : oldest;
-            }, null);
-            if (oldestCreatedAt == null || (before != null && oldestCreatedAt >= before)) {
-                break;
-            }
-            before = oldestCreatedAt;
+            const incomingContent = buildHostedIncomingContentText(incomingParts);
+            return {
+                kind: 'protocol-turn',
+                raw: {
+                    channel_id: channelId,
+                    message_id: priorMessage.id,
+                    user_id: priorMessage.authorId,
+                    content: incomingContent,
+                    body: incomingContent,
+                    attachments: priorMessage.attachments,
+                    type: 'message',
+                    created_at: priorMessage.createdAt,
+                },
+                authorId: priorMessage.authorId,
+                authorKind: 'agent',
+                content: incomingContent,
+                incomingParts,
+            };
         }
         return null;
     }
@@ -1604,6 +1514,7 @@ export class AgentsHost {
             ownerAgentId,
             anchorAuthorId: protocolState.anchorAuthorId,
             anchorContent: protocolState.anchorContent,
+            anchorIncomingParts: protocolState.anchorIncomingParts,
             anchorMessageId: protocolState.anchorMessageId,
             participantIds: protocolState.participantIds,
             issuerId: protocolState.issuerId,
@@ -1682,18 +1593,36 @@ export class AgentsHost {
             await this.persistProtocolState(channelId, protocolState);
             return;
         }
+        const anchorIncomingParts = await this.ensureProtocolAnchorIncomingParts(channelId, protocolState);
+        const anchorIncomingContent = buildHostedIncomingContentText(anchorIncomingParts);
         const fallbackMessage = {
             channel_id: channelId,
             message_id: protocolState.anchorMessageId,
             user_id: protocolState.anchorAuthorId,
-            content: protocolState.anchorContent,
-            body: protocolState.anchorContent,
+            content: anchorIncomingContent,
+            body: anchorIncomingContent,
+            attachments: extractHostedMessageAttachments(anchorIncomingParts),
             type: 'message',
         };
         this.cancelProtocolState(channelId, channelState);
         const taskThreadContext = await this.buildTurnTaskThreadContext(fallbackMessage, channelId);
         const attentionSnapshot = this.getAttentionSnapshotForTurn(channelId, taskThreadContext);
-        await this.runUngatedTurn(fallbackMessage, protocolState.anchorAuthorId, protocolState.anchorContent, taskThreadContext, attentionSnapshot);
+        await this.runUngatedTurn(fallbackMessage, protocolState.anchorAuthorId, anchorIncomingContent, taskThreadContext, attentionSnapshot, anchorIncomingParts);
+    }
+    async ensureProtocolAnchorIncomingParts(channelId, protocolState) {
+        if (protocolState.anchorIncomingParts) {
+            return protocolState.anchorIncomingParts;
+        }
+        const anchorMessage = await this.findChannelHistoryMessageById(channelId, protocolState.anchorMessageId);
+        if (!anchorMessage) {
+            return buildHostedTurnContentParts({ text: protocolState.anchorContent });
+        }
+        const anchorIncomingParts = buildHostedTurnContentParts({
+            text: protocolState.anchorContent,
+            attachments: anchorMessage.attachments,
+        });
+        protocolState.anchorIncomingParts = anchorIncomingParts;
+        return anchorIncomingParts;
     }
     finishProtocolState(channelId, channelState, protocolState, lastMessageId) {
         protocolState.active = false;
@@ -1733,15 +1662,125 @@ export class AgentsHost {
         }
         return matched;
     }
+    async findChannelHistoryMessageById(channelId, messageId) {
+        let before;
+        for (;;) {
+            const history = await this.borgee.readChannelHistory({
+                channelId,
+                before,
+                limit: 200,
+            });
+            const matched = history.find((entry) => entry.id === messageId);
+            if (matched) {
+                return {
+                    ...matched,
+                    ...(matched.attachments
+                        ? { attachments: matched.attachments.map(normalizeHostedMessageAttachment) }
+                        : {}),
+                };
+            }
+            if (history.length < 200) {
+                break;
+            }
+            const oldestCreatedAt = history.reduce((oldest, entry) => {
+                return oldest == null || entry.createdAt < oldest ? entry.createdAt : oldest;
+            }, null);
+            if (oldestCreatedAt == null || (before != null && oldestCreatedAt >= before)) {
+                break;
+            }
+            before = oldestCreatedAt;
+        }
+        return null;
+    }
     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.
      *
@@ -1997,14 +2036,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,
@@ -2037,10 +2077,11 @@ export class AgentsHost {
             reason: 'wake-suppressed-attention-policy',
         });
     }
-    async runUngatedTurn(msg, authorId, content, taskThreadContext, attentionSnapshot) {
+    async runUngatedTurn(msg, authorId, content, taskThreadContext, attentionSnapshot, incomingParts) {
         const executed = await this.executeTurn(msg, authorId, content, {
             attentionSnapshot,
             taskThreadContext,
+            incomingParts,
         });
         if (executed.completed && executed.reply) {
             this.updateAwaitingUserState(msg.channel_id, executed.reply.awaitingUser);
@@ -2100,18 +2141,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,
@@ -2132,7 +2167,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,
@@ -2140,6 +2183,7 @@ export class AgentsHost {
                 channelId,
                 incomingAuthorId: authorId,
                 incomingContent: content,
+                incomingParts,
                 incomingEventKind: msg.type,
                 incomingMessageType: msg.message_type,
                 collaboration: turnExecutionId || options?.kickoff
@@ -2154,17 +2198,30 @@ export class AgentsHost {
                     : undefined,
                 collaborationOutcome,
                 attentionSnapshot,
+                compactionSnapshot,
                 ...(taskThreadCollaborationContract ? { taskThreadCollaborationContract } : {}),
                 ...(collaborationCapabilities ? { collaborationCapabilities } : {}),
                 ...(missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {}),
-            }, usePublicDraftProgress || usePrivateCollaborationDraftProgress
+            }, 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);
@@ -2187,7 +2244,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,
@@ -2236,35 +2292,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,
@@ -2278,7 +2306,7 @@ export class AgentsHost {
                     controlMalformed: reply?.controlMalformed ?? false,
                     delivery: 'post',
                 });
-                if (usePrivateCollaborationDraftProgress) {
+                if (publishesCollaborationDraft) {
                     this.finalizeCollaborationDraft(channelId, activeTurn, posted.messageId, visibleReplyBody);
                 }
                 return {
@@ -2296,9 +2324,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,
@@ -2316,7 +2344,6 @@ export class AgentsHost {
             };
         }
         catch (error) {
-            await this.discardDraft(channelId);
             if (activeTurn?.turnExecutionId) {
                 this.clearCollaborationDraft(channelId, {
                     generation: activeTurn.generation,
@@ -2342,8 +2369,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;
@@ -2386,27 +2436,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;
@@ -2495,14 +2537,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;
@@ -2520,7 +2554,6 @@ export class AgentsHost {
         }
         activeTurn.superseded = true;
         activeTurn.turnExecutionId = null;
-        void this.discardDraft(channelId);
     }
     invalidateChannelTurn(channelId) {
         const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
@@ -2683,17 +2716,22 @@ export class AgentsHost {
             });
             return null;
         }
-        const content = String(msg.content ?? msg.body ?? '').trim();
-        if (!content) {
+        const incomingParts = buildHostedTurnContentParts({
+            text: String(msg.content ?? msg.body ?? ''),
+            attachments: msg.attachments,
+        });
+        if (incomingParts.length === 0) {
             this.logger.debug('ignored empty message', {
                 channelId: msg.channel_id,
                 messageId: msg.message_id,
             });
             return null;
         }
+        const content = buildHostedIncomingContentText(incomingParts);
         return {
             authorId,
             content,
+            incomingParts,
         };
     }
     // Only a task assigned to this agent drives a task-assignment turn: it keeps the message a