@borgee/agents-host 0.2.56 → 0.2.65

package/dist/context/resolved-workspace.js

@@ -3,8 +3,11 @@ function buildWorkspaceRootLine(context) {
     if (!resolvedWorkspace) {
         return undefined;
     }
-    if (resolvedWorkspace.authority === 'task') {
-        return `Writable task-isolated workspace root for this task thread: ${resolvedWorkspace.rootPath}.`;
+    if (resolvedWorkspace.authority === 'task-execution-target') {
+        return `Explicit execution local directory for this task thread: ${resolvedWorkspace.rootPath}.`;
+    }
+    if (resolvedWorkspace.authority === 'task-thread-scratch') {
+        return `Discussion-only scratch workspace for this task thread: ${resolvedWorkspace.rootPath}.`;
     }
     if (context.taskAssignmentContext?.active === true) {
         return `Writable workspace root inherited from this task thread's channel: ${resolvedWorkspace.rootPath}.`;
@@ -15,8 +18,13 @@ function buildWorkspaceModeLine(context) {
     if (context.taskAssignmentContext?.active !== true || !context.resolvedWorkspace) {
         return undefined;
     }
-    if (context.resolvedWorkspace.authority === 'task') {
-        return 'This task thread runs in a task-isolated workspace instead of inheriting the channel workspace.';
+    if (context.resolvedWorkspace.authority === 'task-execution-target') {
+        return 'This task thread has a valid explicit execution.local_directory target, so execution is bound to that exact existing local directory.';
+    }
+    if (context.resolvedWorkspace.authority === 'task-thread-scratch') {
+        return context.resolvedWorkspace.reason === 'cross-agent-independent-workspace-disabled'
+            ? 'This task thread has an explicit execution.local_directory target, but this agents-host currently disables cross-agent independent-workspace handoff, so it is discussion-only.'
+            : 'This task thread has no valid explicit execution.local_directory target, so it is discussion-only.';
     }
     return 'This task thread inherits the channel workspace rather than using a task-isolated workspace.';
 }
@@ -24,8 +32,11 @@ function buildWorkspaceLocalityLine(context) {
     if (!context.resolvedWorkspace) {
         return undefined;
     }
-    if (context.resolvedWorkspace.authority === 'task') {
-        return 'This writable workspace is local to agents-host for this task thread. It does not imply that the target repository has already been checked out there.';
+    if (context.resolvedWorkspace.authority === 'task-execution-target') {
+        return 'This is a human-selected existing local directory. The host validates it before use and never creates it.';
+    }
+    if (context.resolvedWorkspace.authority === 'task-thread-scratch') {
+        return 'This scratch workspace is host-managed only for discussion turns. It is not a bound project workspace and does not imply that any target repository is checked out there.';
     }
     if (context.taskAssignmentContext?.active === true) {
         return 'This writable workspace is local to agents-host for this task thread because the task inherits its channel workspace. It does not imply that the target repository has already been checked out there.';
@@ -36,14 +47,34 @@ function buildCopilotCwdLine(context) {
     if (!context.resolvedWorkspace) {
         return undefined;
     }
-    if (context.resolvedWorkspace.authority === 'task') {
-        return 'GitHub Copilot runs this turn with that task-isolated workspace as its real cwd.';
+    if (context.resolvedWorkspace.authority === 'task-execution-target') {
+        return 'GitHub Copilot runs this turn with that exact local directory as its real cwd.';
+    }
+    if (context.resolvedWorkspace.authority === 'task-thread-scratch') {
+        return 'GitHub Copilot runs this turn with that host-managed scratch workspace as its real cwd.';
     }
     if (context.taskAssignmentContext?.active === true) {
         return 'GitHub Copilot runs this turn with that inherited channel workspace as its real cwd.';
     }
     return 'GitHub Copilot runs this turn with that workspace as its real cwd.';
 }
+function buildDiscussionOnlyPermissionLine(context) {
+    if (context.resolvedWorkspace?.authority !== 'task-thread-scratch') {
+        return undefined;
+    }
+    return context.resolvedWorkspace.reason === 'cross-agent-independent-workspace-disabled'
+        ? 'Filesystem and shell tool permissions stay denied in this discussion-only task thread while this agents-host keeps cross-agent independent-workspace handoff disabled.'
+        : 'Filesystem and shell tool permissions stay denied in this discussion-only task thread until a human sets a valid execution.local_directory target.';
+}
+function buildProjectEntryPrecheckLine(context) {
+    if (context.taskAssignmentContext?.active !== true) {
+        return undefined;
+    }
+    if (context.resolvedWorkspace?.authority === 'task-execution-target') {
+        return 'Precheck before switching this task thread into your own local workspace or project directory: the task\'s parent channel must have exactly one human user. Cross-agent independent-workspace handoff is also governed by this agents-host\'s local policy switch.';
+    }
+    return 'Before a human switches this task thread into their own local workspace or project directory, verify that the task\'s parent channel has exactly one human user; otherwise keep the thread discussion-only. Cross-agent independent-workspace handoff is also governed by this agents-host\'s local policy switch.';
+}
 export function buildResolvedWorkspaceGuidanceLines(context, provider) {
     if (!context?.resolvedWorkspace) {
         return [];
@@ -60,5 +91,16 @@ export function buildResolvedWorkspaceGuidanceLines(context, provider) {
     if (localityLine) {
         lines.push(localityLine);
     }
+    const permissionLine = buildDiscussionOnlyPermissionLine(context);
+    if (permissionLine) {
+        lines.push(permissionLine);
+    }
+    const precheckLine = buildProjectEntryPrecheckLine(context);
+    if (precheckLine) {
+        lines.push(precheckLine);
+    }
     return lines;
 }
+export function isDiscussionOnlyResolvedWorkspace(context) {
+    return context?.resolvedWorkspace?.authority === 'task-thread-scratch';
+}

package/dist/context/turn-preparation.js

@@ -127,6 +127,14 @@ export class ProviderTurnPreparer {
                     ...(input.incomingMessageType !== undefined && incomingContent !== undefined
                         ? { incomingContent }
                         : {}),
+                    ...(input.taskAssignmentContextOverride
+                        ? {
+                            taskAssignmentContextOverride: input.taskAssignmentContextOverride,
+                            ...(input.taskAssignmentContextOverridePersistence
+                                ? { taskAssignmentContextOverridePersistence: input.taskAssignmentContextOverridePersistence }
+                                : {}),
+                        }
+                        : {}),
                 };
                 channelContext = await this.channelContextStore.prepare(prepareInput);
             }

package/dist/gateway/localhost-gateway.js

@@ -550,11 +550,6 @@ class LoopbackLocalhostGatewayController {
                     return;
                 }
                 case 'users': {
-                    if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
-                        this.sendJson(response, 404, { error: 'not_found' });
-                        this.recordAudit('not-found', 404, decision.path, request.method ?? 'GET', decision.binding);
-                        return;
-                    }
                     this.sendJson(response, 200, {
                         users: await this.controlPlane.listUsers(),
                     });
@@ -910,6 +905,8 @@ function mapGatewayControlPlaneError(error, fallbackReason) {
             // is broken, and it would retry the same bad call instead of correcting it.
             case 'bpp.task_property_key_unknown':
                 return new GatewayHttpError(400, { error: 'unknown_property_key' }, 'bad-request');
+            case 'bpp.task_property_write_forbidden':
+                return new GatewayHttpError(403, { error: 'forbidden' }, 'forbidden');
             case 'bpp.task_property_value_invalid':
                 return new GatewayHttpError(400, { error: 'invalid_property_value' }, 'bad-request');
             case 'bpp.task_property_value_too_long':

package/dist/local-config.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
-import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseProviderIdleShutdownMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseBooleanValue, parseProviderIdleShutdownMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
 import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
@@ -127,6 +127,10 @@ function parseProviderCommandOverrides(value, sourceLabel) {
     if (value.providerIdleShutdownMinutes !== undefined && value.providerIdleShutdownMinutes !== null) {
         overrides.providerIdleShutdownMinutes = parseProviderIdleShutdownMinutesValue(value.providerIdleShutdownMinutes, sourceLabel);
     }
+    if (value.allowCrossAgentIndependentWorkspaceHandoff !== undefined
+        && value.allowCrossAgentIndependentWorkspaceHandoff !== null) {
+        overrides.allowCrossAgentIndependentWorkspaceHandoff = parseBooleanValue(value.allowCrossAgentIndependentWorkspaceHandoff, 'allowCrossAgentIndependentWorkspaceHandoff', sourceLabel);
+    }
     return overrides;
 }
 function toAgentsDir(hostConfigPath, rawAgentsDir) {
@@ -599,6 +603,9 @@ function renderAgentConfigYaml(agent) {
     if (agent.providerIdleShutdownMinutes !== undefined) {
         config.providerIdleShutdownMinutes = agent.providerIdleShutdownMinutes;
     }
+    if (agent.allowCrossAgentIndependentWorkspaceHandoff !== undefined) {
+        config.allowCrossAgentIndependentWorkspaceHandoff = agent.allowCrossAgentIndependentWorkspaceHandoff;
+    }
     return stringify(config);
 }
 function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
@@ -638,6 +645,9 @@ function resolveAgentProviderCommandConfig(hostDefaults, agent) {
         ...(agent.providerIdleShutdownMinutes !== undefined
             ? { providerIdleShutdownMinutes: agent.providerIdleShutdownMinutes }
             : {}),
+        ...(agent.allowCrossAgentIndependentWorkspaceHandoff !== undefined
+            ? { allowCrossAgentIndependentWorkspaceHandoff: agent.allowCrossAgentIndependentWorkspaceHandoff }
+            : {}),
     });
 }
 export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {

package/dist/managed-daemon.js

@@ -6,7 +6,7 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
 import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.js';
-import { resolveChannelWorkspaceDirectory, resolveChannelWorkspaceRootDirectory, resolveManagedWorkspaceCollectionRoot, resolveTaskWorkspaceDirectory, } from './context/injection.js';
+import { resolveChannelWorkspaceDirectory, resolveChannelWorkspaceRootDirectory, resolveManagedWorkspaceCollectionRoot, resolveTaskThreadScratchWorkspaceDirectory, } from './context/injection.js';
 import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, serializeManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
 import { DEFAULT_PROVIDER_COMMAND_CONFIG, hasLegacyClaudeOneShotArgs, loadConfigFromEnv, } from './config.js';
 import { loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
@@ -355,6 +355,7 @@ export function buildManagedLocalAgentConfig(options) {
             copilotArgs: [...config.copilotArgs],
             copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
             providerIdleShutdownMinutes: config.providerIdleShutdownMinutes,
+            allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
         },
     };
 }
@@ -401,6 +402,9 @@ function mergeManagedLocalAgentConfig(hostDefaults, existingAgent, generatedAgen
         providerIdleShutdownMinutes: hasOverride('PROVIDER_IDLE_SHUTDOWN_MINUTES')
             ? generatedAgent.providerIdleShutdownMinutes
             : existingAgent.providerIdleShutdownMinutes,
+        allowCrossAgentIndependentWorkspaceHandoff: hasOverride('ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF')
+            ? generatedAgent.allowCrossAgentIndependentWorkspaceHandoff
+            : existingAgent.allowCrossAgentIndependentWorkspaceHandoff,
     };
 }
 function collectExplicitManagedAgentEnvOverrides(processEnv, optionEnv) {
@@ -416,6 +420,7 @@ function collectExplicitManagedAgentEnvOverrides(processEnv, optionEnv) {
         'COPILOT_ARGS',
         'COPILOT_SESSION_TTL_MINUTES',
         'PROVIDER_IDLE_SHUTDOWN_MINUTES',
+        'ALLOW_CROSS_AGENT_INDEPENDENT_WORKSPACE_HANDOFF',
     ]) {
         if (processEnv[key] !== undefined) {
             explicitOverrides[key] = processEnv[key];
@@ -892,7 +897,9 @@ async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
                 continue;
             }
             const resolvedWorkspace = parsed.resolvedWorkspace;
-            if ((resolvedWorkspace.authority !== 'channel' && resolvedWorkspace.authority !== 'task')
+            if ((resolvedWorkspace.authority !== 'channel'
+                && resolvedWorkspace.authority !== 'task-thread-scratch'
+                && resolvedWorkspace.authority !== 'task-execution-target')
                 || typeof resolvedWorkspace.rootPath !== 'string'
                 || !isAbsolute(resolvedWorkspace.rootPath)) {
                 continue;
@@ -910,20 +917,18 @@ async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
                     workspaceRoots.add(trustedChannelWorkspaceRoot);
                     break;
                 }
-                const expectedWorkspacePath = resolvedWorkspace.authority === 'task'
-                    ? typeof resolvedWorkspace.taskId === 'string' && resolvedWorkspace.taskId.length > 0
-                        ? resolveTaskWorkspaceDirectory(workspaceCollectionRoot, parsed.channelId, resolvedWorkspace.taskId)
-                        : null
-                    : null;
-                if (!expectedWorkspacePath) {
-                    continue;
+                if (resolvedWorkspace.authority === 'task-thread-scratch') {
+                    const expectedWorkspacePath = resolveTaskThreadScratchWorkspaceDirectory(workspaceCollectionRoot, parsed.channelId);
+                    if (resolvedWorkspace.rootPath !== expectedWorkspacePath) {
+                        continue;
+                    }
+                    workspaceRoots.add(resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, parsed.channelId));
+                    break;
                 }
-                if (resolvedWorkspace.rootPath !== expectedWorkspacePath) {
+                if (resolvedWorkspace.authority !== 'task-execution-target') {
                     continue;
                 }
-                workspaceRoots.add(dirname(expectedWorkspacePath));
-                workspaceRoots.add(resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, parsed.channelId));
-                break;
+                continue;
             }
         }
     }

package/dist/plugin-sdk.js

@@ -3754,9 +3754,6 @@ var CONFIG_ACK_REASONS = /* @__PURE__ */ new Set([
   "unknown"
 ]);
 var WS_CLOSE_AUTH_FAILED = 4004;
-var RESUME_REPLAY_MODE = "latest_n";
-var RESUME_SINCE_CURSOR = 0;
-var RESUME_LATEST_N = 200;
 var RESULT_STATUS_OK = "ok";
 var STOP_TURN_ACTION = "stop_turn";
 var STOP_TURN_CHANNEL_ID_INVALID = "stop_turn_channel_id_invalid";
@@ -3999,7 +3996,6 @@ var BppTransport = class {
           throw new BorgeeError("authenticated agent identity could not be resolved", "bpp.identity_unresolved");
         this.agentId = resolved;
       }
-      this.sendResumeRequest(ws);
       this.startHeartbeat();
       this.goOnline(ws);
       resolve();
@@ -4009,18 +4005,6 @@ var BppTransport = class {
       this.failTerminal(failure, ws);
     }
   }
-  // The resume is written for one reader: a server that still holds durable
-  // frames behind a pre-ack barrier releases it when this frame arrives. Its
-  // answer is not read, so the request asks for nothing.
-  sendResumeRequest(ws) {
-    const frame = {
-      type: "session.resume",
-      replay_mode: RESUME_REPLAY_MODE,
-      since_cursor: RESUME_SINCE_CURSOR,
-      latest_n: RESUME_LATEST_N
-    };
-    this.sendTo(ws, frame);
-  }
   scheduleReconnect() {
     if (this.closed || this.terminal || !this.autoReconnect)
       return;
@@ -4086,7 +4070,6 @@ var BppTransport = class {
       case "agent_config_update":
         this.handleConfigUpdate(env, source);
         break;
-      case "session.resume_ack":
       case "pong":
       case "ping":
       case "agent_toggle":