@borgee/agents-host 0.2.56 → 0.2.62

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

@@ -125,6 +125,7 @@ export declare class AgentsHost {
     private revalidateAttentionSnapshotForTurn;
     private getAttentionSnapshotForTurn;
     private isHumanWakeFiltered;
+    private isOrdinaryAgentWakeFiltered;
     private applyAttentionUpdate;
     private commitAttentionSnapshot;
     private resolveTaskThreadCollaborationContractForTurn;

package/dist/agents-host.js

@@ -9,13 +9,13 @@ 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 { 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;
@@ -136,6 +136,7 @@ class DefaultHostRuntime {
                     copilotArgs: config.copilotArgs,
                     copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
                     providerIdleShutdownMinutes: config.providerIdleShutdownMinutes,
+                    allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
                 }, deps.logger, {
                     compatibilityGates,
                     authorizationAuditSink: this.authorizationAuditSink,
@@ -461,6 +462,9 @@ export class AgentsHost {
                 const authorKind = await this.classifyAuthor(normalized.authorId, false);
                 await this.ensureAttentionSnapshotLoaded(msg.channel_id, channelState);
                 attentionSnapshot = this.getAttentionSnapshotForTurn(msg.channel_id, taskThreadContext);
+                if (this.isOrdinaryAgentWakeFiltered(msg, authorKind)) {
+                    return;
+                }
                 if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
                     return;
                 }
@@ -553,6 +557,9 @@ export class AgentsHost {
                 }
             }
         }
+        if (this.isOrdinaryAgentWakeFiltered(msg, authorKind)) {
+            return;
+        }
         if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
             return;
         }
@@ -1824,19 +1831,74 @@ export class AgentsHost {
         if (!this.contextInjectionEnabled) {
             return { state: 'inactive' };
         }
+        const recoverFromControlPlane = async (preferredTaskId) => {
+            try {
+                if (preferredTaskId) {
+                    try {
+                        const preferredTask = await this.borgee.getTask({ taskId: preferredTaskId });
+                        if (preferredTask.threadId === channelId) {
+                            return preferredTask.id.trim().length > 0
+                                ? { state: 'recovered', currentTaskId: preferredTask.id }
+                                : { state: 'recovered' };
+                        }
+                    }
+                    catch {
+                        // Fall through to the visibility-based scan.
+                    }
+                }
+                const channels = await this.borgee.listChannels();
+                const currentChannel = channels.find((channel) => channel.id === channelId);
+                if (currentChannel && currentChannel.kind !== 'thread') {
+                    return { state: 'inactive' };
+                }
+                let sawTaskListSuccess = false;
+                let sawTaskListFailure = false;
+                for (const channel of channels) {
+                    let tasks;
+                    try {
+                        tasks = await this.borgee.listTasks({ channelId: channel.id });
+                        sawTaskListSuccess = true;
+                    }
+                    catch {
+                        sawTaskListFailure = true;
+                        continue;
+                    }
+                    for (const task of tasks) {
+                        if (task.threadId === channelId) {
+                            return task.id.trim().length > 0 ? { state: 'recovered', currentTaskId: task.id } : { state: 'recovered' };
+                        }
+                    }
+                }
+                return sawTaskListSuccess && !sawTaskListFailure ? { state: 'inactive' } : { state: 'unavailable' };
+            }
+            catch {
+                return { state: 'unavailable' };
+            }
+        };
         try {
-            const content = await readFile(resolveChannelContextPayloadPath(this.config.stateRootDir, channelId), 'utf8');
+            const content = await readFile(resolveTaskAssignmentStatePath(this.config.stateRootDir, channelId), 'utf8');
             const payload = JSON.parse(content);
             if (payload.taskAssignmentContext?.active !== true) {
-                return { state: 'inactive' };
+                return await recoverFromControlPlane();
             }
             const currentTaskId = typeof payload.taskAssignmentContext.currentTaskId === 'string'
                 ? payload.taskAssignmentContext.currentTaskId.trim()
                 : '';
-            return currentTaskId ? { state: 'active', currentTaskId } : { state: 'active' };
+            if (currentTaskId) {
+                try {
+                    const task = await this.borgee.getTask({ taskId: currentTaskId });
+                    if (task.threadId === channelId) {
+                        return { state: 'active', currentTaskId: task.id };
+                    }
+                }
+                catch {
+                    // Fall through to the recovery scan below.
+                }
+            }
+            return await recoverFromControlPlane(currentTaskId || undefined);
         }
         catch {
-            return { state: 'unavailable' };
+            return await recoverFromControlPlane();
         }
     }
     async ensureAttentionSnapshotLoaded(channelId, channelState) {
@@ -1936,11 +1998,28 @@ export class AgentsHost {
         if (!ORDINARY_HUMAN_EVENT_KINDS.has(eventKind)) {
             return false;
         }
-        if (attentionSnapshot?.wakeMode === 'follow-visible-human') {
+        if (msg.channel_type === 'dm'
+            && attentionSnapshot?.wakeMode !== 'mute-non-mention') {
             return false;
         }
-        this.noteWakeSuppressedAttentionPolicy(msg, authorKind);
-        return true;
+        if (attentionSnapshot?.wakeMode === 'mute-non-mention') {
+            this.noteWakeSuppressedAttentionPolicy(msg, authorKind);
+            return true;
+        }
+        return false;
+    }
+    isOrdinaryAgentWakeFiltered(msg, authorKind) {
+        if (authorKind !== 'agent') {
+            return false;
+        }
+        if (msg.message_type === 'task_assignment') {
+            return false;
+        }
+        if (msg.type?.trim() === 'mention') {
+            return false;
+        }
+        const eventKind = msg.type?.trim() ?? '';
+        return ORDINARY_HUMAN_EVENT_KINDS.has(eventKind);
     }
     applyAttentionUpdate(channelId, baseSnapshot, attentionUpdate, taskThreadContext, options) {
         if (!this.attentionFollowSemanticsEnabled) {
@@ -2202,6 +2281,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) => {

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 {

package/dist/context/injection.d.ts

@@ -49,6 +49,8 @@ export interface ChannelContextStore {
         missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
+        taskAssignmentContextOverride?: TaskAssignmentThreadContext;
+        taskAssignmentContextOverridePersistence?: 'persist' | 'ephemeral';
     }): Promise<PreparedChannelContext>;
     prepare(channelId: string, options?: {
         provider?: ProviderKind;
@@ -62,6 +64,8 @@ export interface ChannelContextStore {
         missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
+        taskAssignmentContextOverride?: TaskAssignmentThreadContext;
+        taskAssignmentContextOverridePersistence?: 'persist' | 'ephemeral';
     }): Promise<PreparedChannelContext>;
 }
 export interface SkillAssetResolver {
@@ -95,7 +99,10 @@ interface ContextFileSystem {
     }): Promise<void>;
     unlink(path: string): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
-    access(path: string): Promise<void>;
+    access(path: string, mode?: number): Promise<void>;
+    stat?(path: string): Promise<{
+        isDirectory(): boolean;
+    }>;
 }
 interface FileChannelContextStoreOptions {
     fileSystem?: ContextFileSystem;
@@ -103,8 +110,10 @@ interface FileChannelContextStoreOptions {
     skillAssetResolver?: SkillAssetResolver;
     localhostGateway?: LocalhostGatewayContextPublisher;
     workspaceCollectionRootDir?: string;
-    taskReader?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
+    taskReader?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks' | 'listUsers'>;
     taskResolutionTimeoutMs?: number;
+    allowCrossAgentIndependentWorkspaceHandoff?: boolean;
+    resolveStableAgentId?: () => string | undefined;
     env?: NodeJS.ProcessEnv;
     resolvedHomeDir?: string;
 }
@@ -117,12 +126,15 @@ export declare function extractTaskIdFromTaskAssignmentContent(incomingContent:
 export declare function encodeChannelPathSegment(channelId: string): string;
 export declare function resolveChannelContextDirectory(stateRootDir: string, channelId: string): string;
 export declare function resolveChannelContextPayloadPath(stateRootDir: string, channelId: string): string;
+export declare function resolveTaskAssignmentStateDirectory(stateRootDir: string, channelId: string): string;
+export declare function resolveTaskAssignmentStatePath(stateRootDir: string, channelId: string): string;
 export declare function resolveTaskWorkspaceRootDirectory(startupWorkspaceRootDir: string): string;
 export declare function resolveManagedWorkspaceCollectionRoot(workspaceCollectionRootDir: string | undefined, env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
 export declare function resolveChannelWorkspaceRootDirectory(workspaceCollectionRootDir: string, channelId: string): string;
 export declare function resolveChannelWorkspaceDirectory(workspaceCollectionRootDir: string, channelId: string): string;
 export declare function resolveTaskIsolatedWorkspaceDirectory(workspaceCollectionRootDir: string, channelId: string, taskId: string): string;
 export declare const resolveTaskWorkspaceDirectory: typeof resolveTaskIsolatedWorkspaceDirectory;
+export declare function resolveTaskThreadScratchWorkspaceDirectory(workspaceCollectionRootDir: string, channelId: string): string;
 export declare function resolveChannelGatewayCredentialPath(stateRootDir: string, channelId: string): string;
 export declare function resolveGatewayCredentialPathFromPayloadPath(payloadPath: string): string;
 export declare function resolveClaudeProjectedBriefPathFromPayloadPath(payloadPath: string): string;
@@ -137,6 +149,8 @@ export declare class FileChannelContextStore implements ChannelContextStore {
     private readonly workspaceCollectionRootDir;
     private readonly taskReader?;
     private readonly taskResolutionTimeoutMs;
+    private readonly allowCrossAgentIndependentWorkspaceHandoff;
+    private readonly resolveStableAgentId?;
     constructor(stateRootDir: string, options?: FileChannelContextStoreOptions);
     prepare(inputOrChannelId: {
         channelId: string;
@@ -151,6 +165,8 @@ export declare class FileChannelContextStore implements ChannelContextStore {
         missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
+        taskAssignmentContextOverride?: TaskAssignmentThreadContext;
+        taskAssignmentContextOverridePersistence?: 'persist' | 'ephemeral';
     } | string, options?: {
         provider?: ProviderKind;
         projectionStrategy?: ProjectionStrategy;
@@ -163,6 +179,8 @@ export declare class FileChannelContextStore implements ChannelContextStore {
         missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
         incomingMessageType?: string;
         incomingContent?: string;
+        taskAssignmentContextOverride?: TaskAssignmentThreadContext;
+        taskAssignmentContextOverridePersistence?: 'persist' | 'ephemeral';
     }): Promise<PreparedChannelContext>;
     private resolveSkillRuntimeBestEffort;
 }