@borgee/agents-host 0.2.44 → 0.2.56

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

@@ -2,6 +2,7 @@ import { Readable, Writable } from 'node:stream';
 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 { resolveCopilotPermissionResponse } from '../../policy/copilot-permission.js';
 import { IDLE_BACKEND_SHUTDOWN_DISABLED_MS, IdleBackendShutdownScheduler, } from '../idle-backend-shutdown.js';
 const SESSION_TAINTED_ERRORS = new WeakSet();
@@ -36,9 +37,6 @@ const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
     resumeSession: false,
 };
-function hasVisibleText(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
 function isAbsoluteHttpUrl(value) {
     return value.startsWith('http://') || value.startsWith('https://');
 }
@@ -61,84 +59,6 @@ function isSameOrigin(left, right) {
 function asImagePart(part) {
     return part.type === 'image' ? part : null;
 }
-function formatToolProgress(title, status) {
-    const normalizedTitle = hasVisibleText(title) ? title.trim() : null;
-    switch (status) {
-        case 'completed':
-            return normalizedTitle ? `Completed ${normalizedTitle}` : 'Completed tool call';
-        case 'failed':
-            return normalizedTitle ? `Failed ${normalizedTitle}` : 'Tool call failed';
-        case 'pending':
-        case 'in_progress':
-        case undefined:
-        case null:
-            return normalizedTitle ? `Running ${normalizedTitle}…` : 'Running tool…';
-        default:
-            return normalizedTitle ? `${status} ${normalizedTitle}` : status;
-    }
-}
-function formatPlanProgress(entries) {
-    const current = entries.find((entry) => entry.status === 'in_progress') ??
-        entries.find((entry) => entry.status === 'pending') ??
-        entries[0];
-    return hasVisibleText(current?.content) ? `Plan: ${current.content.trim()}` : null;
-}
-class CopilotProgressCollector {
-    onProgress;
-    publicText = '';
-    lastPublished = null;
-    toolTitles = new Map();
-    constructor(onProgress) {
-        this.onProgress = onProgress;
-    }
-    consume(update) {
-        switch (update.update.sessionUpdate) {
-            case 'agent_message_chunk':
-                if (update.update.content.type !== 'text') {
-                    return;
-                }
-                this.publicText += update.update.content.text;
-                this.publish(this.publicText);
-                return;
-            case 'tool_call':
-                this.toolTitles.set(update.update.toolCallId, update.update.title);
-                this.publishFallback(formatToolProgress(update.update.title, update.update.status));
-                return;
-            case 'tool_call_update': {
-                const nextTitle = update.update.title ?? this.toolTitles.get(update.update.toolCallId);
-                if (hasVisibleText(nextTitle)) {
-                    this.toolTitles.set(update.update.toolCallId, nextTitle);
-                }
-                this.publishFallback(formatToolProgress(nextTitle, update.update.status));
-                return;
-            }
-            case 'plan':
-                this.publishFallback(formatPlanProgress(update.update.entries.map((entry) => ({
-                    content: entry.content,
-                    status: entry.status,
-                }))));
-                return;
-            default:
-                return;
-        }
-    }
-    getFinalText() {
-        return this.publicText.trim();
-    }
-    publishFallback(text) {
-        if (hasVisibleText(this.publicText)) {
-            return;
-        }
-        this.publish(text);
-    }
-    publish(text) {
-        if (!this.onProgress || !hasVisibleText(text) || text === this.lastPublished) {
-            return;
-        }
-        this.lastPublished = text;
-        this.onProgress({ text });
-    }
-}
 function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
     let settled = false;
     let resolvePromise;
@@ -647,7 +567,7 @@ export class CopilotCliClient {
         }
     }
     async resolveSessionCwd(promptContext) {
-        return promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
+        return promptContext?.resolvedWorkspace?.rootPath ?? this.runtime.cwd;
     }
     async buildPromptInput(turn) {
         const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
@@ -707,7 +627,7 @@ export class CopilotCliClient {
         const promptFailure = new Promise((_, reject) => {
             void promptPromise.catch((error) => reject(markSessionTainted(error)));
         });
-        const collector = new CopilotProgressCollector(options?.onProgress);
+        const collector = new AcpProgressCollector(options?.onProgress);
         for (;;) {
             let update;
             try {

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

@@ -1,5 +1,6 @@
 import type { DebugLogger } from '../debug.js';
 import type { ProviderRuntimeConfig } from '../types.js';
+import type { ChatControlPlane } from '../chat/chat-control-plane.js';
 import { type ProviderAdapter } from './provider-adapter.js';
 import type { LocalhostGatewayContextPublisher } from '../context/injection.js';
 import type { AuthorizationAuditSinkLike } from '../policy/authorization-audit.js';
@@ -7,6 +8,7 @@ interface CreateProviderOptions {
     compatibilityGates?: ReadonlySet<string>;
     localhostGateway?: LocalhostGatewayContextPublisher;
     authorizationAuditSink?: AuthorizationAuditSinkLike;
+    controlPlane?: Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
 }
 export declare function createProvider(config: ProviderRuntimeConfig, debugLogger?: DebugLogger, options?: CreateProviderOptions): ProviderAdapter;
 export {};

package/dist/providers/create-provider.js

@@ -1,7 +1,8 @@
 import { FileChannelContextStore } from '../context/injection.js';
+import { ServerProjectionStrategyResolver } from '../context/projection-strategy.js';
 import { createProviderConnectionsSessionStore } from '../connections-state-store.js';
 import { ProviderTurnPreparer } from '../context/turn-preparation.js';
-import { CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
+import { CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, resolveInternalProjectionStrategy, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
 import { resolveIdleBackendShutdownMs } from './idle-backend-shutdown.js';
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
@@ -52,7 +53,6 @@ class CliBackedProviderV2 {
 }
 class CopilotProviderV2 extends CliBackedProviderV2 {
 }
-const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
 const PROVIDER_V2_COMPATIBILITY_GATES = {
     copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
 };
@@ -131,13 +131,29 @@ export function createProvider(config, debugLogger, options = {}) {
     const channelContextStore = contextInjectionGateEnabled
         ? new FileChannelContextStore(config.stateRootDir, {
             skillRuntimeEnabled: skillRuntimeGateEnabled,
-            taskWorkspaceRootDir: process.env[TASK_WORKSPACE_ROOT_DIR_ENV],
             localhostGateway: skillRuntimeGateEnabled && localhostGatewayGateEnabled
                 ? options.localhostGateway
                 : undefined,
+            taskReader: options.controlPlane,
         })
         : undefined;
-    const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger);
+    const resolveInternalProjection = () => resolveInternalProjectionStrategy();
+    const projectionStrategyResolver = new ServerProjectionStrategyResolver({
+        baseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+        resolveStableAgentId: config.resolveStableAgentId,
+        fallback: resolveInternalProjection,
+        logger: debugLogger,
+        taskReader: options.controlPlane,
+    });
+    const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger, {
+        resolveProjectionStrategy: async (input) => {
+            if (input.provider !== 'claude') {
+                return resolveInternalProjection();
+            }
+            return projectionStrategyResolver.resolve(input.channelId);
+        },
+    });
     switch (config.provider) {
         case 'claude': {
             return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs);

package/dist/state-paths.d.ts

@@ -20,11 +20,11 @@ export declare function resolveManagedDaemonLogPath(rootPath: string): string;
 export declare function resolveManagedRuntimeSettingsPath(rootPath: string): string;
 export declare function resolveManagedBootstrapLockPath(rootPath: string): string;
 export declare function resolveLocalConfigAgentStateRoot(rootPath: string, agentKey: string): string;
-export declare function resolveAgentCursorPath(stateRootDir: string, agentId: string): string;
 export declare function resolveSharedProtocolKickoffDecisionPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
 export declare function resolveSharedProtocolStatusPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
 export declare function resolveConnectionsStatePath(stateRootDir: string): string;
 export declare function resolveAttentionStatePath(stateRootDir: string, channelId: string): string;
+export declare function resolveCompactionStatePath(stateRootDir: string, channelId: string): string;
 export declare function resolveAuthorizationAuditPath(stateRootDir: string): string;
 export declare function resolvePreviousAuthorizationAuditPath(stateRootDir: string): string;
 export declare function resolveClaudeSessionMapPath(stateRootDir: string, agentId: string): string;

package/dist/state-paths.js

@@ -129,9 +129,6 @@ export function resolveManagedBootstrapLockPath(rootPath) {
 export function resolveLocalConfigAgentStateRoot(rootPath, agentKey) {
     return join(resolveManagedStateRoot(rootPath), `${sanitizeStateRootLabel(agentKey)}-${hashStateRootKey(agentKey)}`);
 }
-export function resolveAgentCursorPath(stateRootDir, agentId) {
-    return join(stateRootDir, `bpp-cursor-${encodeSegment(agentId)}.json`);
-}
 export function resolveSharedProtocolKickoffDecisionPath(stateRootDir, channelId, anchorMessageId) {
     return join(dirname(resolve(stateRootDir)), 'protocol-kickoff-decisions', `${encodeSegment(channelId)}--${encodeSegment(anchorMessageId)}.json`);
 }
@@ -144,6 +141,9 @@ export function resolveConnectionsStatePath(stateRootDir) {
 export function resolveAttentionStatePath(stateRootDir, channelId) {
     return join(stateRootDir, 'attention-state', `${encodeSegment(channelId)}.json`);
 }
+export function resolveCompactionStatePath(stateRootDir, channelId) {
+    return join(stateRootDir, 'compaction-state', `${encodeSegment(channelId)}.json`);
+}
 export function resolveAuthorizationAuditPath(stateRootDir) {
     return join(stateRootDir, 'authorization-audit.jsonl');
 }

package/dist/task-thread-resolution.d.ts

@@ -1,10 +1,11 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
 import type { Task } from './types.js';
+type TaskThreadResolutionControlPlane = Pick<ChatControlPlane, 'getTask' | 'listChannels' | 'listTasks'>;
 interface WaitForTaskForThreadOptions {
     preferredTaskId?: string;
     attempts?: number;
     delayMs?: number;
 }
-export declare function findTaskForThread(controlPlane: ChatControlPlane, threadId: string, preferredTaskId?: string): Promise<Task | null>;
-export declare function waitForTaskForThread(controlPlane: ChatControlPlane, threadId: string, options?: WaitForTaskForThreadOptions): Promise<Task | null>;
+export declare function findTaskForThread(controlPlane: TaskThreadResolutionControlPlane, threadId: string, preferredTaskId?: string): Promise<Task | null>;
+export declare function waitForTaskForThread(controlPlane: TaskThreadResolutionControlPlane, threadId: string, options?: WaitForTaskForThreadOptions): Promise<Task | null>;
 export {};

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 export type ProviderKind = 'claude' | 'codex' | 'copilot';
+export type ProjectionStrategy = 'session-brief' | 'turn-full' | 'message-only' | 'turn-thin' | 'file-brief';
 export interface ProviderCommandConfig {
     claudeCommand: string;
     claudeArgs: string[];
@@ -167,7 +168,7 @@ export interface CollaborationDraftSnapshot {
 }
 export type ProviderCollaborationTurnMode = 'ordinary' | 'silent-kickoff' | 'protocol-managed';
 export type CollaborationOutcomeResponseState = 'responded' | 'blocked' | 'superseded' | 'failed';
-export type CollaborationOutcomeDeliveryState = 'posted' | 'draft-finalized' | 'not-delivered' | 'delivery-failed';
+export type CollaborationOutcomeDeliveryState = 'posted' | 'not-delivered' | 'delivery-failed';
 export type CollaborationOutcomeWakeState = 'waiting' | 'suppressed-agent' | 'resumed-human';
 export interface CollaborationOutcomeBlockedDetails {
     question: string;
@@ -211,6 +212,22 @@ export interface AttentionSnapshot {
     turnExecutionId?: string;
     claimContext?: AttentionClaimContext;
 }
+export type ProviderCompactionStage = 'started' | 'completed' | 'failed';
+/**
+ * Shared host-side projection only. This is the latest host-observed compaction
+ * lifecycle snapshot surfaced by a provider adapter; it is not provider- or
+ * model-authoritative truth about retained prompt content.
+ */
+export interface CompactionSnapshot {
+    source: 'host-observed';
+    provider: ProviderKind;
+    stage: ProviderCompactionStage;
+    observedAt: number;
+    turnExecutionId?: string;
+    usedTokens?: number;
+    contextWindowTokens?: number;
+    failureReason?: string;
+}
 export type TaskThreadCollaborationTurnRole = 'assignment' | 'continuation';
 export type TaskThreadMainResultContract = 'ordinary-final-reply-in-thread';
 export type TaskThreadAuxiliaryRouteContract = 'optional-auxiliary-send-or-escalation-only';
@@ -233,6 +250,7 @@ export interface TaskThreadCollaborationContract {
 export interface CollaborationCapabilityDeclaration {
     collaborationOutcome?: true;
     attentionSnapshot?: true;
+    compactionSnapshot?: true;
     taskThreadCollaborationContract?: true;
     missedCollaborationDiagnostic?: true;
     recoveryExplanation?: 'runtime-local-only';
@@ -264,6 +282,7 @@ export interface ProviderInput {
     collaboration?: ProviderCollaborationContext;
     collaborationOutcome?: CollaborationOutcomeSnapshot;
     attentionSnapshot?: AttentionSnapshot;
+    compactionSnapshot?: CompactionSnapshot;
     taskThreadCollaborationContract?: TaskThreadCollaborationContract;
     collaborationCapabilities?: CollaborationCapabilityDeclaration;
     missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
@@ -310,17 +329,52 @@ export interface TaskAssignmentThreadContext {
     active: true;
     currentTaskId?: string;
 }
-export interface TaskWorkspaceContext {
-    currentTaskId: string;
+export interface ChannelResolvedWorkspaceContext {
+    authority: 'channel';
+    owningChannelId: string;
     rootPath: string;
 }
+export interface TaskResolvedWorkspaceContext {
+    authority: 'task';
+    taskId: string;
+    rootPath: string;
+}
+export type ResolvedWorkspaceContext = ChannelResolvedWorkspaceContext | TaskResolvedWorkspaceContext;
+export interface RuntimeSurface {
+    schemaVersion: 1;
+    turnMode: ProviderCollaborationTurnMode;
+    gateway: {
+        available: boolean;
+        readOnlyRoutesAuthorized: boolean;
+        inspectBeforeAnswer: boolean;
+    };
+    task: {
+        currentThread: 'parent-channel' | 'task-assignment-thread';
+        parentChannelTaskCollection: 'available' | 'parent-channel-only';
+        currentTaskShorthand: 'requires-task-id' | 'persisted-current-task' | 'fallback-current-task';
+        currentTaskIdPersisted: boolean;
+        currentTaskFallback: 'disallowed' | 'visible-parent-channel-thread-scan';
+    };
+    collaboration: {
+        participantLookup: 'unavailable' | 'available';
+        draftRead: 'unavailable' | 'available';
+        auxiliarySend: 'unavailable' | 'available';
+    };
+    response: {
+        mainVisibleReply: 'model-visible-reply' | 'host-visible-protocol-reply' | 'no-visible-reply';
+        auxiliaryMessageUsage: 'unavailable' | 'targeted-escalation-only';
+    };
+}
 export interface PreparedPromptContext {
     channelContextPayloadPath?: string;
+    claudeProjectedBriefPath?: string;
+    claudeProjectedBriefHash?: string;
     gatewayCredentialPath?: string;
     collaborationTurnExecutionId?: string;
     collaborationTurnMode?: ProviderCollaborationTurnMode;
     collaborationOutcome?: CollaborationOutcomeSnapshot;
     attentionSnapshot?: AttentionSnapshot;
+    compactionSnapshot?: CompactionSnapshot;
     taskThreadCollaborationContract?: TaskThreadCollaborationContract;
     collaborationCapabilities?: CollaborationCapabilityDeclaration;
     missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
@@ -330,19 +384,25 @@ export interface PreparedPromptContext {
     skillRuntime?: SkillRuntimeBootstrapMetadata;
     localhostGateway?: LocalhostGatewayBootstrapMetadata;
     taskAssignmentContext?: TaskAssignmentThreadContext;
-    taskWorkspace?: TaskWorkspaceContext;
+    resolvedWorkspace?: ResolvedWorkspaceContext;
+    runtimeSurface?: RuntimeSurface;
 }
 export interface PreparedProviderSessionRouting {
     key: string;
     persistence: 'persistent' | 'ephemeral';
 }
 export interface PreparedProviderTurnInput {
+    agentName?: string;
     channelId: string;
     incomingContent: string;
     incomingParts: HostedTurnContentPart[];
     incomingEventKind?: string;
     incomingMessageType?: string;
     prompt: string;
+    /** Claude-only session append content for ACP systemPrompt.append. */
+    claudeSessionPromptAppend?: string;
+    /** Shared projection-strategy selector used for provider prompt/session experiments. */
+    projectionStrategy?: ProjectionStrategy;
     promptContext?: PreparedPromptContext;
     providerSessionRouting?: PreparedProviderSessionRouting;
 }
@@ -417,9 +477,73 @@ export interface UpdateTaskInput {
     title?: string;
     description?: string;
 }
-export interface ProviderProgressUpdate {
-    text: string;
+/** The protocol's ten tool kinds, treated as open: an unknown value is not an error. */
+export type ProgressActivityKind = 'read' | 'edit' | 'delete' | 'move' | 'search' | 'execute' | 'think' | 'fetch' | 'switch_mode' | 'other';
+/** The protocol's four statuses, plus the one it lacks: stopped, waiting on a human. */
+export type ProgressActivityStatus = 'pending' | 'in_progress' | 'waiting' | 'completed' | 'failed';
+/**
+ * One entry in an agent's timeline of work. Identity is minted by the producer:
+ * a producer that can correlate later progress to an earlier event reuses the
+ * id and the entry is patched in place; one that cannot mints a fresh id and
+ * entries accumulate. An absent field means unchanged; `paths` replaces.
+ */
+export interface ProgressActivity {
+    id: string;
+    /** The protocol's title. For a shell tool this is the raw command line. */
+    label?: string;
+    /** The provider's human-readable phrasing, when it offers one. */
+    description?: string;
+    kind?: ProgressActivityKind;
+    status?: ProgressActivityStatus;
+    /** Bounded one-line detail: the command, the file, the query. Never raw output. */
+    detail?: string;
+    /** Files this activity touched. Replaces the previous list. */
+    paths?: string[];
+    /** The activity that spawned this one. */
+    parentId?: string;
+    /**
+     * Whether this activity is a container for other work rather than work of its
+     * own. A reader nests under it, and cannot arrive at that by noticing it has
+     * children: a sub-agent's children can be reported before it is, and a
+     * sub-agent that has spawned nothing yet is still a sub-agent.
+     */
+    subagent?: boolean;
+    /** Why a terminal activity ended as it did. An open set upstream, so never an enum. */
+    reason?: string;
 }
+/** Plan entries have no identity: the whole list is replaced on every update. */
+export interface ProgressPlanItem {
+    label: string;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface ProviderCompactionProgress {
+    provider: ProviderKind;
+    stage: ProviderCompactionStage;
+    usedTokens?: number;
+    contextWindowTokens?: number;
+    failureReason?: string;
+}
+/**
+ * A plan, a tool call and a stream of text are three meanings with three
+ * cardinalities and three update rules, so they travel as three shapes rather
+ * than as one entry with a category field. Text is cumulative rather than a
+ * delta, so a consumer that misses one update recovers on the next.
+ */
+export type ProviderProgressUpdate = {
+    type: 'text';
+    stream: 'answer' | 'reasoning';
+    text: string;
+    messageId?: string;
+} | {
+    type: 'activity';
+    activity: ProgressActivity;
+} | {
+    type: 'plan';
+    items: ProgressPlanItem[];
+} | {
+    type: 'compaction';
+    compaction: ProviderCompactionProgress;
+};
 export interface ProviderGenerateOptions {
     onProgress?: (update: ProviderProgressUpdate) => void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.44",
+  "version": "0.2.56",
   "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.4.0"
+    "@borgee/plugin-sdk": "0.10.0"
   },
   "scripts": {
     "predev": "pnpm --filter @borgee/plugin-sdk build",

package/skills/borgee-agent/SKILL.md

@@ -11,6 +11,14 @@ This turn is running as an agent inside a Borgee channel. The packaged CLI is th
 
 Every command below is already authorized on a turn whose prompt names a gateway credential file. Run it directly. Never ask the user for permission first, and never end a turn having asked to read instead of reading.
 
+## Session contract
+
+This session is the coordination surface for the work that belongs to this Borgee thread: read the channel, answer the human here, break the work down, and keep task state current here.
+
+Delegate the heavy execution to workers rather than running everything inline in this session. Research, code edits, long builds and test runs, and broad repository sweeps belong in delegated workers so a newly arriving message can still be handled promptly here.
+
+Delegation changes who executes, not who owns. The work still belongs to this thread, and this session still reports the result here itself.
+
 ## When to use it
 
 - You are asked what was said here, who is here, or what you are supposed to be working on: read it, do not guess.
@@ -56,7 +64,7 @@ Everything below writes that leading interpreter and script path as `borgee-agen
 
 On `task get`, `task update`, `task set-property` and `task delete-property` the task id is an optional leading positional. Inside a task thread, omitting it addresses this thread's own task: the host's published binding names it, and where the host published none the gateway scans the parent channel's visible tasks for this thread instead — so pass the id explicitly when that scan cannot land on a single task. `task list` and `task create` are refused inside a task thread; they belong to the parent channel. In a parent channel every one of those ids is required, and omitting it answers `not_found`.
 
-The keys `task set-property` and `task delete-property` accept are a closed set, and a value has a size limit: see `references/task-properties.md`.
+The keys `task set-property` and `task delete-property` accept are a closed set, and a value has a size limit: see `references/task-properties.md`. In this slice, `workspace.mode` is the formal task-workspace switch: `inherit` keeps a task thread on its channel workspace, while `isolated` moves that task thread onto its own task workspace.
 
 ## What is available on a turn
 

package/skills/borgee-agent/references/task-properties.md

@@ -1,12 +1,14 @@
 # Task properties
 
-A task property associates a task with something that lives outside it. Use one to record what a reader would otherwise have to hunt for in the thread — the pull request that implements the task, the issue it came from.
+A task property associates a task with something that lives outside it, or with a closed task-level runtime choice. Use one to record what a reader would otherwise have to hunt for in the thread — the pull request that implements the task, the issue it came from, or the task workspace mode it should run with.
 
 Read them back with `task get`: every task response carries a `properties` object, `{}` when the task has none.
 
 ```
 borgee-agent --gateway <path> task set-property <task-id> --key link.pr --value https://github.com/org/repo/pull/12
 borgee-agent --gateway <path> task delete-property <task-id> --key link.pr
+borgee-agent --gateway <path> task set-property <task-id> --key workspace.mode --value isolated
+borgee-agent --gateway <path> task delete-property <task-id> --key workspace.mode
 ```
 
 The task id is omitted only inside that task's own thread, where the request resolves to the thread's task.
@@ -19,6 +21,7 @@ The key set is closed; writing an unregistered key is rejected with `unknown_pro
 | --- | --- |
 | `link.pr` | The pull request that implements this task. Set it as soon as the PR exists, not at the end. |
 | `link.issue` | The issue or ticket the task originates from. |
+| `workspace.mode` | The task workspace binding for task threads. `inherit` keeps the task on its channel workspace. `isolated` switches it to its task-isolated workspace. Deleting the key returns to the default `inherit` behavior. |
 | `agent.session_id` | Do not write this. It is registered, so a write is accepted and lands — overwriting the host's record of which provider session worked this task. The host writes it itself after each turn. |
 
 ## One key per call
@@ -27,4 +30,4 @@ Each call writes exactly one key, and that is what makes it safe to write a prop
 
 ## Value
 
-A value is a plain string of at most 8 KiB; a longer one is rejected with `property_value_too_long`. It is a reference — a URL, an identifier — never a document.
+A value is a plain string of at most 8 KiB; a longer one is rejected with `property_value_too_long`. It is a reference — a URL, an identifier — never a document. Some registered keys are closed enums: `workspace.mode` accepts only `inherit` or `isolated`.

package/dist/durable-cursor-store.d.ts

@@ -1,5 +0,0 @@
-import { type CursorStore } from './plugin-sdk.js';
-export interface DurableCursorStoreOptions {
-    stateRootDir: string;
-}
-export declare function createDurableCursorStore(options: DurableCursorStoreOptions): CursorStore;

package/dist/durable-cursor-store.js

@@ -1,7 +0,0 @@
-import { FileCursorStore } from './plugin-sdk.js';
-import { resolveAgentCursorPath } from './state-paths.js';
-export function createDurableCursorStore(options) {
-    return new FileCursorStore({
-        resolvePath: (agentId) => resolveAgentCursorPath(options.stateRootDir, agentId),
-    });
-}