@borgee/agents-host 0.2.56 → 0.2.65

package/README.md

@@ -479,7 +479,7 @@ successfully applied snapshot running.
 Each Borgee channel is mapped 1:1 to a provider-native session while it stays
 active:
 
-- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess is shared by a single `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are serialized; different channels keep isolated ACP sessions. The real ACP session cwd now comes from the resolved channel workspace `~/.borgee/channels/<encoded-channel-id>/workspace`. Task threads inherit that same channel workspace unless the bound task carries `workspace.mode=isolated`, in which case the real ACP session cwd switches to `~/.borgee/channels/<encoded-channel-id>/tasks/<encoded-task-id>/workspace`. Both writable workspace paths are explicitly not a claim that the target repository is already checked out there. The host persists the channel→ACP-session map in its state root, restores same-host continuity with ACP `session/resume` when available, retries stale restores with a fresh session immediately, and injects the per-channel local context paths through Claude ACP `_meta.systemPrompt.append`.
+- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess is shared by a single `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are serialized; different channels keep isolated ACP sessions. The real ACP session cwd now comes from the resolved channel workspace `~/.borgee/channels/<encoded-channel-id>/workspace`. Task threads only switch execution onto an explicit existing `execution.local_directory`; otherwise they stay discussion-only on `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP permission requests are denied so filesystem and shell tools stay unavailable. The host persists the channel→ACP-session map in its state root, restores same-host continuity with ACP `session/resume` when available, retries stale restores with a fresh session immediately, and injects the per-channel local context paths through Claude ACP `_meta.systemPrompt.append`.
 - **Codex**: one persistent `@agentclientprotocol/codex-acp` subprocess is
   shared by a single `AgentsHost`, with one ACP session per Borgee channel. When
   the current turn has a materialized channel context payload, Codex refreshes a
@@ -487,12 +487,11 @@ active:
   per-channel projection directory and exposes that directory to Codex through
   ACP `additionalDirectories`. The real ACP session cwd now comes from the
   resolved channel workspace `~/.borgee/channels/<encoded-channel-id>/workspace`.
-  Task threads inherit that same channel
-  workspace unless the bound task carries `workspace.mode=isolated`, in which
-  case the real ACP session cwd switches to
-  `~/.borgee/channels/<encoded-channel-id>/tasks/<encoded-task-id>/workspace`. Both
-  writable workspace paths are explicitly not a claim that the target
-  repository is already checked out there. The host persists the
+  Task threads only switch execution onto an explicit existing
+  `execution.local_directory`; otherwise they stay discussion-only on
+  `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP
+  permission requests are denied so filesystem and shell tools stay
+  unavailable. The host persists the
   channel→ACP-session map in its state root and attempts ACP `session/resume`
   first when the adapter advertises it, otherwise `session/load`.
 - **Copilot**: one persistent `copilot --acp` subprocess is shared by a single
@@ -500,9 +499,11 @@ active:
   serialized; different channels keep isolated ACP sessions. The real ACP
   session cwd now comes from the resolved channel workspace
   `~/.borgee/channels/<encoded-channel-id>/workspace` by default. Task threads
-  inherit that same channel workspace unless the bound task carries
-  `workspace.mode=isolated`, in which case the real ACP session cwd switches
-  to `~/.borgee/channels/<encoded-channel-id>/tasks/<encoded-task-id>/workspace`. The
+  only switch execution onto an explicit existing `execution.local_directory`;
+  otherwise they stay discussion-only on
+  `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP
+  permission requests are denied so filesystem and shell tools stay
+  unavailable. The
   host persists the channel→ACP-session map in its state root and restores
   same-host continuity with ACP `session/resume` when available, otherwise
   `session/load` plus local replay cleanup on runtimes that advertise only

package/dist/agents-host.d.ts

@@ -1,6 +1,6 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
 import { type AgentsHostRuntimeOptions } from './debug.js';
-import type { ProviderAdapter } from './providers/provider-adapter.js';
+import { type ProviderAdapter } from './providers/provider-adapter.js';
 import type { AgentsHostConfig } from './types.js';
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
@@ -125,6 +125,7 @@ export declare class AgentsHost {
     private revalidateAttentionSnapshotForTurn;
     private getAttentionSnapshotForTurn;
     private isHumanWakeFiltered;
+    private isOrdinaryAgentWakeFiltered;
     private applyAttentionUpdate;
     private commitAttentionSnapshot;
     private resolveTaskThreadCollaborationContractForTurn;
@@ -159,6 +160,8 @@ export declare class AgentsHost {
     private readCollaborationDraft;
     private supersedeActiveTurn;
     private invalidateChannelTurn;
+    private stopTurn;
+    private responseStateForExecuted;
     private rememberRecentTurn;
     private resolveAuthorizedCollaborationTurn;
     private updateAwaitingUserState;

package/dist/agents-host.js

@@ -9,13 +9,14 @@ import { buildNormalizedAttentionSnapshot, parsePersistedAttentionSnapshot, } fr
 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 { ProviderTurnCancelledError } from './providers/provider-adapter.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 PROTOCOL_STATE_DIRNAME = 'protocol-state';
 const PROTOCOL_PROVIDER_TURN_TIMEOUT_MS = 120_000;
@@ -24,6 +25,9 @@ const PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS = 50;
 const PROTOCOL_KICKOFF_ROUND_LIMIT = 20;
 const COLLABORATION_LATE_SEND_GRACE_MS = 5_000;
 const ORDINARY_HUMAN_EVENT_KINDS = new Set(['', 'message']);
+const TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY = 'execution.local_directory';
+const TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER = 'This task has no Execution Local Directory yet. Set it before asking me to work in a real local project directory.';
+const TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX = 'Using Execution Local Directory:';
 async function ensurePrivateStateRoot(path) {
     await mkdir(path, { recursive: true, mode: PRIVATE_STATE_ROOT_MODE });
     await chmod(path, PRIVATE_STATE_ROOT_MODE);
@@ -136,6 +140,7 @@ class DefaultHostRuntime {
                     copilotArgs: config.copilotArgs,
                     copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
                     providerIdleShutdownMinutes: config.providerIdleShutdownMinutes,
+                    allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
                 }, deps.logger, {
                     compatibilityGates,
                     authorizationAuditSink: this.authorizationAuditSink,
@@ -144,13 +149,15 @@ class DefaultHostRuntime {
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
     }
-    async start(onMessage) {
+    async start(onMessage, onStopTurn) {
         await this.ensureStateRoot(this.config.stateRootDir);
         await this.gateway.start();
         try {
+            this.controlPlane.onStopTurn?.(onStopTurn);
             await this.controlPlane.connect(onMessage);
         }
         catch (error) {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.gateway.stop().catch(() => { });
             throw error;
         }
@@ -158,6 +165,7 @@ class DefaultHostRuntime {
     async stop() {
         let thrown;
         try {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.controlPlane.close();
         }
         catch (error) {
@@ -365,7 +373,7 @@ export class AgentsHost {
                     return;
                 }
                 this.dispatchMessage(message);
-            });
+            }, async (channelId) => this.stopTurn(channelId));
             const agentId = await this.ensureSelfAgentId();
             bufferingMessages = false;
             while (bufferedMessages.length > 0) {
@@ -461,6 +469,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;
                 }
@@ -553,6 +564,9 @@ export class AgentsHost {
                 }
             }
         }
+        if (this.isOrdinaryAgentWakeFiltered(msg, authorKind)) {
+            return;
+        }
         if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
             return;
         }
@@ -668,7 +682,7 @@ export class AgentsHost {
             return null;
         }
         this.recordCollaborationOutcome(msg.channel_id, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
         });
         this.updateMissedCollaborationDiagnostic(msg.channel_id, priorMissedCollaborationDiagnostic);
@@ -1103,7 +1117,7 @@ export class AgentsHost {
         channelState.blocked = undefined;
         this.awaitingUserByChannel.delete(channelId);
         this.recordCollaborationOutcome(channelId, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
             turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1167,7 +1181,7 @@ export class AgentsHost {
         const visibleMessageId = deliveredMessageId ?? protocolState.lastProtocolMessageId;
         if (executed.reply?.controlMalformed) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1177,7 +1191,7 @@ export class AgentsHost {
         }
         if (!executed.reply?.control) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1211,7 +1225,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'start-protocol') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1222,7 +1236,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'attention-only') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1824,19 +1838,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) {
@@ -1936,11 +2005,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) {
@@ -2109,9 +2195,7 @@ export class AgentsHost {
         this.recordCollaborationOutcome(msg.channel_id, {
             responseState: executed.completed && executed.reply?.awaitingUser
                 ? 'blocked'
-                : executed.completed
-                    ? 'responded'
-                    : 'failed',
+                : this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(executed.completed && executed.reply?.awaitingUser
                 ? {
@@ -2202,6 +2286,21 @@ export class AgentsHost {
                 ...(taskThreadCollaborationContract ? { taskThreadCollaborationContract } : {}),
                 ...(collaborationCapabilities ? { collaborationCapabilities } : {}),
                 ...(missedCollaborationDiagnostic ? { missedCollaborationDiagnostic } : {}),
+                ...((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) => {
@@ -2350,6 +2449,65 @@ export class AgentsHost {
                     turnExecutionId: activeTurn.turnExecutionId,
                 });
             }
+            if (error instanceof ProviderTurnCancelledError) {
+                const cancelledReplyText = error.publicReplyText?.trim();
+                if (!silentTurn &&
+                    !deferDelivery &&
+                    typeof cancelledReplyText === 'string' &&
+                    cancelledReplyText.length > 0 &&
+                    this.started &&
+                    !this.controlPlaneClosed) {
+                    reply = { text: cancelledReplyText };
+                    publicReplyText = cancelledReplyText;
+                    visibleReplyBody = this.resolveVisibleTurnBody(activeTurn, reply, publicReplyText);
+                    try {
+                        const posted = await this.borgee.postMessage({
+                            channelId,
+                            body: visibleReplyBody,
+                            replyToId: activeTurn?.delivery?.replyToId,
+                        });
+                        this.logger.debug('posted cancelled turn feedback', {
+                            ...turnContext,
+                            durationMs: Date.now() - turnStartedAt,
+                            replyLength: publicReplyText.length,
+                            delivery: 'post',
+                        });
+                        return {
+                            reply,
+                            deliveredMessageId: posted.messageId,
+                            publicReplyText,
+                            visibleReplyBody,
+                            deliveryState: 'posted',
+                            stale: activeTurn?.superseded === true,
+                            completed: false,
+                            cancelled: true,
+                        };
+                    }
+                    catch (postError) {
+                        this.logger.debugError('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: postError,
+                        });
+                        this.logger.error('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: summarizeError(postError),
+                        });
+                    }
+                }
+                this.logger.debug('cancelled turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                });
+                return {
+                    reply,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'not-delivered',
+                    stale: activeTurn?.superseded === true,
+                    completed: false,
+                    cancelled: true,
+                };
+            }
             this.logger.debugError('failed to generate or send reply', {
                 ...turnContext,
                 error,
@@ -2561,6 +2719,29 @@ export class AgentsHost {
             activeTurn.turnExecutionId = null;
         }
     }
+    async stopTurn(channelId) {
+        const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
+        const aborted = await this.provider.cancelTurn?.(channelId) ?? false;
+        if (!aborted) {
+            return { aborted: false };
+        }
+        if (activeTurn) {
+            this.supersedeActiveTurn(channelId, activeTurn);
+        }
+        else {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'superseded',
+                deliveryState: 'not-delivered',
+            });
+        }
+        return { aborted: true };
+    }
+    responseStateForExecuted(executed) {
+        if (executed.cancelled) {
+            return 'superseded';
+        }
+        return executed.completed ? 'responded' : 'failed';
+    }
     rememberRecentTurn(channelState, activeTurn) {
         if (!activeTurn.turnExecutionId) {
             channelState.recentTurn = undefined;
@@ -2759,6 +2940,34 @@ export class AgentsHost {
             task = null;
         }
         if (task && task.assigneeId === selfAgentId) {
+            const executionLocalDirectory = task.properties?.[TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY];
+            if (typeof executionLocalDirectory !== 'string' || executionLocalDirectory.trim().length === 0) {
+                try {
+                    await this.borgee.postMessage({
+                        channelId: msg.channel_id,
+                        body: TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER,
+                    });
+                }
+                catch (error) {
+                    this.logger.debugError('task local directory reminder post failed', {
+                        channelId: msg.channel_id,
+                        error,
+                    });
+                }
+                return null;
+            }
+            try {
+                await this.borgee.postMessage({
+                    channelId: msg.channel_id,
+                    body: `${TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX} ${executionLocalDirectory}`,
+                });
+            }
+            catch (error) {
+                this.logger.debugError('task local directory notice post failed', {
+                    channelId: msg.channel_id,
+                    error,
+                });
+            }
             if (task.status === 'open') {
                 try {
                     await this.borgee.updateTask({

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

@@ -1,6 +1,7 @@
-import type { ReportTurnActivityInput, TurnActivityReporter } from '../plugin-sdk.js';
+import type { ReportTurnActivityInput, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 export interface ChatControlPlane {
+    onStopTurn?(handler: StopTurnHandler | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -1,7 +1,7 @@
-import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type TurnActivityReporter } from '../plugin-sdk.js';
+import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type StopTurnHandler, 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' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'onStopTurn' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
 type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'pluginId'>;
 /**
@@ -16,6 +16,7 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     private connected;
     private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
+    onStopTurn(handler: StopTurnHandler | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -14,6 +14,9 @@ export class SdkChatControlPlane {
     constructor(baseUrl, apiKey, createClient = createBorgeePlugin, options = {}) {
         this.client = createClient({ baseUrl, apiKey, ...options });
     }
+    onStopTurn(handler) {
+        this.client.onStopTurn(handler);
+    }
     async connect(onMessage) {
         this.unsubscribe = this.client.on('message', (event) => {
             const message = mapInboundToChannelMessage(event);
@@ -46,6 +49,7 @@ export class SdkChatControlPlane {
         this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.client.onStopTurn(undefined);
         await this.client.close();
     }
     async postMessage(input) {

package/dist/compatibility-gates.js

@@ -24,8 +24,10 @@ export const INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV = 'AGENTS_HOST_INTERNAL_CLAUDE_
 export const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
 const VALID_PROVIDER_IMPLEMENTATION_ENTRIES = '"claude:v1", "claude:v2", "copilot:v1", or "copilot:v2"';
 export const DEFAULT_INTERNAL_COMPATIBILITY_GATES = Object.freeze([
+    ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE,
     COLLABORATION_CAPABILITIES_DIAGNOSTICS_COMPATIBILITY_GATE,
     COLLABORATION_OUTCOME_MODEL_COMPATIBILITY_GATE,
+    COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE,
     CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE,
     CONTEXT_INJECTION_COMPATIBILITY_GATE,
     CODEX_PROVIDER_COMPATIBILITY_GATE,

package/dist/config.d.ts

@@ -3,6 +3,7 @@ export declare const MAX_TIMER_DELAY_MINUTES: number;
 export declare const DEFAULT_COPILOT_SESSION_TTL_MINUTES: number;
 export declare const PROVIDER_IDLE_SHUTDOWN_DISABLED_MINUTES = 0;
 export declare const DEFAULT_PROVIDER_IDLE_SHUTDOWN_MINUTES = 10;
+export declare const DEFAULT_ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF = true;
 export declare const DEFAULT_CLAUDE_COMMAND = "claude-agent-acp";
 export declare const LEGACY_CLAUDE_COMMAND = "claude";
 export declare const LEGACY_CLAUDE_ONE_SHOT_ARGS: readonly ["--print", "--permission-mode", "bypassPermissions"];
@@ -13,6 +14,7 @@ export declare function parseArgs(value: string): string[];
 export declare function optionalStringArray(value: unknown, fieldName: string, sourceLabel: string): string[] | undefined;
 export declare function parseCopilotSessionTtlMinutesValue(value: unknown, sourceLabel: string): number;
 export declare function parseProviderIdleShutdownMinutesValue(value: unknown, sourceLabel: string): number;
+export declare function parseBooleanValue(value: unknown, envName: string, sourceLabel: string): boolean;
 export declare function resolveProvider(rawValue: string, sourceLabel: string): ProviderKind;
 export declare function assertProviderCompatibility(provider: ProviderKind, sourceLabel: string, env?: NodeJS.ProcessEnv): void;
 export declare function isLegacyClaudeCompatibilityAlias(command: string, args: string[]): boolean;

package/dist/config.js

@@ -6,6 +6,7 @@ export const MAX_TIMER_DELAY_MINUTES = MAX_TIMER_DELAY_MS / 60_000;
 export const DEFAULT_COPILOT_SESSION_TTL_MINUTES = 2 * 24 * 60;
 export const PROVIDER_IDLE_SHUTDOWN_DISABLED_MINUTES = 0;
 export const DEFAULT_PROVIDER_IDLE_SHUTDOWN_MINUTES = 10;
+export const DEFAULT_ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF = true;
 export const DEFAULT_CLAUDE_COMMAND = 'claude-agent-acp';
 export const LEGACY_CLAUDE_COMMAND = 'claude';
 export const LEGACY_CLAUDE_ONE_SHOT_ARGS = ['--print', '--permission-mode', 'bypassPermissions'];
@@ -18,6 +19,7 @@ export const DEFAULT_PROVIDER_COMMAND_CONFIG = {
     copilotArgs: ['-s', '--no-color', '--allow-all-tools', '--output-format', 'text'],
     copilotSessionTtlMinutes: DEFAULT_COPILOT_SESSION_TTL_MINUTES,
     providerIdleShutdownMinutes: DEFAULT_PROVIDER_IDLE_SHUTDOWN_MINUTES,
+    allowCrossAgentIndependentWorkspaceHandoff: DEFAULT_ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF,
 };
 function requireEnv(name, env) {
     return requireNonEmptyString(env[name], `Missing required environment variable: ${name}`);
@@ -75,6 +77,19 @@ export function parseProviderIdleShutdownMinutesValue(value, sourceLabel) {
     }
     return parsed;
 }
+export function parseBooleanValue(value, envName, sourceLabel) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'true') {
+        return true;
+    }
+    if (normalized === 'false') {
+        return false;
+    }
+    throw new Error(`Invalid ${envName} in ${sourceLabel}: expected true or false`);
+}
 export function resolveProvider(rawValue, sourceLabel) {
     const raw = rawValue.trim().toLowerCase();
     if (raw === 'claude' || raw === 'codex' || raw === 'copilot') {
@@ -134,6 +149,8 @@ export function resolveProviderCommandConfig(overrides = {}) {
         copilotSessionTtlMinutes: overrides.copilotSessionTtlMinutes ?? DEFAULT_PROVIDER_COMMAND_CONFIG.copilotSessionTtlMinutes,
         providerIdleShutdownMinutes: overrides.providerIdleShutdownMinutes
             ?? DEFAULT_PROVIDER_COMMAND_CONFIG.providerIdleShutdownMinutes,
+        allowCrossAgentIndependentWorkspaceHandoff: overrides.allowCrossAgentIndependentWorkspaceHandoff
+            ?? DEFAULT_PROVIDER_COMMAND_CONFIG.allowCrossAgentIndependentWorkspaceHandoff,
     };
 }
 export function loadConfigFromEnv(env = process.env) {
@@ -153,6 +170,10 @@ export function loadConfigFromEnv(env = process.env) {
         providerIdleShutdownMinutes: env.PROVIDER_IDLE_SHUTDOWN_MINUTES && env.PROVIDER_IDLE_SHUTDOWN_MINUTES.trim().length > 0
             ? parseProviderIdleShutdownMinutesValue(env.PROVIDER_IDLE_SHUTDOWN_MINUTES, 'environment variable PROVIDER_IDLE_SHUTDOWN_MINUTES')
             : DEFAULT_PROVIDER_COMMAND_CONFIG.providerIdleShutdownMinutes,
+        allowCrossAgentIndependentWorkspaceHandoff: env.ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF
+            && env.ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF.trim().length > 0
+            ? parseBooleanValue(env.ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF, 'ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF', 'environment variable ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF')
+            : DEFAULT_PROVIDER_COMMAND_CONFIG.allowCrossAgentIndependentWorkspaceHandoff,
     });
     assertProviderCommandCompatibility(provider, providerConfig, 'environment variables');
     return {