@borgee/agents-host 0.2.44 → 0.2.56

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 { 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;
@@ -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({
@@ -142,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;
@@ -258,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.
@@ -398,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();
@@ -508,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);
@@ -532,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) {
@@ -1791,12 +1695,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.
      *
@@ -2052,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,
@@ -2156,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,
@@ -2188,12 +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,
@@ -2216,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);
@@ -2249,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,
@@ -2298,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,
@@ -2340,7 +2306,7 @@ export class AgentsHost {
                     controlMalformed: reply?.controlMalformed ?? false,
                     delivery: 'post',
                 });
-                if (usePrivateCollaborationDraftProgress) {
+                if (publishesCollaborationDraft) {
                     this.finalizeCollaborationDraft(channelId, activeTurn, posted.messageId, visibleReplyBody);
                 }
                 return {
@@ -2358,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,
@@ -2378,7 +2344,6 @@ export class AgentsHost {
             };
         }
         catch (error) {
-            await this.discardDraft(channelId);
             if (activeTurn?.turnExecutionId) {
                 this.clearCollaborationDraft(channelId, {
                     generation: activeTurn.generation,
@@ -2404,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;
@@ -2448,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;
@@ -2557,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;
@@ -2582,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;

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

@@ -1,3 +1,4 @@
+import type { ReportTurnActivityInput, TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 export interface ChatControlPlane {
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
@@ -6,6 +7,8 @@ export interface ChatControlPlane {
     editMessage(messageId: string, content: string): Promise<void>;
     deleteMessage(messageId: string): Promise<void>;
     startTyping(channelId: string): () => void;
+    /** Opens one turn's report on the activity rail. Fire-and-forget: nothing recovers what it sends. */
+    reportTurnActivity(input: ReportTurnActivityInput): TurnActivityReporter;
     getMe(): Promise<MeResponseUser>;
     listUsers(): Promise<DirectoryUser[]>;
     listChannels(): Promise<ChannelSummary[]>;

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

@@ -1,9 +1,9 @@
-import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent } from '../plugin-sdk.js';
+import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 import type { ChatControlPlane } from './chat-control-plane.js';
-type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'readHistory' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
-type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'cursorStore' | 'pluginId'>;
+type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'pluginId'>;
 /**
  * Thin adapter over `@borgee/plugin-sdk` (the same BPP/`/ws/plugin` SDK used by
  * the OpenClaw plugin) that implements the minimal `ChatControlPlane` surface
@@ -22,6 +22,7 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     editMessage(messageId: string, content: string): Promise<void>;
     deleteMessage(messageId: string): Promise<void>;
     startTyping(channelId: string): () => void;
+    reportTurnActivity(input: ReportTurnActivityInput): TurnActivityReporter;
     getMe(): Promise<MeResponseUser>;
     listUsers(): Promise<DirectoryUser[]>;
     readChannelHistory(input: ReadChannelHistoryInput): Promise<ChannelHistoryEntry[]>;

package/dist/chat/sdk-chat-control-plane.js

@@ -65,6 +65,9 @@ export class SdkChatControlPlane {
     startTyping(channelId) {
         return this.client.startTyping(channelId);
     }
+    reportTurnActivity(input) {
+        return this.client.reportTurnActivity(input);
+    }
     async getMe() {
         if (this.me) {
             return this.me;

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { realpathSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { assertNoUpdateArgs, CliUsageError, parseApplyManagedArgs, parseDaemonArgs, parseDescribeArgs, parseDescribeManagedArgs, parseCleanupManagedArgs, parseGenerateConfigArgs, parseLogArgs, parseManagedStartArgs, parsePrintLayoutArgs, parseStartArgs, parseValidateArgs, USAGE, } from './cli-args.js';
 import { resolveAgentsHostDebugMode } from './debug.js';
@@ -15,7 +15,6 @@ function formatErrorMessage(error) {
     }
     return String(error);
 }
-const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
 export async function dispatchCli(argv, deps = {}) {
     const [command, ...rest] = argv;
     const env = deps.env ?? process.env;
@@ -31,7 +30,6 @@ export async function dispatchCli(argv, deps = {}) {
     const applyManagedSpecImpl = deps.applyManagedSpec ?? applyManagedSpec;
     const startManagedDaemonImpl = deps.startManagedDaemon ??
         (async (rootPath, debug) => {
-            env[TASK_WORKSPACE_ROOT_DIR_ENV] = rootPath;
             const daemon = new ManagedAgentsHostDaemon(rootPath, debug, {
                 logPath: env.AGENTS_HOST_MANAGED_DAEMON_LOG_PATH,
             });
@@ -63,7 +61,6 @@ export async function dispatchCli(argv, deps = {}) {
             await runMainImpl({ debug });
             return;
         }
-        env[TASK_WORKSPACE_ROOT_DIR_ENV] = dirname(resolve(parsed.configPath));
         await runMainImpl({ configPath: parsed.configPath, debug });
         return;
     }
@@ -167,7 +164,6 @@ export async function dispatchCli(argv, deps = {}) {
     }
     if (command === 'daemon') {
         const parsed = parseDaemonArgs(rest);
-        env[TASK_WORKSPACE_ROOT_DIR_ENV] = parsed.rootPath;
         await startManagedDaemonImpl(parsed.rootPath, parsed.debug);
         return;
     }

package/dist/compatibility-gates.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectionStrategy } from './types.js';
 export declare const CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE = "claude-provider-v2";
 export declare const COPILOT_PROVIDER_V2_COMPATIBILITY_GATE = "copilot-provider-v2";
 export declare const CODEX_PROVIDER_COMPATIBILITY_GATE = "codex-provider";
@@ -18,6 +19,7 @@ export declare const COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_COMPATIBILI
 export declare const INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_DISABLED_COMPATIBILITY_GATES";
 export declare const INTERNAL_POLICY_MODE_ENV = "AGENTS_HOST_INTERNAL_POLICY_MODE";
 export declare const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = "AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS";
+export declare const INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV = "AGENTS_HOST_INTERNAL_CLAUDE_PROMPT_STRATEGY";
 export declare const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
 export type InternalPolicyMode = 'audit-only' | 'enforce';
 export type InternalProviderImplementationPath = 'v1' | 'v2';
@@ -28,8 +30,10 @@ export interface ManagedRuntimeSettingsSnapshot {
     compatibilityGates: string[];
     providerImplementationOverrides: string[];
     internalPolicyMode: InternalPolicyMode;
+    projectionStrategy: ProjectionStrategy;
 }
 export declare const DEFAULT_INTERNAL_COMPATIBILITY_GATES: readonly string[];
+export declare function resolveInternalProjectionStrategy(env?: NodeJS.ProcessEnv): ProjectionStrategy;
 export declare function parseCompatibilityGates(rawValue: string | undefined): ReadonlySet<string>;
 export declare function resolveInternalCompatibilityGates(env?: NodeJS.ProcessEnv): ReadonlySet<string>;
 export declare function resolveDisabledDefaultCompatibilityGates(compatibilityGates: Iterable<string>): string[];