@borgee/agents-host 0.2.56 → 0.2.65

package/dist/policy/copilot-permission.d.ts

@@ -10,6 +10,7 @@ export interface CopilotPermissionPolicyContext {
     auditSink?: AuthorizationAuditSinkLike;
     agentId?: string;
     channelId?: string;
+    toolPermissionMode?: 'default' | 'deny-all';
 }
 export declare function resolveCopilotPermissionResponse(context: CopilotPermissionPolicyContext): RequestPermissionResponse;
 export declare function createLegacyMissingAllowOptionError(): Error;

package/dist/policy/copilot-permission.js

@@ -84,6 +84,24 @@ function appendAuditRecord(context, effectiveDecision, reason, policyDecision) {
     });
 }
 export function resolveCopilotPermissionResponse(context) {
+    if (context.toolPermissionMode === 'deny-all') {
+        const rejectOption = resolveRejectOption(context.params.options);
+        const deniedDecision = rejectOption
+            ? {
+                outcome: 'selected',
+                optionId: rejectOption.optionId,
+                optionKind: rejectOption.kind,
+                reason: 'discussion-only-task-thread',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            }
+            : {
+                outcome: 'cancelled',
+                reason: 'discussion-only-task-thread',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            };
+        appendAuditRecord(context, deniedDecision, deniedDecision.reason, deniedDecision);
+        return decisionToResponse(deniedDecision);
+    }
     if (!context.gateEnabled) {
         const legacyOption = legacySelectPermissionOption(context.params.options);
         return {

package/dist/policy/gateway-authorization.js

@@ -33,7 +33,7 @@ function decodePathSegment(segment) {
 export function matchChannelRoute(pathname, allowCollaborationRoutes = false) {
     const resources = allowCollaborationRoutes
         ? '(bootstrap|me|history|draft|users|messages|tasks|current-task)'
-        : '(bootstrap|me|history|tasks|current-task)';
+        : '(bootstrap|me|history|users|tasks|current-task)';
     const match = new RegExp(`^/v1/channels/([^/]+)/${resources}$`).exec(pathname);
     if (!match) {
         return null;
@@ -112,7 +112,7 @@ function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
 export function evaluateGatewayAuthorization(input) {
     const url = new URL(input.request.url ?? '/', input.baseUrl);
     const hiddenCollaborationRoute = !input.allowCollaborationRoutes
-        && ['draft', 'users', 'messages'].includes(matchChannelRoute(url.pathname, true)?.resource ?? '');
+        && ['draft', 'messages'].includes(matchChannelRoute(url.pathname, true)?.resource ?? '');
     if (hasVisibleHeader(input.request.headers.origin)) {
         return {
             reason: 'browser-origin-not-allowed',

package/dist/providers/claude/adapter.d.ts

@@ -9,5 +9,6 @@ export declare class ClaudeProviderAdapter implements ProviderAdapter {
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -25,6 +25,9 @@ export class ClaudeProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

package/dist/providers/claude/cli-client.d.ts

@@ -43,6 +43,7 @@ export declare class ClaudeCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
@@ -93,7 +94,7 @@ export declare class ClaudeCliClient {
     private invalidateSession;
     private closeSession;
     private rejectQueuedTurnsAfterSessionTaint;
-    private findChannelIdBySessionId;
+    private findChannelStateBySessionId;
     private currentSessionStoreAgentId;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;

package/dist/providers/claude/cli-client.js

@@ -1,5 +1,6 @@
 import { Readable, Writable } from 'node:stream';
 import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, resolve } from 'node:path';
 import spawn from 'cross-spawn';
@@ -8,9 +9,11 @@ import { assertClaudeCommandCompatibility, DEFAULT_CLAUDE_COMMAND, isLegacyClaud
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { readClaudeActivityMetadata } from './activity-metadata.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { buildClaudeSessionPromptAppend } from '../../context/prompt.js';
+import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const IDLE_BACKEND_STOPPED_MESSAGE = 'Claude ACP backend stopped after idle timeout';
@@ -30,6 +33,7 @@ const DEFAULT_SESSION_CAPABILITIES = {
 };
 const CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD_ENV = 'CLAUDE_SDK_COMPACTION_EXPERIMENT_CONTEXT_TOKEN_THRESHOLD';
 const require = createRequire(import.meta.url);
+const CLAUDE_CANCELLED_REPLY_TEXT = 'Info: Operation cancelled by user';
 const DEFAULT_RUNTIME = {
     spawn,
     client,
@@ -386,6 +390,22 @@ function hashSessionAppend(systemPromptAppend) {
     }
     return createHash('sha256').update(systemPromptAppend).digest('hex');
 }
+function resolveSkillManualContentHash(promptContext) {
+    const skillMarkdownPath = promptContext?.skillRuntime?.skillMarkdownPath;
+    if (!skillMarkdownPath) {
+        return undefined;
+    }
+    try {
+        return createHash('sha256')
+            .update(skillMarkdownPath)
+            .update('\0')
+            .update(readFileSync(skillMarkdownPath))
+            .digest('hex');
+    }
+    catch {
+        return `unreadable:${skillMarkdownPath}`;
+    }
+}
 function resolveSessionVisibilityKey(promptContext, systemPromptAppend, promptStrategy) {
     const resolvedPromptStrategy = resolveProjectionStrategy(promptStrategy);
     const explicitPromptStrategy = resolvedPromptStrategy === DEFAULT_PROJECTION_STRATEGY && promptStrategy == null
@@ -395,9 +415,11 @@ function resolveSessionVisibilityKey(promptContext, systemPromptAppend, promptSt
             : resolvedPromptStrategy;
     const additionalDirectories = resolveSessionAdditionalDirectories(promptContext);
     const sessionAppendHash = hashSessionAppend(systemPromptAppend);
+    const skillManualContentHash = resolveSkillManualContentHash(promptContext);
     const projectedBriefHash = promptContext?.claudeProjectedBriefHash;
     if (!additionalDirectories
         && !sessionAppendHash
+        && !skillManualContentHash
         && !projectedBriefHash
         && !promptContext?.gatewayCredentialPath
         && !explicitPromptStrategy) {
@@ -407,12 +429,14 @@ function resolveSessionVisibilityKey(promptContext, systemPromptAppend, promptSt
         return JSON.stringify({
             ...(additionalDirectories ? { additionalDirectories } : {}),
             sessionAppendHash,
+            ...(skillManualContentHash ? { skillManualContentHash } : {}),
             ...(projectedBriefHash ? { projectedBriefHash } : {}),
             ...(explicitPromptStrategy ? { promptStrategy: explicitPromptStrategy } : {}),
         });
     }
     return JSON.stringify({
         ...(additionalDirectories ? { additionalDirectories } : {}),
+        ...(skillManualContentHash ? { skillManualContentHash } : {}),
         ...(promptContext?.gatewayCredentialPath
             ? { gatewayCredentialPath: promptContext.gatewayCredentialPath }
             : {}),
@@ -473,6 +497,22 @@ export class ClaudeCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -721,6 +761,9 @@ export class ClaudeCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = this.resolveSessionCwd(turn.preparedTurn.promptContext);
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                            ? 'deny-all'
+                            : 'default';
                         const sessionPromptAppend = resolveTurnSessionPromptAppend(turn.preparedTurn);
                         state.visibilityKey = resolveSessionVisibilityKey(turn.preparedTurn.promptContext, sessionPromptAppend, turn.preparedTurn.projectionStrategy);
                         await this.ensureStarted();
@@ -950,6 +993,11 @@ export class ClaudeCliClient {
                     throw markSessionTainted(error);
                 }
                 const output = collector.getFinalText();
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Claude ACP turn cancelled', {
+                        publicReplyText: hasVisibleText(output) ? output : CLAUDE_CANCELLED_REPLY_TEXT,
+                    });
+                }
                 if (response.stopReason !== 'end_turn' && !hasVisibleText(output)) {
                     throw new Error(`Claude ACP turn stopped with stopReason "${response.stopReason}"`);
                 }
@@ -999,13 +1047,15 @@ export class ClaudeCliClient {
         this.shutdownPromise = this.shutdownBackend(error);
     }
     handlePermissionRequest(params) {
+        const state = this.findChannelStateBySessionId(params.sessionId);
         return resolveCopilotPermissionResponse({
             gateEnabled: true,
             policyMode: 'enforce',
             params,
             logger: this.logger,
             agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
-            channelId: this.findChannelIdBySessionId(params.sessionId),
+            channelId: state?.channelId,
+            toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }
     invalidateSession(channelId, state, session) {
@@ -1057,10 +1107,10 @@ export class ClaudeCliClient {
         }
         state.queue.length = 0;
     }
-    findChannelIdBySessionId(sessionId) {
+    findChannelStateBySessionId(sessionId) {
         for (const state of this.channels.values()) {
             if (state.session?.sessionId === sessionId) {
-                return state.channelId;
+                return state;
             }
         }
         return undefined;

package/dist/providers/codex/adapter.d.ts

@@ -9,5 +9,6 @@ export declare class CodexProviderAdapter implements ProviderAdapter {
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: CodexCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/codex/adapter.js

@@ -25,6 +25,9 @@ export class CodexProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

package/dist/providers/codex/cli-client.d.ts

@@ -49,6 +49,7 @@ export declare class CodexCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
@@ -108,6 +109,8 @@ export declare class CodexCliClient {
     private failAll;
     private closeSession;
     private clearIdleTimer;
+    private handlePermissionRequest;
+    private findChannelStateBySessionId;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;

package/dist/providers/codex/cli-client.js

@@ -6,8 +6,11 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { assertCodexProjectDocumentSize, buildCodexProjectDocument } from './project-doc.js';
 import { isGatewayCredentialSidecarBasename } from '../../context/injection.js';
+import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
+import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
@@ -32,6 +35,7 @@ const CODEX_CONTEXT_ROOT_DIRNAME = 'codex-context';
 const PROJECTION_UNAVAILABLE_PLACEHOLDER = '[codex-projection-unavailable]';
 const QUEUED_TURN_DROPPED_MESSAGE = 'Codex ACP session was reset after a failed turn; queued turns were dropped instead of replaying them on a fresh session';
 const require = createRequire(import.meta.url);
+const CODEX_CANCELLED_REPLY_TEXT = 'Info: Operation cancelled by user';
 const DEFAULT_RUNTIME = {
     spawn,
     client,
@@ -193,26 +197,6 @@ function markSessionTainted(error) {
 function isSessionTainted(error) {
     return error instanceof Error && SESSION_TAINTED_ERRORS.has(error);
 }
-function createPermissionResponse(params) {
-    const options = Array.isArray(params.options) ? params.options : [];
-    const preferredKinds = ['allow_once', 'allow_always', 'reject_once', 'reject_always'];
-    for (const kind of preferredKinds) {
-        const match = options.find((option) => option.kind === kind);
-        if (match) {
-            return {
-                outcome: {
-                    outcome: 'selected',
-                    optionId: match.optionId,
-                },
-            };
-        }
-    }
-    return {
-        outcome: {
-            outcome: 'cancelled',
-        },
-    };
-}
 function resolveBundledCodexAdapterPath() {
     return require.resolve('@agentclientprotocol/codex-acp');
 }
@@ -248,6 +232,23 @@ export class CodexCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.clearIdleTimer(state);
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -423,7 +424,7 @@ export class CodexCliClient {
         const stream = this.runtime.ndJsonStream(output, input);
         const app = this.runtime
             .client({ name: 'borgee-agents-host' })
-            .onRequest(this.runtime.methods.client.session.requestPermission, ({ params }) => (createPermissionResponse(params)));
+            .onRequest(this.runtime.methods.client.session.requestPermission, ({ params }) => (this.handlePermissionRequest(params)));
         const connection = app.connect(stream);
         this.connection = connection;
         void connection.closed.then(() => {
@@ -487,6 +488,9 @@ export class CodexCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                            ? 'deny-all'
+                            : 'default';
                         const projectedPromptContext = await this.refreshProjectedPromptContextBestEffort(turn.channelId, turn.preparedTurn.promptContext);
                         state.additionalDirectories = this.resolveSessionAdditionalDirectories(projectedPromptContext);
                         state.visibilityKey = this.resolveSessionVisibilityKey(projectedPromptContext);
@@ -846,10 +850,15 @@ export class CodexCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                const output = collector.getFinalText();
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Codex ACP turn cancelled', {
+                        publicReplyText: output || CODEX_CANCELLED_REPLY_TEXT,
+                    });
+                }
                 if (response.stopReason !== 'end_turn') {
                     throw new Error(`Codex ACP turn stopped with stopReason "${response.stopReason}"`);
                 }
-                const output = collector.getFinalText();
                 if (!output) {
                     throw new Error('Codex ACP returned empty output');
                 }
@@ -953,6 +962,25 @@ export class CodexCliClient {
         clearTimeout(state.idleTimer);
         state.idleTimer = undefined;
     }
+    handlePermissionRequest(params) {
+        const state = this.findChannelStateBySessionId(params.sessionId);
+        return resolveCopilotPermissionResponse({
+            gateEnabled: true,
+            policyMode: 'enforce',
+            params,
+            logger: this.logger,
+            channelId: state?.channelId,
+            toolPermissionMode: state?.toolPermissionMode ?? 'default',
+        });
+    }
+    findChannelStateBySessionId(sessionId) {
+        for (const state of this.channels.values()) {
+            if (state.session?.sessionId === sessionId) {
+                return state;
+            }
+        }
+        return undefined;
+    }
     reconcileIdleChannelState(channelId, state) {
         if (this.channels.get(channelId) !== state) {
             return;

package/dist/providers/copilot/adapter.d.ts

@@ -9,5 +9,6 @@ export declare class CopilotProviderAdapter implements ProviderAdapter {
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;
 }

package/dist/providers/copilot/adapter.js

@@ -25,6 +25,9 @@ export class CopilotProviderAdapter {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async dispose() {
         await this.cli.dispose();
     }

package/dist/providers/copilot/cli-client.d.ts

@@ -51,6 +51,7 @@ export declare class CopilotCliClient {
      * worked a task without the agent being asked to report its own id.
      */
     sessionIdForChannel(channelId: string): string | undefined;
+    cancelTurn(channelId: string): Promise<boolean>;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
@@ -103,7 +104,7 @@ export declare class CopilotCliClient {
     private closeSession;
     private rejectQueuedTurnsAfterSessionTaint;
     private clearIdleTimer;
-    private findChannelIdBySessionId;
+    private findChannelStateBySessionId;
     private reconcileIdleChannelState;
     private ensureSessionStoreLoaded;
     private readPersistedSessionId;

package/dist/providers/copilot/cli-client.js

@@ -3,7 +3,9 @@ import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream, } from '@agentclientprotocol/sdk';
 import { HostLogger, summarizeChildStderr, summarizeError } from '../../debug.js';
 import { AcpProgressCollector } from '../acp-progress-collector.js';
+import { ProviderTurnCancelledError } from '../provider-adapter.js';
 import { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
+import { isDiscussionOnlyResolvedWorkspace } from '../../context/resolved-workspace.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
 const DEFAULT_IDLE_SESSION_TTL_MS = 2 * 24 * 60 * 60 * 1000;
@@ -169,6 +171,23 @@ export class CopilotCliClient {
     sessionIdForChannel(channelId) {
         return this.channels.get(channelId)?.session?.sessionId;
     }
+    async cancelTurn(channelId) {
+        const state = this.channels.get(channelId);
+        const session = state?.session;
+        if (!state?.activeTurn || !session) {
+            return false;
+        }
+        this.clearIdleTimer(state);
+        this.idleBackendShutdown.cancel();
+        const activeSession = session;
+        if (typeof activeSession.cancel === 'function') {
+            await activeSession.cancel({ sessionId: session.sessionId });
+            return true;
+        }
+        const cancelMethod = this.runtime.methods.agent.session?.cancel ?? 'session/cancel';
+        await this.connection?.agent.notify(cancelMethod, { sessionId: session.sessionId });
+        return true;
+    }
     persistedSessions = new Map();
     closingSessions = new WeakSet();
     pendingSessionStarts = new Set();
@@ -407,6 +426,9 @@ export class CopilotCliClient {
                     state.activeTurn = turn;
                     try {
                         state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
+                        state.toolPermissionMode = isDiscussionOnlyResolvedWorkspace(turn.preparedTurn.promptContext)
+                            ? 'deny-all'
+                            : 'default';
                         await this.ensureStarted();
                         await this.recycleSessionIfCwdChanged(channelId, state);
                         const session = await this.getOrCreateSession(channelId, state);
@@ -647,6 +669,9 @@ export class CopilotCliClient {
                 catch (error) {
                     throw markSessionTainted(error);
                 }
+                if (response.stopReason === 'cancelled') {
+                    throw new ProviderTurnCancelledError('Copilot ACP turn cancelled');
+                }
                 if (response.stopReason !== 'end_turn') {
                     throw new Error(`Copilot ACP turn stopped with stopReason "${response.stopReason}"`);
                 }
@@ -666,6 +691,7 @@ export class CopilotCliClient {
         return Promise.race([promise, this.fatalPromise]);
     }
     handlePermissionRequest(params) {
+        const state = this.findChannelStateBySessionId(params.sessionId);
         return resolveCopilotPermissionResponse({
             gateEnabled: this.permissionPolicy.gateEnabled ?? false,
             policyMode: this.permissionPolicy.policyMode ?? 'audit-only',
@@ -673,7 +699,8 @@ export class CopilotCliClient {
             logger: this.logger,
             auditSink: this.permissionPolicy.auditSink,
             agentId: this.resolveSessionStoreAgentId()?.trim() || undefined,
-            channelId: this.findChannelIdBySessionId(params.sessionId),
+            channelId: state?.channelId,
+            toolPermissionMode: state?.toolPermissionMode ?? 'default',
         });
     }
     failAll(error) {
@@ -761,10 +788,10 @@ export class CopilotCliClient {
         clearTimeout(state.idleTimer);
         state.idleTimer = undefined;
     }
-    findChannelIdBySessionId(sessionId) {
+    findChannelStateBySessionId(sessionId) {
         for (const state of this.channels.values()) {
             if (state.session?.sessionId === sessionId) {
-                return state.channelId;
+                return state;
             }
         }
         return undefined;

package/dist/providers/create-provider.d.ts

@@ -8,7 +8,7 @@ interface CreateProviderOptions {
     compatibilityGates?: ReadonlySet<string>;
     localhostGateway?: LocalhostGatewayContextPublisher;
     authorizationAuditSink?: AuthorizationAuditSinkLike;
-    controlPlane?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
+    controlPlane?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks' | 'listUsers'>;
 }
 export declare function createProvider(config: ProviderRuntimeConfig, debugLogger?: DebugLogger, options?: CreateProviderOptions): ProviderAdapter;
 export {};

package/dist/providers/create-provider.js

@@ -30,6 +30,9 @@ class ProviderV2CompatibilityAdapter {
             turn: preparedTurn,
         }, options);
     }
+    async cancelTurn(channelId) {
+        return this.provider.cancelTurn?.(channelId) ?? false;
+    }
     async dispose() {
         await this.provider.shutdown?.();
     }
@@ -47,6 +50,9 @@ class CliBackedProviderV2 {
         // session as it runs, so before this point there is nothing to report.
         return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.turn.channelId) };
     }
+    async cancelTurn(channelId) {
+        return this.cli.cancelTurn(channelId);
+    }
     async shutdown() {
         await this.cli.dispose();
     }
@@ -135,6 +141,8 @@ export function createProvider(config, debugLogger, options = {}) {
                 ? options.localhostGateway
                 : undefined,
             taskReader: options.controlPlane,
+            allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
+            resolveStableAgentId: config.resolveStableAgentId,
         })
         : undefined;
     const resolveInternalProjection = () => resolveInternalProjectionStrategy();

package/dist/providers/provider-adapter.d.ts

@@ -33,8 +33,15 @@ export declare function createHostedProviderCapabilities(params: {
     sharedHostFallback?: SharedHostAttachmentMetadataFallbackCapability;
 }): ProviderCapabilities;
 export declare const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES: ProviderCapabilities;
+export declare class ProviderTurnCancelledError extends Error {
+    readonly publicReplyText?: string;
+    constructor(message?: string, options?: {
+        publicReplyText?: string;
+    });
+}
 export interface ProviderAdapter {
     readonly capabilities: ProviderCapabilities;
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
+    cancelTurn?(channelId: string): Promise<boolean>;
     dispose?(): Promise<void>;
 }

package/dist/providers/provider-adapter.js

@@ -42,3 +42,11 @@ export const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabi
         delivery: [],
     },
 });
+export class ProviderTurnCancelledError extends Error {
+    publicReplyText;
+    constructor(message = 'provider turn cancelled', options) {
+        super(message);
+        this.name = 'ProviderTurnCancelledError';
+        this.publicReplyText = options?.publicReplyText;
+    }
+}

package/dist/types.d.ts

@@ -10,6 +10,12 @@ export interface ProviderCommandConfig {
     copilotSessionTtlMinutes: number;
     /** Minutes a provider's shared ACP adapter process may stay idle before it is shut down; `0` keeps it resident. */
     providerIdleShutdownMinutes: number;
+    /**
+     * Whether this agents-host may let a hosted agent enter an independent
+     * execution.local_directory workspace for a task thread created by another
+     * agent. Undefined keeps the default allow behavior.
+     */
+    allowCrossAgentIndependentWorkspaceHandoff?: boolean;
 }
 export interface ProviderRuntimeConfig extends ProviderCommandConfig {
     provider: ProviderKind;
@@ -286,6 +292,8 @@ export interface ProviderInput {
     taskThreadCollaborationContract?: TaskThreadCollaborationContract;
     collaborationCapabilities?: CollaborationCapabilityDeclaration;
     missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+    taskAssignmentContextOverride?: TaskAssignmentThreadContext;
+    taskAssignmentContextOverridePersistence?: 'persist' | 'ephemeral';
 }
 export interface ProviderProtocolContext {
     anchorMessageId: string;
@@ -334,12 +342,17 @@ export interface ChannelResolvedWorkspaceContext {
     owningChannelId: string;
     rootPath: string;
 }
-export interface TaskResolvedWorkspaceContext {
-    authority: 'task';
+export interface TaskThreadScratchWorkspaceContext {
+    authority: 'task-thread-scratch';
+    rootPath: string;
+    reason?: 'missing-or-invalid-execution-target' | 'cross-agent-independent-workspace-disabled';
+}
+export interface TaskExecutionTargetResolvedWorkspaceContext {
+    authority: 'task-execution-target';
     taskId: string;
     rootPath: string;
 }
-export type ResolvedWorkspaceContext = ChannelResolvedWorkspaceContext | TaskResolvedWorkspaceContext;
+export type ResolvedWorkspaceContext = ChannelResolvedWorkspaceContext | TaskThreadScratchWorkspaceContext | TaskExecutionTargetResolvedWorkspaceContext;
 export interface RuntimeSurface {
     schemaVersion: 1;
     turnMode: ProviderCollaborationTurnMode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.56",
+  "version": "0.2.65",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
     "tsx": "^4.20.5",
     "typescript": "^5.9.3",
     "vitest": "^4.1.5",
-    "@borgee/plugin-sdk": "0.10.0"
+    "@borgee/plugin-sdk": "0.12.0"
   },
   "scripts": {
     "predev": "pnpm --filter @borgee/plugin-sdk build",