@borgee/agents-host 0.2.73 → 0.2.84

package/dist/context/prompt.js

@@ -4,7 +4,7 @@ import { buildAttentionSummaryLines } from './attention.js';
 import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from './collaboration-capabilities-diagnostics.js';
 import { buildCollaborationOutcomeSummaryLines } from './collaboration-outcome.js';
 import { MAIN_SESSION_DELEGATION_LINES } from './main-session-delegation.js';
-import { buildResolvedWorkspaceGuidanceLines } from './resolved-workspace.js';
+import { buildResolvedWorkingFolderGuidanceLines } from './resolved-working-folder.js';
 import { buildSkillManualLines, buildSkillManualReadLine } from './skill-manual.js';
 import { PARENT_CHANNEL_TASK_BOUNDARY_LINES } from './task-channel-boundary.js';
 import { buildTaskThreadCollaborationSummaryLines } from './task-thread-collaboration.js';
@@ -101,8 +101,8 @@ function buildTaskAssignmentPromptLines(params) {
             'This thread is continuing an existing task assignment.',
             'Keep the main work in this thread.',
         ];
-    if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && params.promptContext?.resolvedWorkspace) {
-        lines.push(...buildResolvedWorkspacePromptLines(params.provider, params.promptContext));
+    if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && params.promptContext?.resolvedWorkingFolder) {
+        lines.push(...buildResolvedWorkingFolderPromptLines(params.provider, params.promptContext));
     }
     if ((params.provider !== 'claude' || params.forceInlineForClaude === true) && taskAssignmentContext?.currentTaskId) {
         lines.push(`Current assigned task id: ${taskAssignmentContext.currentTaskId}.`);
@@ -115,8 +115,8 @@ function buildTaskAssignmentPromptLines(params) {
     }
     return lines;
 }
-function buildResolvedWorkspacePromptLines(provider, context) {
-    return buildResolvedWorkspaceGuidanceLines(context, provider);
+function buildResolvedWorkingFolderPromptLines(provider, context) {
+    return buildResolvedWorkingFolderGuidanceLines(context, provider);
 }
 function buildClaudeOrdinaryGatewayTaskLines(context) {
     if (!context?.skillRuntime || !context.localhostGateway || !context.gatewayCredentialPath) {
@@ -250,18 +250,18 @@ function buildClaudeProjectedBriefTurnPrompt(params) {
         params.incomingContent,
     ].join('\n');
 }
-function buildOrdinaryCopilotWorkspacePromptLines(params) {
+function buildOrdinaryCopilotWorkingFolderPromptLines(params) {
     if (params.provider !== 'copilot') {
         return [];
     }
-    if (!params.promptContext?.resolvedWorkspace) {
+    if (!params.promptContext?.resolvedWorkingFolder) {
         return [];
     }
     if (params.incomingMessageType?.trim() === 'task_assignment'
         || params.promptContext.taskAssignmentContext?.active === true) {
         return [];
     }
-    return buildResolvedWorkspacePromptLines(params.provider, params.promptContext);
+    return buildResolvedWorkingFolderPromptLines(params.provider, params.promptContext);
 }
 function buildInboundMetadataLines(params) {
     return [
@@ -272,7 +272,7 @@ function buildInboundMetadataLines(params) {
             return lines.length > 0 ? ['', ...lines] : [];
         })(),
         ...(() => {
-            const lines = buildOrdinaryCopilotWorkspacePromptLines(params);
+            const lines = buildOrdinaryCopilotWorkingFolderPromptLines(params);
             return lines.length > 0 ? ['', ...lines] : [];
         })(),
         ...buildTaskAssignmentPromptLines({
@@ -601,7 +601,7 @@ function buildClaudeSessionEnvironmentLines(context) {
     if (context.localhostGateway && context.gatewayCredentialPath) {
         lines.push(`Gateway credential file for this session: ${context.gatewayCredentialPath}`);
     }
-    lines.push(...buildResolvedWorkspaceGuidanceLines(context));
+    lines.push(...buildResolvedWorkingFolderGuidanceLines(context));
     if (context.taskAssignmentContext?.currentTaskId) {
         lines.push(`Current assigned task id: ${context.taskAssignmentContext.currentTaskId}.`);
     }

package/dist/context/resolved-working-folder.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedPromptContext, ProviderKind } from '../types.js';
+export declare function buildResolvedWorkingFolderGuidanceLines(context: PreparedPromptContext | undefined, provider?: ProviderKind): string[];
+export declare function isDiscussionOnlyResolvedWorkingFolder(context: PreparedPromptContext | undefined): boolean;

package/dist/context/resolved-working-folder.js

@@ -0,0 +1,106 @@
+function buildWorkingFolderRootLine(context) {
+    const resolvedWorkingFolder = context.resolvedWorkingFolder;
+    if (!resolvedWorkingFolder) {
+        return undefined;
+    }
+    if (resolvedWorkingFolder.authority === 'task-execution-target') {
+        return `Explicit execution local directory for this task thread: ${resolvedWorkingFolder.rootPath}.`;
+    }
+    if (resolvedWorkingFolder.authority === 'task-thread-scratch') {
+        return `Discussion-only scratch working folder for this task thread: ${resolvedWorkingFolder.rootPath}.`;
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return `Writable working folder inherited from this task thread's channel: ${resolvedWorkingFolder.rootPath}.`;
+    }
+    return `Writable working folder for this channel: ${resolvedWorkingFolder.rootPath}.`;
+}
+function buildWorkingFolderModeLine(context) {
+    if (context.taskAssignmentContext?.active !== true || !context.resolvedWorkingFolder) {
+        return undefined;
+    }
+    if (context.resolvedWorkingFolder.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.resolvedWorkingFolder.authority === 'task-thread-scratch') {
+        return context.resolvedWorkingFolder.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-working-folder 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 working folder rather than using a task-isolated working folder.';
+}
+function buildWorkingFolderLocalityLine(context) {
+    if (!context.resolvedWorkingFolder) {
+        return undefined;
+    }
+    if (context.resolvedWorkingFolder.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.resolvedWorkingFolder.authority === 'task-thread-scratch') {
+        return 'This scratch working folder is host-managed only for discussion turns. It is not a bound project directory and does not imply that any target repository is checked out there.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'This writable working folder is local to agents-host for this task thread because the task inherits its channel working folder. It does not imply that the target repository has already been checked out there.';
+    }
+    return 'This writable working folder 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.resolvedWorkingFolder) {
+        return undefined;
+    }
+    if (context.resolvedWorkingFolder.authority === 'task-execution-target') {
+        return 'GitHub Copilot runs this turn with that exact local directory as its real cwd.';
+    }
+    if (context.resolvedWorkingFolder.authority === 'task-thread-scratch') {
+        return 'GitHub Copilot runs this turn with that host-managed scratch working folder as its real cwd.';
+    }
+    if (context.taskAssignmentContext?.active === true) {
+        return 'GitHub Copilot runs this turn with that inherited channel working folder as its real cwd.';
+    }
+    return 'GitHub Copilot runs this turn with that working folder as its real cwd.';
+}
+function buildDiscussionOnlyPermissionLine(context) {
+    if (context.resolvedWorkingFolder?.authority !== 'task-thread-scratch') {
+        return undefined;
+    }
+    return context.resolvedWorkingFolder.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-working-folder 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.resolvedWorkingFolder?.authority === 'task-execution-target') {
+        return 'Precheck before switching this task thread into your own local project directory: the task\'s parent channel must have exactly one human user. Cross-agent independent-working-folder handoff is also governed by this agents-host\'s local policy switch.';
+    }
+    return 'Before a human switches this task thread into their own local project directory, verify that the task\'s parent channel has exactly one human user; otherwise keep the thread discussion-only. Cross-agent independent-working-folder handoff is also governed by this agents-host\'s local policy switch.';
+}
+export function buildResolvedWorkingFolderGuidanceLines(context, provider) {
+    if (!context?.resolvedWorkingFolder) {
+        return [];
+    }
+    const lines = [buildWorkingFolderRootLine(context), buildWorkingFolderModeLine(context)]
+        .filter((line) => line != null);
+    if (provider === 'copilot') {
+        const copilotCwdLine = buildCopilotCwdLine(context);
+        if (copilotCwdLine) {
+            lines.push(copilotCwdLine);
+        }
+    }
+    const localityLine = buildWorkingFolderLocalityLine(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 isDiscussionOnlyResolvedWorkingFolder(context) {
+    return context?.resolvedWorkingFolder?.authority === 'task-thread-scratch';
+}

package/dist/context/turn-preparation.js

@@ -38,7 +38,7 @@ function toPromptContext(channelContext, input) {
                 skillRuntime: channelContext.skillRuntime,
                 localhostGateway: channelContext.localhostGateway,
                 taskAssignmentContext: channelContext.payload.taskAssignmentContext,
-                resolvedWorkspace: channelContext.resolvedWorkspace,
+                resolvedWorkingFolder: channelContext.resolvedWorkingFolder,
             }
             : {}),
         runtimeSurface,

package/dist/local-config.d.ts

@@ -41,14 +41,21 @@ export declare function loadLocalConfigSnapshot(hostConfigPath: string, deps?: {
     fileSystem?: LocalConfigFileSystem;
     acquireManagedGenerationLease?: boolean;
     env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
 }): Promise<LocalConfigSnapshot>;
 export declare function loadLocalConfigGenerateSpec(hostConfigPath: string, deps?: {
     fileSystem?: LocalConfigFileSystem;
     acquireManagedGenerationLease?: boolean;
     env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
 }): Promise<LocalConfigGenerateSpec>;
+export declare function hasManagedLocalConfig(rootPath: string, deps?: {
+    fileSystem?: ManagedLocalConfigFileSystem;
+    platform?: NodeJS.Platform;
+}): Promise<boolean>;
 export declare function materializeLocalConfig(rootPath: string, spec: LocalConfigGenerateSpec, deps?: {
     fileSystem?: ManagedLocalConfigFileSystem;
     env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
 }): Promise<LocalConfigGenerateResult>;
 export {};

package/dist/local-config.js

@@ -10,6 +10,8 @@ export const DEFAULT_LOCAL_AGENTS_DIRNAME = 'agents';
 const DEFAULT_AGENTS_DIR = './agents';
 const MANAGED_GENERATIONS_DIRNAME = '.generations';
 const MANAGED_CURRENT_LINK_NAME = 'current';
+const MANAGED_CURRENT_POINTER_FILENAME = 'current.json';
+const MANAGED_CURRENT_POINTER_SCHEMA_VERSION = 1;
 export const MANAGED_WRITE_LOCK_DIRNAME = '.generate-config.lock';
 const MANAGED_READERS_DIRNAME = '.readers';
 const MANAGED_HOLDER_METADATA_FILENAME = '.holder.json';
@@ -391,10 +393,106 @@ function isDirectManagedGeneration(root, target) {
     const resolvedTarget = resolve(root, target);
     return (dirname(resolvedTarget) === generationsDir && relative(generationsDir, resolvedTarget) !== '');
 }
-async function prepareManagedRoot(fileSystem, root) {
+function parseManagedCurrentPointer(raw, pointerPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Invalid managed config pointer ${pointerPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(parsed) ||
+        Object.keys(parsed).sort().join(',') !== 'generation,schemaVersion' ||
+        parsed.schemaVersion !== MANAGED_CURRENT_POINTER_SCHEMA_VERSION ||
+        typeof parsed.generation !== 'string' ||
+        !MANAGED_GENERATION_NAME_PATTERN.test(parsed.generation) ||
+        isAbsolute(parsed.generation) ||
+        parsed.generation.includes('/') ||
+        parsed.generation.includes('\\')) {
+        throw new Error(`Invalid managed config pointer ${pointerPath}: expected schemaVersion ${MANAGED_CURRENT_POINTER_SCHEMA_VERSION} and one direct generation identifier`);
+    }
+    return {
+        schemaVersion: MANAGED_CURRENT_POINTER_SCHEMA_VERSION,
+        generation: parsed.generation,
+    };
+}
+async function resolvePointerGeneration(fileSystem, root) {
+    const pointerPath = join(root, MANAGED_CURRENT_POINTER_FILENAME);
+    const pointerStatus = await pathStatus(fileSystem, pointerPath);
+    if (!pointerStatus) {
+        return undefined;
+    }
+    if (pointerStatus.isDirectory || pointerStatus.isSymbolicLink) {
+        throw new Error(`Managed config pointer must be an ordinary file: ${pointerPath}`);
+    }
+    const pointer = parseManagedCurrentPointer(await fileSystem.readFile(pointerPath), pointerPath);
+    const generationsDir = join(root, MANAGED_GENERATIONS_DIRNAME);
+    const generationPath = resolve(generationsDir, pointer.generation);
+    if (dirname(generationPath) !== generationsDir ||
+        relative(generationsDir, generationPath) !== pointer.generation) {
+        throw new Error(`Managed config pointer generation must be a direct child of ${generationsDir}`);
+    }
+    const generationStatus = await pathStatus(fileSystem, generationPath);
+    if (!generationStatus?.isDirectory || generationStatus.isSymbolicLink) {
+        throw new Error(`Managed config pointer target is not a directory: ${generationPath}`);
+    }
+    return generationPath;
+}
+async function resolveLegacyCurrentGeneration(fileSystem, root) {
+    const generationsDir = join(root, MANAGED_GENERATIONS_DIRNAME);
+    const currentPath = join(root, MANAGED_CURRENT_LINK_NAME);
+    const currentStatus = await pathStatus(fileSystem, currentPath);
+    if (!currentStatus) {
+        return undefined;
+    }
+    if (!currentStatus.isSymbolicLink) {
+        throw new Error(`Managed config path must be a symbolic link: ${currentPath}`);
+    }
+    const currentTarget = await fileSystem.readLink(currentPath);
+    if (!isDirectManagedGeneration(root, currentTarget)) {
+        throw new Error(`Managed config current generation must be inside ${generationsDir}`);
+    }
+    const currentGenerationPath = resolve(root, currentTarget);
+    const generationStatus = await pathStatus(fileSystem, currentGenerationPath);
+    if (!generationStatus?.isDirectory || generationStatus.isSymbolicLink) {
+        throw new Error(`Managed config current generation is not a directory: ${currentGenerationPath}`);
+    }
+    return currentGenerationPath;
+}
+async function validateOptionalLegacyAliases(fileSystem, root) {
+    const aliases = [
+        [
+            join(root, DEFAULT_LOCAL_HOST_CONFIG_FILENAME),
+            `${MANAGED_CURRENT_LINK_NAME}/${DEFAULT_LOCAL_HOST_CONFIG_FILENAME}`,
+        ],
+        [
+            join(root, DEFAULT_LOCAL_AGENTS_DIRNAME),
+            `${MANAGED_CURRENT_LINK_NAME}/${DEFAULT_LOCAL_AGENTS_DIRNAME}`,
+        ],
+    ];
+    for (const [path, target] of aliases) {
+        const status = await pathStatus(fileSystem, path);
+        if (status && (!status.isSymbolicLink || (await fileSystem.readLink(path)) !== target)) {
+            throw new Error(`Managed config path has an unexpected value: ${path}`);
+        }
+    }
+}
+async function prepareManagedRoot(fileSystem, root, platform) {
     await ensureDirectory(fileSystem, root, MANAGED_ROOT_MODE);
     const generationsDir = join(root, MANAGED_GENERATIONS_DIRNAME);
     await ensureDirectory(fileSystem, generationsDir, MANAGED_ROOT_MODE);
+    if (platform === 'win32') {
+        await validateOptionalLegacyAliases(fileSystem, root);
+        const pointerGeneration = await resolvePointerGeneration(fileSystem, root);
+        const legacyGeneration = pointerGeneration
+            ? undefined
+            : await resolveLegacyCurrentGeneration(fileSystem, root);
+        const currentGenerationPath = pointerGeneration ?? legacyGeneration;
+        if (currentGenerationPath) {
+            await fileSystem.chmod(currentGenerationPath, MANAGED_ROOT_MODE);
+        }
+        return { currentGenerationPath };
+    }
     const currentPath = join(root, MANAGED_CURRENT_LINK_NAME);
     const currentStatus = await pathStatus(fileSystem, currentPath);
     const hostAliasPath = join(root, DEFAULT_LOCAL_HOST_CONFIG_FILENAME);
@@ -483,7 +581,7 @@ function supportsManagedGenerationLeases(fileSystem) {
         'chmod' in fileSystem &&
         'readLink' in fileSystem);
 }
-async function managedRootForHostConfigPath(fileSystem, hostConfigPath) {
+async function managedRootForHostConfigPath(fileSystem, hostConfigPath, platform) {
     if (hostConfigPath === join(dirname(hostConfigPath), DEFAULT_LOCAL_HOST_CONFIG_FILENAME)) {
         const generationPath = dirname(hostConfigPath);
         const generationsDir = dirname(generationPath);
@@ -497,6 +595,11 @@ async function managedRootForHostConfigPath(fileSystem, hostConfigPath) {
         return undefined;
     }
     const root = dirname(hostConfigPath);
+    if (platform === 'win32') {
+        const pointerStatus = await pathStatus(fileSystem, join(root, MANAGED_CURRENT_POINTER_FILENAME));
+        const currentStatus = await pathStatus(fileSystem, join(root, MANAGED_CURRENT_LINK_NAME));
+        return pointerStatus || currentStatus ? root : undefined;
+    }
     const currentPath = join(root, MANAGED_CURRENT_LINK_NAME);
     const currentStatus = await pathStatus(fileSystem, currentPath);
     if (!currentStatus?.isSymbolicLink) {
@@ -504,7 +607,7 @@ async function managedRootForHostConfigPath(fileSystem, hostConfigPath) {
     }
     return isDirectManagedGeneration(root, await fileSystem.readLink(currentPath)) ? root : undefined;
 }
-async function resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath) {
+async function resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath, platform) {
     const resolveHostConfigPath = async () => resolve(fileSystem.realPath
         ? await fileSystem.realPath(absoluteHostConfigPath)
         : absoluteHostConfigPath);
@@ -512,14 +615,20 @@ async function resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConf
     if (!supportsManagedGenerationLeases(fileSystem)) {
         return { resolvedHostConfigPath: await resolveHostConfigPath(), release: noLease };
     }
-    const root = await managedRootForHostConfigPath(fileSystem, absoluteHostConfigPath);
+    const root = await managedRootForHostConfigPath(fileSystem, absoluteHostConfigPath, platform);
     if (!root) {
         return { resolvedHostConfigPath: await resolveHostConfigPath(), release: noLease };
     }
     const releaseWriteLock = await acquireManagedWriteLock(fileSystem, root);
     let leasePath;
     try {
-        const resolvedHostConfigPath = await resolveHostConfigPath();
+        const activeGenerationPath = platform === 'win32'
+            ? ((await resolvePointerGeneration(fileSystem, root)) ??
+                (await resolveLegacyCurrentGeneration(fileSystem, root)))
+            : undefined;
+        const resolvedHostConfigPath = activeGenerationPath
+            ? join(activeGenerationPath, DEFAULT_LOCAL_HOST_CONFIG_FILENAME)
+            : await resolveHostConfigPath();
         const generationPath = dirname(resolvedHostConfigPath);
         const generationsDir = join(root, MANAGED_GENERATIONS_DIRNAME);
         if (dirname(generationPath) !== generationsDir ||
@@ -660,7 +769,7 @@ export async function loadLocalConfigSnapshot(hostConfigPath, deps = {}) {
                 : absoluteHostConfigPath),
             release: async () => undefined,
         }
-        : await resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath);
+        : await resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath, deps.platform ?? process.platform);
     try {
         const { resolvedHostConfigPath } = managedGeneration;
         const hostConfigDir = dirname(absoluteHostConfigPath);
@@ -718,7 +827,7 @@ export async function loadLocalConfigGenerateSpec(hostConfigPath, deps = {}) {
                 : absoluteHostConfigPath),
             release: async () => undefined,
         }
-        : await resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath);
+        : await resolveHostConfigWithGenerationLease(fileSystem, absoluteHostConfigPath, deps.platform ?? process.platform);
     try {
         const { resolvedHostConfigPath } = managedGeneration;
         const hostConfigRecord = await loadParsedDocument(fileSystem, resolvedHostConfigPath, 'host config');
@@ -755,9 +864,20 @@ export async function loadLocalConfigGenerateSpec(hostConfigPath, deps = {}) {
         await managedGeneration.release();
     }
 }
+export async function hasManagedLocalConfig(rootPath, deps = {}) {
+    const fileSystem = deps.fileSystem ?? nodeFileSystem;
+    const root = resolve(rootPath);
+    const platform = deps.platform ?? process.platform;
+    if (platform === 'win32') {
+        return ((await resolvePointerGeneration(fileSystem, root)) !== undefined ||
+            (await resolveLegacyCurrentGeneration(fileSystem, root)) !== undefined);
+    }
+    return (await pathStatus(fileSystem, join(root, DEFAULT_LOCAL_HOST_CONFIG_FILENAME))) !== undefined;
+}
 export async function materializeLocalConfig(rootPath, spec, deps = {}) {
     const fileSystem = deps.fileSystem ?? nodeFileSystem;
     const layout = resolveLocalConfigLayout(rootPath);
+    const platform = deps.platform ?? process.platform;
     const desiredAgentFiles = new Map();
     for (const agent of spec.agents) {
         desiredAgentFiles.set(toGeneratedAgentConfigPath(layout.agentsDir, agent.key), agent);
@@ -768,8 +888,10 @@ export async function materializeLocalConfig(rootPath, spec, deps = {}) {
     await ensureDirectory(fileSystem, layout.root, MANAGED_ROOT_MODE);
     const releaseWriteLock = await acquireManagedWriteLock(fileSystem, layout.root);
     try {
-        const { currentGenerationPath } = await prepareManagedRoot(fileSystem, layout.root);
-        const priorAgentConfigPaths = await listSupportedConfigPaths(fileSystem, layout.agentsDir);
+        const { currentGenerationPath } = await prepareManagedRoot(fileSystem, layout.root, platform);
+        const priorAgentConfigPaths = (await listSupportedConfigPaths(fileSystem, currentGenerationPath
+            ? join(currentGenerationPath, DEFAULT_LOCAL_AGENTS_DIRNAME)
+            : layout.agentsDir)).map((path) => join(layout.agentsDir, path.slice(dirname(path).length + 1)));
         const generationName = randomUUID();
         const generationsDir = join(layout.root, MANAGED_GENERATIONS_DIRNAME);
         const generationPath = join(generationsDir, generationName);
@@ -792,9 +914,33 @@ export async function materializeLocalConfig(rootPath, spec, deps = {}) {
                 acquireManagedGenerationLease: false,
                 env: deps.env,
             });
-            const nextCurrentPath = join(layout.root, `.${MANAGED_CURRENT_LINK_NAME}-${generationName}`);
-            await fileSystem.symlink(join(MANAGED_GENERATIONS_DIRNAME, generationName), nextCurrentPath);
-            await fileSystem.rename(nextCurrentPath, join(layout.root, MANAGED_CURRENT_LINK_NAME));
+            if (platform === 'win32') {
+                const nextCurrentPath = join(layout.root, `.${MANAGED_CURRENT_POINTER_FILENAME}-${generationName}`);
+                await fileSystem.writeFile(nextCurrentPath, `${JSON.stringify({
+                    schemaVersion: MANAGED_CURRENT_POINTER_SCHEMA_VERSION,
+                    generation: generationName,
+                })}\n`);
+                await fileSystem.chmod(nextCurrentPath, MANAGED_CONFIG_MODE);
+                try {
+                    await fileSystem.rename(nextCurrentPath, join(layout.root, MANAGED_CURRENT_POINTER_FILENAME));
+                }
+                catch (error) {
+                    try {
+                        await fileSystem.removeFile(nextCurrentPath);
+                    }
+                    catch (cleanupError) {
+                        if (!isNotFoundError(cleanupError)) {
+                            throw new AggregateError([error, cleanupError], 'Managed config pointer publication and cleanup both failed');
+                        }
+                    }
+                    throw error;
+                }
+            }
+            else {
+                const nextCurrentPath = join(layout.root, `.${MANAGED_CURRENT_LINK_NAME}-${generationName}`);
+                await fileSystem.symlink(join(MANAGED_GENERATIONS_DIRNAME, generationName), nextCurrentPath);
+                await fileSystem.rename(nextCurrentPath, join(layout.root, MANAGED_CURRENT_LINK_NAME));
+            }
             published = true;
             try {
                 await pruneSupersededGenerations(fileSystem, generationsDir, new Set([generationPath, currentGenerationPath].filter((path) => path !== undefined)));

package/dist/managed-daemon.js

@@ -6,10 +6,10 @@ 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, resolveTaskThreadScratchWorkspaceDirectory, } from './context/injection.js';
+import { resolveChannelWorkingFolderDirectory, resolveChannelWorkingFolderRootDirectory, resolveManagedWorkingFolderCollectionRoot, resolveTaskThreadScratchWorkingFolderDirectory, } from './context/injection.js';
 import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, CURRENT_AGENTS_HOST_PACKAGE_VERSION, 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 { hasManagedLocalConfig, loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
 import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedStateRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
 const MANAGED_ROOT_MODE = 0o700;
 const MANAGED_CONFIG_MODE = 0o600;
@@ -843,19 +843,19 @@ async function shutdownManagedDaemon(rootPath, sendRequest, waitForShutdown) {
     }
     await waitForShutdown(rootPath);
 }
-function resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, owningChannelId, rootPath) {
+function resolveTrustedPersistedChannelWorkingFolderRoot(workingFolderCollectionRoot, owningChannelId, rootPath) {
     if (!owningChannelId || !isAbsolute(rootPath)) {
         return null;
     }
-    const expectedWorkspacePath = resolveChannelWorkspaceDirectory(workspaceCollectionRoot, owningChannelId);
-    if (rootPath !== expectedWorkspacePath) {
+    const expectedWorkingFolderPath = resolveChannelWorkingFolderDirectory(workingFolderCollectionRoot, owningChannelId);
+    if (rootPath !== expectedWorkingFolderPath) {
         return null;
     }
-    return resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, owningChannelId);
+    return resolveChannelWorkingFolderRootDirectory(workingFolderCollectionRoot, owningChannelId);
 }
-async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
-    const trustedWorkspaceCollectionRoots = new Set([
-        resolveManagedWorkspaceCollectionRoot(undefined, processEnv),
+async function discoverManagedWorkingFolderRootsForPurge(rootPath, processEnv) {
+    const trustedWorkingFolderCollectionRoots = new Set([
+        resolveManagedWorkingFolderCollectionRoot(undefined, processEnv),
     ]);
     const managedStateRoot = resolveManagedStateRoot(rootPath);
     const agentStateEntries = await fs.readdir(managedStateRoot, { withFileTypes: true }).catch((error) => {
@@ -864,7 +864,7 @@ async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
         }
         throw error;
     });
-    const workspaceRoots = new Set();
+    const workingFolderRoots = new Set();
     for (const agentStateEntry of agentStateEntries) {
         if (!agentStateEntry.isDirectory()) {
             continue;
@@ -900,43 +900,43 @@ async function discoverManagedWorkspaceRootsForPurge(rootPath, processEnv) {
             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)) {
+            const resolvedWorkingFolder = parsed.resolvedWorkspace;
+            if ((resolvedWorkingFolder.authority !== 'channel'
+                && resolvedWorkingFolder.authority !== 'task-thread-scratch'
+                && resolvedWorkingFolder.authority !== 'task-execution-target')
+                || typeof resolvedWorkingFolder.rootPath !== 'string'
+                || !isAbsolute(resolvedWorkingFolder.rootPath)) {
                 continue;
             }
-            for (const workspaceCollectionRoot of trustedWorkspaceCollectionRoots) {
-                if (resolvedWorkspace.authority === 'channel') {
-                    if (typeof resolvedWorkspace.owningChannelId !== 'string'
-                        || resolvedWorkspace.owningChannelId.length === 0) {
+            for (const workingFolderCollectionRoot of trustedWorkingFolderCollectionRoots) {
+                if (resolvedWorkingFolder.authority === 'channel') {
+                    if (typeof resolvedWorkingFolder.owningChannelId !== 'string'
+                        || resolvedWorkingFolder.owningChannelId.length === 0) {
                         continue;
                     }
-                    const trustedChannelWorkspaceRoot = resolveTrustedPersistedChannelWorkspaceRoot(workspaceCollectionRoot, resolvedWorkspace.owningChannelId, resolvedWorkspace.rootPath);
-                    if (!trustedChannelWorkspaceRoot) {
+                    const trustedChannelWorkingFolderRoot = resolveTrustedPersistedChannelWorkingFolderRoot(workingFolderCollectionRoot, resolvedWorkingFolder.owningChannelId, resolvedWorkingFolder.rootPath);
+                    if (!trustedChannelWorkingFolderRoot) {
                         continue;
                     }
-                    workspaceRoots.add(trustedChannelWorkspaceRoot);
+                    workingFolderRoots.add(trustedChannelWorkingFolderRoot);
                     break;
                 }
-                if (resolvedWorkspace.authority === 'task-thread-scratch') {
-                    const expectedWorkspacePath = resolveTaskThreadScratchWorkspaceDirectory(workspaceCollectionRoot, parsed.channelId);
-                    if (resolvedWorkspace.rootPath !== expectedWorkspacePath) {
+                if (resolvedWorkingFolder.authority === 'task-thread-scratch') {
+                    const expectedWorkingFolderPath = resolveTaskThreadScratchWorkingFolderDirectory(workingFolderCollectionRoot, parsed.channelId);
+                    if (resolvedWorkingFolder.rootPath !== expectedWorkingFolderPath) {
                         continue;
                     }
-                    workspaceRoots.add(resolveChannelWorkspaceRootDirectory(workspaceCollectionRoot, parsed.channelId));
+                    workingFolderRoots.add(resolveChannelWorkingFolderRootDirectory(workingFolderCollectionRoot, parsed.channelId));
                     break;
                 }
-                if (resolvedWorkspace.authority !== 'task-execution-target') {
+                if (resolvedWorkingFolder.authority !== 'task-execution-target') {
                     continue;
                 }
                 continue;
             }
         }
     }
-    return [...workspaceRoots].sort((left, right) => left.localeCompare(right));
+    return [...workingFolderRoots].sort((left, right) => left.localeCompare(right));
 }
 export async function cleanupManagedRuntime(options, deps = {}) {
     const sendRequest = deps.sendRequest ?? sendManagedDaemonRequest;
@@ -974,8 +974,8 @@ 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 });
+        for (const workingFolderRoot of await discoverManagedWorkingFolderRootsForPurge(resolved.rootPath, options.processEnv ?? process.env)) {
+            await fs.rm(workingFolderRoot, { recursive: true, force: true });
         }
         await removeRuntimeRoot(resolved.rootPath);
     }
@@ -1130,7 +1130,7 @@ export async function bootstrapManagedDaemonStart(options, deps = {}) {
             });
         if (options.apiKey !== undefined
             && currentRuntimeSettings.persistedSettingsSnapshot == null
-            && await fs.access(resolved.hostConfigPath).then(() => true).catch(() => false)) {
+            && await hasManagedLocalConfig(resolved.rootPath)) {
             throw new Error(`Managed runtime root ${resolved.rootPath} predates managed-runtime-settings.json; run \`agents-host start-managed ${options.serverUrl}\` once to migrate it before updating an individual agent`);
         }
         const explicitManagedAgentOverrides = collectExplicitManagedAgentEnvOverrides(options.processEnv ?? process.env, options.env);
@@ -1628,9 +1628,16 @@ export class ManagedAgentsHostDaemon {
         this.endpoint = resolveManagedDaemonEndpoint(this.rootPath, deps.platform);
         this.createSupervisor =
             deps.createSupervisor ??
-                ((configPath, daemonDebug) => new AgentsHostSupervisor(configPath, { debug: daemonDebug }));
-        this.loadSpec = deps.loadSpec ?? loadLocalConfigGenerateSpec;
-        this.materialize = deps.materialize ?? materializeLocalConfig;
+                ((configPath, daemonDebug) => new AgentsHostSupervisor(configPath, {
+                    debug: daemonDebug,
+                    platform: deps.platform,
+                }));
+        this.loadSpec =
+            deps.loadSpec ??
+                ((configPath) => loadLocalConfigGenerateSpec(configPath, { platform: deps.platform }));
+        this.materialize =
+            deps.materialize ??
+                ((managedRootPath, spec) => materializeLocalConfig(managedRootPath, spec, { platform: deps.platform }));
         const managedRuntimeSettings = resolveDesiredManagedRuntimeSettings(process.env);
         this.managedRuntimeFingerprint = managedRuntimeSettings.fingerprint;
         this.logger = deps.logger ?? console;