@borgee/agents-host 0.2.44 → 0.2.62

package/dist/context/resolved-workspace.js

@@ -0,0 +1,106 @@
+function buildWorkspaceRootLine(context) {
+    const resolvedWorkspace = context.resolvedWorkspace;
+    if (!resolvedWorkspace) {
+        return undefined;
+    }
+    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}.`;
+    }
+    return `Writable workspace root for this channel: ${resolvedWorkspace.rootPath}.`;
+}
+function buildWorkspaceModeLine(context) {
+    if (context.taskAssignmentContext?.active !== true || !context.resolvedWorkspace) {
+        return undefined;
+    }
+    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.';
+}
+function buildWorkspaceLocalityLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    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.';
+    }
+    return 'This writable workspace is local to agents-host for this channel. It does not imply that the target repository has already been checked out there.';
+}
+function buildCopilotCwdLine(context) {
+    if (!context.resolvedWorkspace) {
+        return undefined;
+    }
+    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 [];
+    }
+    const lines = [buildWorkspaceRootLine(context), buildWorkspaceModeLine(context)]
+        .filter((line) => line != null);
+    if (provider === 'copilot') {
+        const copilotCwdLine = buildCopilotCwdLine(context);
+        if (copilotCwdLine) {
+            lines.push(copilotCwdLine);
+        }
+    }
+    const localityLine = buildWorkspaceLocalityLine(context);
+    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/skill-manual.d.ts

@@ -1,4 +1,5 @@
 import type { SkillRuntimeBootstrapMetadata } from '../types.js';
+export declare function buildSkillManualReadLine(skillRuntime: SkillRuntimeBootstrapMetadata): string;
 /**
  * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
  * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host

package/dist/context/skill-manual.js

@@ -1,3 +1,6 @@
+export function buildSkillManualReadLine(skillRuntime) {
+    return `Read its manual at ${skillRuntime.skillMarkdownPath} before you act on this channel; it defines both the session-level coordination and delegation contract and the CLI invocation.`;
+}
 /**
  * What every model-facing surface says about the packaged CLI: what it is, where its manual is, and
  * that the manual has to be opened before acting. Nothing else about the CLI is stated on a host
@@ -12,7 +15,7 @@
 export function buildSkillManualLines(skillRuntime) {
     return [
         "A packaged local CLI reads this Borgee channel and acts on its tasks: channel history, visible participants, this channel's tasks and their properties, and short auxiliary mentions.",
-        `Read its manual at ${skillRuntime.skillMarkdownPath} before you act on this channel; you cannot form a working invocation without it.`,
+        buildSkillManualReadLine(skillRuntime),
         'Every command the manual documents is already authorized on a turn whose prompt names a gateway credential file. Run them directly and do not ask the user for permission first.',
     ];
 }

package/dist/context/turn-preparation.d.ts

@@ -1,9 +1,15 @@
 import { type DebugLogger } from '../debug.js';
-import type { PreparedProviderTurnInput, ProviderInput } from '../types.js';
+import type { ProjectionStrategy, PreparedProviderTurnInput, ProviderInput } from '../types.js';
 import { type ChannelContextStore } from './injection.js';
+type ResolveProjectionStrategy = (input: ProviderInput) => Promise<ProjectionStrategy>;
 export declare class ProviderTurnPreparer {
     private readonly channelContextStore?;
     private readonly logger;
-    constructor(channelContextStore?: ChannelContextStore | undefined, logger?: DebugLogger);
+    private readonly resolveProjectionStrategy;
+    constructor(channelContextStore?: ChannelContextStore | undefined, logger?: DebugLogger, options?: {
+        projectionStrategy?: ProjectionStrategy;
+        resolveProjectionStrategy?: ResolveProjectionStrategy;
+    });
     prepare(input: ProviderInput): Promise<PreparedProviderTurnInput>;
 }
+export {};

package/dist/context/turn-preparation.js

@@ -1,7 +1,8 @@
 import { HostLogger, summarizeError } from '../debug.js';
+import { DEFAULT_PROJECTION_STRATEGY } from '../projection-strategy-values.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts } from '../hosted-turn-content.js';
-import { ChannelContextPreparationError, } from './injection.js';
-import { buildPrompt } from './prompt.js';
+import { buildRuntimeSurfaceForTurn, ChannelContextPreparationError, } from './injection.js';
+import { buildClaudeSessionPromptAppend, buildClaudeTurnPrompt, buildPrompt } from './prompt.js';
 function providerLabel(provider) {
     if (provider === 'copilot') {
         return 'Copilot';
@@ -16,26 +17,36 @@ function toPromptContext(channelContext, input) {
         && !input.collaboration
         && !input.collaborationOutcome
         && !input.attentionSnapshot
+        && !input.compactionSnapshot
         && !input.collaborationCapabilities
         && !input.missedCollaborationDiagnostic
         && !input.taskThreadCollaborationContract) {
         return undefined;
     }
+    const runtimeSurface = channelContext?.payload.runtimeSurface ?? buildRuntimeSurfaceForTurn({
+        localhostGateway: channelContext?.payload.localhostGateway ?? channelContext?.localhostGateway,
+        collaboration: input.collaboration,
+        taskAssignmentContext: channelContext?.payload.taskAssignmentContext,
+    });
     return {
         ...(channelContext
             ? {
                 channelContextPayloadPath: channelContext.payloadPath,
+                claudeProjectedBriefPath: channelContext.claudeProjectedBriefPath,
+                claudeProjectedBriefHash: channelContext.claudeProjectedBriefHash,
                 gatewayCredentialPath: channelContext.gatewayCredentialPath,
                 skillRuntime: channelContext.skillRuntime,
                 localhostGateway: channelContext.localhostGateway,
                 taskAssignmentContext: channelContext.payload.taskAssignmentContext,
-                taskWorkspace: channelContext.taskWorkspace,
+                resolvedWorkspace: channelContext.resolvedWorkspace,
             }
             : {}),
+        runtimeSurface,
         collaborationTurnExecutionId: input.collaboration?.turnExecutionId,
         collaborationTurnMode: input.collaboration?.turnMode,
         collaborationOutcome: input.collaborationOutcome ?? channelContext?.payload.collaborationOutcome,
         attentionSnapshot: input.attentionSnapshot ?? channelContext?.payload.attentionSnapshot,
+        compactionSnapshot: input.compactionSnapshot ?? channelContext?.payload.compactionSnapshot,
         ...(() => {
             const collaborationCapabilities = input.collaborationCapabilities ?? channelContext?.payload.collaborationCapabilities;
             return collaborationCapabilities ? { collaborationCapabilities } : {};
@@ -71,9 +82,12 @@ function resolveProviderSessionRouting(input) {
 export class ProviderTurnPreparer {
     channelContextStore;
     logger;
-    constructor(channelContextStore, logger = new HostLogger()) {
+    resolveProjectionStrategy;
+    constructor(channelContextStore, logger = new HostLogger(), options = {}) {
         this.channelContextStore = channelContextStore;
         this.logger = logger;
+        this.resolveProjectionStrategy = options.resolveProjectionStrategy
+            ?? (async () => options.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY);
     }
     async prepare(input) {
         const incomingParts = input.incomingParts ?? buildHostedTurnContentParts({
@@ -82,11 +96,16 @@ export class ProviderTurnPreparer {
         const incomingContent = incomingParts.length > 0
             ? buildHostedIncomingContentText(incomingParts)
             : input.incomingContent;
+        const projectionStrategy = input.provider === 'claude'
+            ? await this.resolveProjectionStrategy(input)
+            : undefined;
         let channelContext;
         if (this.channelContextStore) {
             try {
                 const prepareInput = {
                     channelId: input.channelId,
+                    provider: input.provider,
+                    projectionStrategy,
                     collaboration: input.collaboration
                         ? {
                             ...input.collaboration,
@@ -96,6 +115,7 @@ export class ProviderTurnPreparer {
                         : undefined,
                     collaborationOutcome: input.collaborationOutcome,
                     attentionSnapshot: input.attentionSnapshot,
+                    compactionSnapshot: input.compactionSnapshot,
                     collaborationCapabilities: input.collaborationCapabilities,
                     missedCollaborationDiagnostic: input.missedCollaborationDiagnostic,
                     ...(input.taskThreadCollaborationContract
@@ -107,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);
             }
@@ -122,21 +150,43 @@ export class ProviderTurnPreparer {
         }
         const promptContext = toPromptContext(channelContext, input);
         return {
+            agentName: input.agentName,
             channelId: input.channelId,
             incomingContent,
             incomingParts,
             incomingEventKind: input.incomingEventKind,
             incomingMessageType: input.incomingMessageType,
-            prompt: buildPrompt({
-                agentName: input.agentName,
-                provider: input.provider,
-                channelId: input.channelId,
-                incomingAuthorId: input.incomingAuthorId,
-                incomingContent,
-                incomingEventKind: input.incomingEventKind,
-                incomingMessageType: input.incomingMessageType,
-                promptContext,
-            }),
+            prompt: input.provider === 'claude'
+                ? buildClaudeTurnPrompt({
+                    agentName: input.agentName,
+                    channelId: input.channelId,
+                    incomingAuthorId: input.incomingAuthorId,
+                    incomingContent,
+                    incomingEventKind: input.incomingEventKind,
+                    incomingMessageType: input.incomingMessageType,
+                    promptContext,
+                    promptStrategy: projectionStrategy,
+                })
+                : buildPrompt({
+                    agentName: input.agentName,
+                    provider: input.provider,
+                    channelId: input.channelId,
+                    incomingAuthorId: input.incomingAuthorId,
+                    incomingContent,
+                    incomingEventKind: input.incomingEventKind,
+                    incomingMessageType: input.incomingMessageType,
+                    promptContext,
+                }),
+            ...(input.provider === 'claude'
+                ? {
+                    claudeSessionPromptAppend: buildClaudeSessionPromptAppend({
+                        agentName: input.agentName,
+                        promptContext,
+                        promptStrategy: projectionStrategy,
+                    }),
+                    projectionStrategy,
+                }
+                : {}),
             promptContext,
             providerSessionRouting: resolveProviderSessionRouting(input),
         };

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,10 @@ 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':
                 return new GatewayHttpError(400, { error: 'property_value_too_long' }, 'bad-request');
             case 'bpp.task_invalid_status':

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

@@ -2,13 +2,15 @@ import { createHash, randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { createConnection, createServer } from 'node:net';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
-import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, 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, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.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';
-import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
+import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedStateRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
 const MANAGED_ROOT_MODE = 0o700;
 const MANAGED_CONFIG_MODE = 0o600;
 const BOOTSTRAP_LOCK_WAIT_MS = 10_000;
@@ -48,6 +50,9 @@ function isAlreadyExistsError(error) {
 function isSocketBusyError(error) {
     return isNodeErrorWithCode(error, 'EADDRINUSE');
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 function delay(milliseconds) {
     return new Promise((resolveDelay) => {
         setTimeout(resolveDelay, milliseconds);
@@ -157,6 +162,7 @@ function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
         compatibilityGates,
         providerImplementationOverrides,
         internalPolicyMode: snapshot.internalPolicyMode,
+        projectionStrategy: snapshot.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     };
 }
 function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
@@ -178,11 +184,19 @@ function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
     if (record.internalPolicyMode !== 'audit-only' && record.internalPolicyMode !== 'enforce') {
         throw new Error(`Invalid ${sourceLabel}: expected internalPolicyMode to be "audit-only" or "enforce"`);
     }
+    const rawProjectionStrategy = typeof record.projectionStrategy === 'string'
+        ? record.projectionStrategy
+        : record.claudePromptStrategy;
+    const projectionStrategy = normalizeProjectionStrategy(rawProjectionStrategy);
+    if (rawProjectionStrategy !== undefined && !projectionStrategy) {
+        throw new Error(`Invalid ${sourceLabel}: expected projectionStrategy to be "session-brief", "turn-full", "message-only", "turn-thin", or "file-brief"`);
+    }
     return normalizeManagedRuntimeSettingsSnapshot({
         schemaVersion: MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION,
         compatibilityGates: [...record.compatibilityGates],
         providerImplementationOverrides: [...record.providerImplementationOverrides],
         internalPolicyMode: record.internalPolicyMode,
+        projectionStrategy: projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
     });
 }
 async function loadManagedRuntimeSettingsSnapshot(rootPath) {
@@ -205,7 +219,7 @@ async function writeManagedRuntimeSettingsSnapshot(rootPath, snapshot) {
     await ensureDirectory(rootPath, MANAGED_ROOT_MODE);
     const settingsPath = resolveManagedRuntimeSettingsPath(rootPath);
     const normalizedSnapshot = normalizeManagedRuntimeSettingsSnapshot(snapshot);
-    await fs.writeFile(settingsPath, `${JSON.stringify(normalizedSnapshot)}\n`, {
+    await fs.writeFile(settingsPath, `${serializeManagedRuntimeSettingsSnapshot(normalizedSnapshot)}\n`, {
         encoding: 'utf8',
         mode: MANAGED_CONFIG_MODE,
     });
@@ -226,6 +240,7 @@ function buildManagedRuntimeSettingsEnv(baseEnv, snapshot) {
         [INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV]: resolveDisabledDefaultCompatibilityGates(snapshot.compatibilityGates).join(','),
         [INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]: snapshot.providerImplementationOverrides.join(','),
         [INTERNAL_POLICY_MODE_ENV]: snapshot.internalPolicyMode,
+        [INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV]: snapshot.projectionStrategy,
     };
 }
 function buildDesiredManagedRuntimeSettingsFromSnapshot(snapshot) {
@@ -340,6 +355,7 @@ export function buildManagedLocalAgentConfig(options) {
             copilotArgs: [...config.copilotArgs],
             copilotSessionTtlMinutes: config.copilotSessionTtlMinutes,
             providerIdleShutdownMinutes: config.providerIdleShutdownMinutes,
+            allowCrossAgentIndependentWorkspaceHandoff: config.allowCrossAgentIndependentWorkspaceHandoff,
         },
     };
 }
@@ -386,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) {
@@ -401,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];
@@ -819,6 +839,101 @@ async function shutdownManagedDaemon(rootPath, sendRequest, waitForShutdown) {
     }
     await waitForShutdown(rootPath);
 }
+function resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, owningChannelId, rootPath) {
+    if (!owningChannelId || !isAbsolute(rootPath)) {
+        return null;
+    }
+    const expectedWorkspacePath = resolveChannelWorkspaceDirectory(workspaceCollectionRoot, owningChannelId);
+    if (rootPath !== expectedWorkspacePath) {
+        return null;
+    }
+    return resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, owningChannelId);
+}
+async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
+    const trustedWorkspaceCollectionRoots = new Set([
+        resolveManagedWorkspaceCollectionRoot(undefined, processEnv),
+    ]);
+    const managedStateRoot = resolveManagedStateRoot(rootPath);
+    const agentStateEntries = await fs.readdir(managedStateRoot, { withFileTypes: true }).catch((error) => {
+        if (isNotFoundError(error)) {
+            return [];
+        }
+        throw error;
+    });
+    const workspaceRoots = new Set();
+    for (const agentStateEntry of agentStateEntries) {
+        if (!agentStateEntry.isDirectory()) {
+            continue;
+        }
+        const channelContextRoot = join(managedStateRoot, agentStateEntry.name, 'channel-context');
+        const channelEntries = await fs.readdir(channelContextRoot, { withFileTypes: true }).catch((error) => {
+            if (isNotFoundError(error)) {
+                return [];
+            }
+            throw error;
+        });
+        for (const channelEntry of channelEntries) {
+            if (!channelEntry.isDirectory()) {
+                continue;
+            }
+            const payloadPath = join(channelContextRoot, channelEntry.name, 'context.json');
+            const payload = await fs.readFile(payloadPath, 'utf8').catch((error) => {
+                if (isNotFoundError(error)) {
+                    return undefined;
+                }
+                throw error;
+            });
+            if (!payload) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(parsed) || typeof parsed.channelId !== 'string' || !isRecord(parsed.resolvedWorkspace)) {
+                continue;
+            }
+            const resolvedWorkspace = parsed.resolvedWorkspace;
+            if ((resolvedWorkspace.authority !== 'channel'
+                && resolvedWorkspace.authority !== 'task-thread-scratch'
+                && resolvedWorkspace.authority !== 'task-execution-target')
+                || typeof resolvedWorkspace.rootPath !== 'string'
+                || !isAbsolute(resolvedWorkspace.rootPath)) {
+                continue;
+            }
+            for (const workspaceCollectionRoot of trustedWorkspaceCollectionRoots) {
+                if (resolvedWorkspace.authority === 'channel') {
+                    if (typeof resolvedWorkspace.owningChannelId !== 'string'
+                        || resolvedWorkspace.owningChannelId.length === 0) {
+                        continue;
+                    }
+                    const trustedChannelWorkspaceRoot = resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, resolvedWorkspace.owningChannelId, resolvedWorkspace.rootPath);
+                    if (!trustedChannelWorkspaceRoot) {
+                        continue;
+                    }
+                    workspaceRoots.add(trustedChannelWorkspaceRoot);
+                    break;
+                }
+                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.authority !== 'task-execution-target') {
+                    continue;
+                }
+                continue;
+            }
+        }
+    }
+    return [...workspaceRoots].sort((left, right) => left.localeCompare(right));
+}
 export async function cleanupManagedRuntime(options, deps = {}) {
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
     const removeRuntimeRoot = deps.removeRuntimeRoot ??
@@ -855,6 +970,9 @@ export async function cleanupManagedRuntime(options, deps = {}) {
         await waitForShutdown(resolved.rootPath);
     }
     if (options.purge === true) {
+        for (const workspaceRoot of await discoverManagedWorkspaceRootsForPurge(resolved.rootPath, options.processEnv ?? process.env)) {
+            await fs.rm(workspaceRoot, { recursive: true, force: true });
+        }
         await removeRuntimeRoot(resolved.rootPath);
     }
 }
@@ -900,16 +1018,16 @@ export async function spawnManagedDaemonProcess(options, deps = {}) {
     }
     const thisPath = fileURLToPath(import.meta.url);
     const cliEntrypointPath = join(dirname(thisPath), thisPath.endsWith('.ts') ? 'cli.ts' : 'cli.js');
+    const baseEnv = {
+        ...process.env,
+        ...(options.processEnv ?? {}),
+    };
     return spawnDetachedProcess({
         rootPath: options.rootPath,
         command: process.execPath,
         env: {
-            ...buildManagedRuntimeSettingsEnv({
-                ...process.env,
-                ...(options.processEnv ?? {}),
-            }, managedRuntimeSettingsSnapshot),
+            ...buildManagedRuntimeSettingsEnv(baseEnv, managedRuntimeSettingsSnapshot),
             AGENTS_HOST_MANAGED_DAEMON_LOG_PATH: resolveManagedDaemonLogPath(options.rootPath),
-            AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR: options.rootPath,
         },
         args: [
             ...process.execArgv,