maka-agent 0.2.0-dev.16.20260903 → 0.2.0-dev.18.20260904

package/RUNTIME_HOST_PEER_THIRD_PARTY_NOTICES.txt

@@ -5,7 +5,7 @@ Generated by scripts/generate-runtime-host-peer-notices.mjs from the exact
 four-target production dependency inventory. Do not edit this file by hand.
 
 Manifest: native/runtime-host-peer/Cargo.toml
-Cargo.lock SHA-256: e7d745e06c3d2d65d7a01e15075001e2f5fc95e127b77918ddb0d23c024984cd
+Cargo.lock SHA-256: b1a7cdd67fee2bbde5bd8d91c6773f97e809515898604bde7ee0dbf4e04cbbd8
 Inventory SHA-256: c28a17749fa5f9af237a49dd2b4ad9149b6c4224d383c4a5050eeac3be14073c
 
 Packages

package/dist/cli-core.js

@@ -20,7 +20,7 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { deriveMakaDataRoots, resolveMakaDataRoots } from './workspace-root.js';
-import { configureRuntimeHostPeerClient, resolveRuntimeHostPeerNativePath, } from './runtime-host-peer-artifact.js';
+import { configureRuntimeHostPeerClient, resolveRuntimeHostNativePath, } from './runtime-host-peer-artifact.js';
 import { parseRuntimeHostCommand, parseRuntimeHostInstalledUpdateCommand, } from './runtime-host-cli.js';
 import { resolveCliUiLocale } from './cli-ui-locale.js';
 export const RELEASE_MAKA_CLI_LAUNCH_OPTIONS = {
@@ -264,6 +264,10 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 const { config } = await resolveRuntimeHostManagedDeployment(command.managedDeployment.rootId);
                 const peer = config.listeners.directPeer?.enabled ? config.listeners.directPeer : undefined;
                 const packageLayout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
+                if (process.platform === 'win32') {
+                    const { ownWindowsRuntimeHostProcessTree } = await import('./runtime-host-windows-service.js');
+                    await ownWindowsRuntimeHostProcessTree(packageLayout.cliPath);
+                }
                 return runRuntimeHostServiceCli({
                     rootPath: config.root.path,
                     json: command.json,
@@ -276,7 +280,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     ...(peer
                         ? {
                             peer: {
-                                nativePath: await resolveRuntimeHostPeerNativePath(packageLayout.cliPath),
+                                nativePath: await resolveRuntimeHostNativePath(packageLayout.cliPath),
                                 keyPath: peer.keyPath,
                                 expectedPeerId: peer.peerId,
                                 listenAddresses: peer.listenAddresses,
@@ -681,7 +685,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                     id: command.id,
                     name: command.name,
                     distribution: command.distribution,
-                    operatorPath: command.operatorPath,
+                    operator: command.operator,
                     expectedRootId: command.expectedRootId,
                 }, {}, profileOptions);
             }

package/dist/mcp-capability-provider.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { createHash } from 'node:crypto';
-import { CLIENT_CAPABILITY_MAX_TOOLS, CLIENT_CAPABILITY_MAX_TOOLS_PER_OFFER, decodeClientCapabilityReplaceInput, } from '@maka/runtime-host/protocol';
+import { CLIENT_CAPABILITY_MAX_TOOLS, CLIENT_CAPABILITY_MAX_TOOLS_PER_OFFER, clientCapabilityEntityId, decodeClientCapabilityReplaceInput, } from '@maka/runtime-host/protocol';
 const CAPABILITY_VERSION = '0';
 export function createMcpCapabilityProvider(manager) {
     const toolSnapshot = manager.toolSnapshot();
@@ -32,7 +32,7 @@ export function createMcpCapabilityProvider(manager) {
     const projectedIdentities = new Set();
     const projected = [];
     for (const source of tools) {
-        const descriptor = projectMcpTool(source.descriptor, capabilityEntityId(source.descriptor.serverId));
+        const descriptor = projectMcpTool(source.descriptor, clientCapabilityEntityId(source.descriptor.serverId));
         const identity = `${descriptor.serverId}\0${descriptor.name}`;
         if (projectedIdentities.has(identity)) {
             throw new Error('MCP tools collide after Client Capability identity normalization');
@@ -79,19 +79,12 @@ export function createMcpCapabilityProvider(manager) {
 function projectMcpTool(tool, wireServerId) {
     return {
         serverId: wireServerId,
-        name: capabilityEntityId(tool.name),
+        name: clientCapabilityEntityId(tool.name),
         ...(tool.description ? { description: tool.description } : {}),
         inputSchema: structuredClone(tool.inputSchema),
         ...(tool.annotations ? { annotations: { ...tool.annotations } } : {}),
     };
 }
-function capabilityEntityId(value) {
-    if (/^[A-Za-z0-9_-]{1,128}$/u.test(value))
-        return value;
-    const label = value.replace(/[^A-Za-z0-9_-]+/gu, '_').slice(0, 103) || 'mcp';
-    const digest = createHash('sha256').update(value).digest('hex').slice(0, 24);
-    return `${label}_${digest}`;
-}
 function projectMcpResult(result) {
     return {
         content: result.content.map((block) => structuredClone(block)),

package/dist/runtime-host-cli.js

@@ -18,7 +18,7 @@
  */
 import { isAbsolute } from 'node:path';
 import { isProductReleaseVersion, isSha512PackageIntegrity, } from '@maka/runtime-host/operator/update-package-evidence';
-import { decodeRuntimeHostWebRtcStunPolicy, } from '@maka/runtime-host/operator';
+import { createRuntimeHostLegacyPosixOperatorCommand, decodeRuntimeHostPosixOperatorCommand, decodeRuntimeHostWebRtcStunPolicy, } from '@maka/runtime-host/operator';
 import { canonicalProjectDirectoryRootSpec, isCanonicalRuntimeHostWebSocketPath, PROJECT_DIRECTORY_MAX_ROOTS, projectDirectoryPosixRootSpecValid, projectDirectoryRootSpecValid, } from '@maka/runtime-host/protocol';
 import { hasEphemeralRuntimeHostPeerPort } from './runtime-host-peer-artifact.js';
 export function parseRuntimeHostCommand(argv) {
@@ -1348,6 +1348,7 @@ function parseProfileCommand(argv) {
     let sshWebSocketPath = '/runtime-host';
     let sshWebSocketPathConfigured = false;
     let wslDistribution;
+    let operator;
     let operatorPath;
     let expectedRootId;
     let credentialEnv;
@@ -1362,6 +1363,7 @@ function parseProfileCommand(argv) {
             argument !== '--ssh-remote-port' &&
             argument !== '--ssh-websocket-path' &&
             argument !== '--wsl-distribution' &&
+            argument !== '--operator-command' &&
             argument !== '--operator-path' &&
             argument !== '--expected-root' &&
             argument !== '--credential-env' &&
@@ -1395,6 +1397,14 @@ function parseProfileCommand(argv) {
         }
         if (argument === '--wsl-distribution')
             wslDistribution = parsed;
+        if (argument === '--operator-command') {
+            try {
+                operator = decodeRuntimeHostPosixOperatorCommand(JSON.parse(parsed));
+            }
+            catch {
+                return error('--operator-command must be a valid Runtime Host operator command JSON value');
+            }
+        }
         if (argument === '--operator-path')
             operatorPath = parsed;
         if (argument === '--expected-root')
@@ -1407,6 +1417,17 @@ function parseProfileCommand(argv) {
         return error('--id is required');
     if (!name)
         return error('--name is required');
+    if (operator && operatorPath) {
+        return error('--operator-command and --operator-path cannot be combined');
+    }
+    if (operatorPath) {
+        try {
+            operator = createRuntimeHostLegacyPosixOperatorCommand(operatorPath);
+        }
+        catch {
+            return error('--operator-path must be an absolute POSIX path');
+        }
+    }
     if ((tlsUrl ? 1 : 0) +
         (plaintextUrl ? 1 : 0) +
         (sshDestination ? 1 : 0) +
@@ -1414,12 +1435,13 @@ function parseProfileCommand(argv) {
         1) {
         return error('exactly one of --tls-url, --plaintext-url, --ssh-destination, or --wsl-distribution is required');
     }
-    if (wslDistribution && !operatorPath) {
-        return error('--wsl-distribution requires --operator-path');
+    if (wslDistribution && !operator) {
+        return error('--wsl-distribution requires --operator-command or --operator-path');
     }
-    if (!wslDistribution && operatorPath) {
+    if (!wslDistribution && operatorPath)
         return error('--operator-path requires --wsl-distribution');
-    }
+    if (!wslDistribution && operator)
+        return error('--operator-command requires --wsl-distribution');
     if (wslDistribution && credentialEnv) {
         return error('WSL environment profiles do not accept --credential-env');
     }
@@ -1451,7 +1473,7 @@ function parseProfileCommand(argv) {
             id,
             name,
             distribution: wslDistribution,
-            operatorPath: operatorPath,
+            operator: operator,
             expectedRootId,
         };
     }

package/dist/runtime-host-lifecycle-transaction.js

@@ -17,12 +17,11 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { resolveExistingStorageRoot, tryAcquireStateRootOwner, } from '@maka/storage/root-authority';
 import { connectExistingRuntimeHost, prepareConnectedRuntimeHostRetirement, RuntimeHostOperationError, RuntimeHostRequestInterruptedError, waitForRuntimeHostReady, } from '@maka/runtime-host/client';
 import { RUNTIME_HOST_PROTOCOL_VERSION } from '@maka/runtime-host/protocol';
-import { beginRuntimeHostManagedDeploymentTransition, blockRuntimeHostManagedDeploymentTransition, commitRuntimeHostManagedDeploymentTransition, decodeRuntimeHostManagedDeploymentConfig, readRuntimeHostManagedDeploymentAuthorityRecord, resolveRuntimeHostManagedDeploymentAuthority, resolveRuntimeHostNpmDeploymentLayout, rollbackRuntimeHostManagedDeploymentTransition, RuntimeHostManagedDeploymentError, } from '@maka/runtime-host/operator';
+import { beginRuntimeHostManagedDeploymentTransition, blockRuntimeHostManagedDeploymentTransition, commitRuntimeHostManagedDeploymentTransition, decodeRuntimeHostManagedDeploymentConfig, readRuntimeHostManagedDeploymentAuthorityRecord, resolveRuntimeHostManagedDeploymentAuthority, resolveRuntimeHostNpmDeploymentLayout, runtimeHostManagedOperatorModulePath, rollbackRuntimeHostManagedDeploymentTransition, RuntimeHostManagedDeploymentError, } from '@maka/runtime-host/operator';
 /** The budget a managed Runtime Host has to become reachable after its lifecycle is activated. */
 export const RUNTIME_HOST_READY_TIMEOUT_MS = 45_000;
 export class RuntimeHostLifecycleTransactionError extends Error {
@@ -304,7 +303,7 @@ export async function replaceRuntimeHostLifecycle(input) {
     const desired = decodeRuntimeHostManagedDeploymentConfig(input.desired);
     const currentProvider = supervisedProvider(current ?? null, input.deps);
     if (desired.lifecycle.mode === 'supervised') {
-        await input.deps.resolveProvider(desired.lifecycle.provider).supervisor.preflight();
+        await input.deps.resolveProvider(desired).supervisor.preflight();
     }
     const retirement = await retireRuntimeHostLifecycleOwner({
         rootPath: desired.root.path,
@@ -459,7 +458,7 @@ export async function activateRuntimeHostLifecycle(config, deps) {
     const canonical = decodeRuntimeHostManagedDeploymentConfig(config);
     if (canonical.lifecycle.mode !== 'supervised')
         return;
-    const provider = deps.resolveProvider(canonical.lifecycle.provider);
+    const provider = deps.resolveProvider(canonical);
     await provider.supervisor.activate();
     if (canonical.reconciliation.trigger === 'scheduled') {
         await provider.reconciliationTrigger.activate();
@@ -470,7 +469,7 @@ export async function verifyRuntimeHostLifecycleReady(config, deps, timeoutMs =
     await verifyRuntimeHostLifecycleProjection(canonical, deps);
     if (canonical.lifecycle.mode !== 'supervised')
         return;
-    const provider = deps.resolveProvider(canonical.lifecycle.provider);
+    const provider = deps.resolveProvider(canonical);
     const deadline = Date.now() + timeoutMs;
     let lastFailure = new Error('Runtime Host is not ready');
     while (Date.now() < deadline) {
@@ -519,7 +518,7 @@ export async function verifyRuntimeHostLifecycleProjection(config, deps) {
     await deps.verifyOperator(canonical);
     if (canonical.lifecycle.mode !== 'supervised')
         return;
-    const provider = deps.resolveProvider(canonical.lifecycle.provider);
+    const provider = deps.resolveProvider(canonical);
     await provider.supervisor.verify(runtimeHostSupervisorDefinition(canonical));
     if (canonical.reconciliation.trigger !== 'scheduled')
         return;
@@ -550,7 +549,12 @@ export function runtimeHostSupervisorDefinition(config) {
 export function runtimeHostReconciliationTriggerDefinition(config) {
     const canonical = decodeRuntimeHostManagedDeploymentConfig(config);
     return {
-        command: [join(canonical.deploymentRoot, 'operator'), 'reconcile-update', '--framed'],
+        command: [
+            canonical.launch.nodePath,
+            runtimeHostManagedOperatorModulePath(canonical.deploymentRoot, process.platform === 'win32' ? 'win32' : 'posix'),
+            'reconcile-update',
+            '--framed',
+        ],
     };
 }
 async function convergeLifecycleArtifacts(from, to, deps) {
@@ -600,7 +604,5 @@ async function restoreTransition(record, deps) {
     await convergeTransitionOwnership(record.to, record.from, record, deps);
 }
 function supervisedProvider(config, deps) {
-    return config?.lifecycle.mode === 'supervised'
-        ? deps.resolveProvider(config.lifecycle.provider)
-        : undefined;
+    return config?.lifecycle.mode === 'supervised' ? deps.resolveProvider(config) : undefined;
 }

package/dist/runtime-host-managed-deployment.js

@@ -21,10 +21,10 @@ import { constants } from 'node:fs';
 import { access, lstat, mkdir, open, readdir, realpath, rename, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { openRuntimeHostPackageDeployment, prepareRuntimeHostPackageDeployment, pruneRuntimeHostPackageDeployments, resolveRuntimeHostPackageCliPath, RuntimeHostPackageDeploymentError as RuntimeHostManagedDeploymentError, } from './runtime-host-package-deployment.js';
+import { openRuntimeHostPackageDeployment, prepareRuntimeHostPackageDeployment, pruneRuntimeHostPackageDeployments, removeDeploymentDirectory, resolveRuntimeHostPackageCliPath, RuntimeHostPackageDeploymentError as RuntimeHostManagedDeploymentError, } from './runtime-host-package-deployment.js';
 import { readStableBoundedFile, syncDirectory } from '@maka/storage/stable-storage';
 import { resolveExistingStorageRoot, tryAcquireStateRootOwner } from '@maka/storage/root-authority';
-import { resolveRuntimeHostManagedDeploymentAuthorityRoot, resolveRuntimeHostManagedDeploymentAuthority, resolveRuntimeHostNpmDeploymentLayout, } from '@maka/runtime-host/operator';
+import { resolveRuntimeHostManagedDeploymentAuthorityRoot, resolveRuntimeHostManagedDeploymentAuthority, resolveRuntimeHostNpmDeploymentLayout, runtimeHostManagedOperatorModulePath, } from '@maka/runtime-host/operator';
 export { RuntimeHostPackageDeploymentError as RuntimeHostManagedDeploymentError } from './runtime-host-package-deployment.js';
 const CLEANUP_RECEIPT_FILE = 'cleanup-approved.json';
 export function resolveRuntimeHostManagedPackageCliPath(deploymentRoot, version, packageIntegrity) {
@@ -277,11 +277,16 @@ export function resolveRuntimeHostManagedDeploymentRoot(serviceId, options = {})
 function resolveRuntimeHostManagedDataHome(options = {}) {
     const env = options.env ?? process.env;
     const homeDir = options.homeDir ?? homedir();
-    return (options.platform ?? process.platform) === 'darwin'
+    const platform = options.platform ?? process.platform;
+    return platform === 'darwin'
         ? join(homeDir, 'Library', 'Application Support')
-        : env.XDG_DATA_HOME && isAbsolute(env.XDG_DATA_HOME)
-            ? env.XDG_DATA_HOME
-            : join(homeDir, '.local', 'share');
+        : platform === 'win32'
+            ? env.LOCALAPPDATA && isAbsolute(env.LOCALAPPDATA)
+                ? env.LOCALAPPDATA
+                : join(homeDir, 'AppData', 'Local')
+            : env.XDG_DATA_HOME && isAbsolute(env.XDG_DATA_HOME)
+                ? env.XDG_DATA_HOME
+                : join(homeDir, '.local', 'share');
 }
 export function resolveRuntimeHostManagedControlRoot(serviceId) {
     return join(resolveRuntimeHostManagedDeploymentAuthorityRoot(), serviceId, 'control');
@@ -372,24 +377,29 @@ export async function removeRuntimeHostManagedDeployment(root, serviceId) {
         // recognized as already complete and reclaimed by the next deployment.
         await syncDirectory(parent);
     }
-    await rm(retiredRoot, { recursive: true, force: true });
+    await removeDeploymentDirectory(retiredRoot);
     await syncDirectory(parent);
 }
 function managedDeployment(staged, clientDataRoot, managedRootId) {
-    const operatorPath = join(staged.root, 'operator');
+    const modulePath = runtimeHostManagedOperatorModulePath(staged.root, process.platform === 'win32' ? 'win32' : 'posix');
     return {
         version: staged.version,
         root: staged.root,
         cliPath: staged.cliPath,
-        operatorPath,
-        activate: () => writeOperatorLauncher(operatorPath, process.execPath, staged.cliPath, clientDataRoot, managedRootId),
+        activate: async () => {
+            await writeOperatorLauncher(modulePath, process.execPath, staged.cliPath, clientDataRoot, managedRootId);
+            await forwardLegacyOperatorIfPresent(staged.root, process.execPath, modulePath);
+        },
         cleanup: staged.cleanup,
         rollback: staged.rollback,
     };
 }
 async function writeOperatorLauncher(path, nodePath, cliPath, clientDataRoot, managedRootId, deploymentId) {
-    const temporaryPath = `${path}.${randomUUID()}.tmp`;
     const contents = operatorLauncherContents(nodePath, cliPath, clientDataRoot, managedRootId, deploymentId);
+    await writeStableOperator(path, contents);
+}
+async function writeStableOperator(path, contents) {
+    const temporaryPath = `${path}.${randomUUID()}.tmp`;
     try {
         const file = await open(temporaryPath, 'wx', 0o700);
         try {
@@ -400,44 +410,53 @@ async function writeOperatorLauncher(path, nodePath, cliPath, clientDataRoot, ma
             await file.close();
         }
         await rename(temporaryPath, path);
-        const parent = await open(dirname(path), 'r');
-        try {
-            await parent.sync();
-        }
-        finally {
-            await parent.close();
-        }
+        await syncDirectory(dirname(path));
     }
     finally {
         await rm(temporaryPath, { force: true });
     }
 }
 function operatorLauncherContents(nodePath, cliPath, clientDataRoot, managedRootId, deploymentId) {
-    return [
-        '#!/bin/sh',
-        'if [ "$#" -ge 1 ] && [ "$1" = "__cleanup-managed-deployment" ]; then',
-        '  shift',
-        `  exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host service cleanup-deployment "$@" --client-data-root ${quotePosix(clientDataRoot)} --managed-root-id ${quotePosix(managedRootId)}${deploymentId ? ` --operator-deployment-id ${quotePosix(deploymentId)}` : ''}`,
-        'fi',
-        'if [ "$#" -ge 1 ] && [ "$1" = "access" ]; then',
-        '  shift',
-        `  exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host access "$@"`,
-        'fi',
-        'if [ "$#" -ge 1 ] && [ "$1" = "activate" ]; then',
-        '  shift',
-        `  exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host activate "$@"`,
-        'fi',
-        'if [ "$#" -ge 1 ] && [ "$1" = "connect" ]; then',
-        '  shift',
-        `  exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host connect "$@"`,
-        'fi',
-        'if [ "$#" -ge 1 ] && [ "$1" = "serve" ]; then',
-        '  shift',
-        `  exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host serve "$@"`,
-        'fi',
-        `exec ${quotePosix(nodePath)} ${quotePosix(cliPath)} runtime-host service "$@" --client-data-root ${quotePosix(clientDataRoot)} --managed-root-id ${quotePosix(managedRootId)}${deploymentId ? ` --operator-deployment-id ${quotePosix(deploymentId)}` : ''}`,
-        '',
-    ].join('\n');
+    const fixedServiceArguments = [
+        '--client-data-root',
+        clientDataRoot,
+        '--managed-root-id',
+        managedRootId,
+        ...(deploymentId ? ['--operator-deployment-id', deploymentId] : []),
+    ];
+    return `import { spawn } from 'node:child_process';
+
+const [action, ...args] = process.argv.slice(2);
+const direct = new Set(['access', 'activate', 'connect', 'serve']);
+const cliArgs = action === '__cleanup-managed-deployment'
+  ? ['runtime-host', 'service', 'cleanup-deployment', ...args, ...${JSON.stringify(fixedServiceArguments)}]
+  : direct.has(action)
+    ? ['runtime-host', action, ...args]
+    : ['runtime-host', 'service', ...(action === undefined ? [] : [action]), ...args, ...${JSON.stringify(fixedServiceArguments)}];
+const child = spawn(${JSON.stringify(nodePath)}, [${JSON.stringify(cliPath)}, ...cliArgs], {
+  stdio: 'inherit',
+  windowsHide: true,
+});
+const signalForwarders = new Map();
+for (const signal of ['SIGINT', 'SIGTERM']) {
+  const forward = () => child.kill(signal);
+  signalForwarders.set(signal, forward);
+  process.on(signal, forward);
+}
+const stopForwardingSignals = () => {
+  for (const [signal, forward] of signalForwarders) process.off(signal, forward);
+};
+child.once('error', (error) => {
+  stopForwardingSignals();
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+child.once('exit', (code, signal) => {
+  stopForwardingSignals();
+  if (signal) process.kill(process.pid, signal);
+  else process.exitCode = code ?? 1;
+});
+`;
 }
 export async function convergeRuntimeHostManagedOperator(current, desired) {
     const deployment = desired ?? current;
@@ -447,35 +466,77 @@ export async function convergeRuntimeHostManagedOperator(current, desired) {
     // is removed. Package cleanup removes it with the deployment root.
     if (!desired)
         return;
-    const operatorPath = join(deployment.deploymentRoot, 'operator');
+    const operatorPath = runtimeHostManagedOperatorModulePath(deployment.deploymentRoot, process.platform === 'win32' ? 'win32' : 'posix');
     const layout = resolveRuntimeHostNpmDeploymentLayout(desired.deploymentRoot, desired.launch.package.integrity);
     await writeOperatorLauncher(operatorPath, desired.launch.nodePath, layout.cliPath, resolveRuntimeHostManagedControlRoot(desired.root.id), desired.root.id, desired.deploymentId);
+    await forwardLegacyOperatorIfPresent(deployment.deploymentRoot, desired.launch.nodePath, operatorPath);
+}
+function legacyOperatorLauncherContents(nodePath, modulePath) {
+    return `#!/bin/sh\nexec ${quotePosix(nodePath)} ${quotePosix(modulePath)} "$@"\n`;
+}
+async function forwardLegacyOperatorIfPresent(deploymentRoot, nodePath, modulePath) {
+    if (process.platform === 'win32')
+        return;
+    const path = join(deploymentRoot, 'operator');
+    const exists = await access(path, constants.F_OK).then(() => true, (error) => {
+        if (isNodeError(error, 'ENOENT'))
+            return false;
+        throw error;
+    });
+    if (exists) {
+        await writeStableOperator(path, legacyOperatorLauncherContents(nodePath, modulePath));
+    }
 }
 export async function restoreRuntimeHostLegacyManagedOperator(input) {
-    await writeOperatorLauncher(join(input.deploymentRoot, 'operator'), input.nodePath, input.cliPath, input.clientDataRoot, input.serviceId);
+    await writeOperatorLauncher(runtimeHostManagedOperatorModulePath(input.deploymentRoot, 'posix'), input.nodePath, input.cliPath, input.clientDataRoot, input.serviceId);
 }
 export async function verifyRuntimeHostManagedOperator(config) {
     const layout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
     const expected = operatorLauncherContents(config.launch.nodePath, layout.cliPath, resolveRuntimeHostManagedControlRoot(config.root.id), config.root.id, config.deploymentId);
+    const operatorPath = runtimeHostManagedOperatorModulePath(config.deploymentRoot, process.platform === 'win32' ? 'win32' : 'posix');
     const observed = await readStableBoundedFile({
-        path: join(config.deploymentRoot, 'operator'),
+        path: operatorPath,
         maxBytes: Buffer.byteLength(expected),
         invalidFile: () => new Error('The managed Runtime Host operator is not a stable regular file'),
     }).then((contents) => new TextDecoder('utf-8', { fatal: true }).decode(contents));
     if (observed !== expected)
         throw new Error('The managed Runtime Host operator does not match its deployment');
-    await access(join(config.deploymentRoot, 'operator'), constants.X_OK).catch((error) => {
-        throw new Error('The managed Runtime Host operator is not executable', {
+    await access(operatorPath, constants.R_OK).catch((error) => {
+        throw new Error('The managed Runtime Host operator is not readable', {
             cause: error,
         });
     });
-}
-function quotePosix(value) {
-    return `'${value.replaceAll("'", `'"'"'`)}'`;
+    const legacyOperatorPath = join(config.deploymentRoot, 'operator');
+    const legacyExpected = legacyOperatorLauncherContents(config.launch.nodePath, operatorPath);
+    const legacyExists = await access(legacyOperatorPath, constants.F_OK).then(() => true, (error) => {
+        if (isNodeError(error, 'ENOENT'))
+            return false;
+        throw error;
+    });
+    const legacyObserved = legacyExists
+        ? await readStableBoundedFile({
+            path: legacyOperatorPath,
+            maxBytes: Buffer.byteLength(legacyExpected),
+            invalidFile: () => new Error('The legacy managed Runtime Host operator is invalid'),
+        }).then((contents) => new TextDecoder('utf-8', { fatal: true }).decode(contents))
+        : null;
+    if (legacyObserved !== null && legacyObserved !== legacyExpected) {
+        throw new Error('The legacy managed Runtime Host operator does not match its deployment');
+    }
+    if (legacyObserved !== null) {
+        await access(legacyOperatorPath, constants.X_OK).catch((error) => {
+            throw new Error('The legacy managed Runtime Host operator is not executable', {
+                cause: error,
+            });
+        });
+    }
 }
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+function quotePosix(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 function isNodeError(error, code) {
     return error instanceof Error && 'code' in error && error.code === code;
 }

package/dist/runtime-host-managed-lifecycle-manager.js

@@ -26,7 +26,7 @@ export async function manageRuntimeHostManagedLifecycle(rootId, input, dependenc
     const lifecycleDeps = {
         convergeOperator: (currentConfig, desiredConfig) => convergeRuntimeHostManagedOperator(currentConfig, desiredConfig),
         verifyOperator: verifyRuntimeHostManagedOperator,
-        resolveProvider: (requested) => dependencies.resolveProvider(rootId, requested),
+        resolveProvider: dependencies.resolveProvider,
     };
     const resolved = await resolveRecoverableRuntimeHostManagedDeployment(rootId, lifecycleDeps, {
         ...(input.expectedTarget ? { expectedTarget: input.expectedTarget } : {}),
@@ -45,10 +45,7 @@ export async function manageRuntimeHostManagedLifecycle(rootId, input, dependenc
     if (dependencies.operatorClaim) {
         assertRuntimeHostManagedOperatorConfig(config, dependencies.operatorClaim.deploymentId, dependencies.operatorClaim.cliPath);
     }
-    const supervisedLifecycle = config.lifecycle.mode === 'supervised' ? config.lifecycle : undefined;
-    const provider = supervisedLifecycle
-        ? dependencies.resolveProvider(rootId, supervisedLifecycle.provider)
-        : undefined;
+    const provider = config.lifecycle.mode === 'supervised' ? dependencies.resolveProvider(config) : undefined;
     if (input.action === 'install') {
         throw new RuntimeHostServiceManagerError('target_mismatch', 'Managed Runtime Host installation must use runtime-host setup');
     }

package/dist/runtime-host-package-deployment.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
 import { cp, lstat, mkdir, readFile, readdir, realpath, rename, rm, stat } from 'node:fs/promises';
 import { basename, dirname, isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
 import { resolveRuntimeHostNpmDeploymentLayout } from '@maka/runtime-host/operator';
@@ -223,12 +224,12 @@ async function removePackageAtomically(versionsRoot, packageName) {
     const packageRoot = join(versionsRoot, packageName);
     try {
         if (packageName.startsWith('.') && packageName.endsWith('.deleted')) {
-            await rm(packageRoot, { recursive: true, force: true });
+            await removeDeploymentDirectory(packageRoot);
             return;
         }
         const tombstone = join(versionsRoot, `.${packageName}.${randomUUID()}.deleted`);
         await rename(packageRoot, tombstone);
-        await rm(tombstone, { recursive: true, force: true });
+        await removeDeploymentDirectory(tombstone);
     }
     catch (error) {
         if (isNodeError(error, 'ENOENT'))
@@ -236,6 +237,38 @@ async function removePackageAtomically(versionsRoot, packageName) {
         throw new RuntimeHostPackageDeploymentError('deployment_failed', 'Unable to remove an inactive Runtime Host package', { cause: error });
     }
 }
+export async function removeDeploymentDirectory(path) {
+    try {
+        await rm(path, { recursive: true, force: true });
+    }
+    catch (error) {
+        if (process.platform !== 'win32')
+            throw error;
+        deferWindowsDirectoryRemovalUntilExit(path);
+    }
+}
+function deferWindowsDirectoryRemovalUntilExit(path) {
+    // Loaded native addons remain locked until this operator exits. The caller
+    // has already renamed the directory out of authority before reaching here.
+    const script = `const { rm } = require('node:fs/promises');
+const path = process.argv[1];
+const parent = Number(process.argv[2]);
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+(async () => {
+  for (let attempt = 0; attempt < 3000; attempt += 1) {
+    try { process.kill(parent, 0); } catch { break; }
+    await wait(100);
+  }
+  await rm(path, { recursive: true, force: true, maxRetries: 100, retryDelay: 100 });
+})().catch(() => { process.exitCode = 1; });`;
+    const cleanup = spawn(process.execPath, ['-e', script, path, String(process.pid)], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    cleanup.on('error', () => undefined);
+    cleanup.unref();
+}
 function registryPackageLayout(deploymentRoot, integrity) {
     try {
         return resolveRuntimeHostNpmDeploymentLayout(deploymentRoot, integrity);

package/dist/runtime-host-peer-artifact.js

@@ -20,7 +20,7 @@ import { access, realpath } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 const PEER_NATIVE_FILE = 'maka_runtime_host_peer.node';
 const SUPPORTED_TARGETS = new Set(['darwin-arm64', 'linux-arm64', 'linux-x64', 'win32-x64']);
-export async function resolveRuntimeHostPeerNativePath(cliPath) {
+export async function resolveRuntimeHostNativePath(cliPath) {
     const packageRoot = dirname(dirname(await realpath(cliPath)));
     const target = runtimeHostPeerTarget();
     const packaged = join(packageRoot, 'native', 'runtime-host-peer', 'prebuilds', target, PEER_NATIVE_FILE);
@@ -31,7 +31,7 @@ export async function resolveRuntimeHostPeerNativePath(cliPath) {
         if (await isReadable(development))
             return realpath(development);
     }
-    throw new Error(`Maka does not include a direct-peer native artifact for ${target}`);
+    throw new Error(`Maka does not include a Runtime Host native artifact for ${target}`);
 }
 export function runtimeHostPeerTarget(platform = process.platform, arch = process.arch) {
     const target = `${platform}-${arch}`;
@@ -56,7 +56,7 @@ export async function configureRuntimeHostPeerClient(input) {
     if (explicitNativePath || explicitKeyPath)
         return Boolean(explicitNativePath && explicitKeyPath);
     try {
-        environment.MAKA_RUNTIME_HOST_PEER_NATIVE_PATH = await resolveRuntimeHostPeerNativePath(input.cliPath);
+        environment.MAKA_RUNTIME_HOST_PEER_NATIVE_PATH = await resolveRuntimeHostNativePath(input.cliPath);
         environment.MAKA_RUNTIME_HOST_PEER_KEY_PATH = resolveRuntimeHostClientPeerKeyPath(input.clientDataRoot);
         return true;
     }

package/dist/runtime-host-peer-management-command.js

@@ -28,7 +28,7 @@ import { allocateRuntimeHostPeerPort, RuntimeHostServiceManagerError, withRuntim
 import { resolveRuntimeHostLifecycleProvider } from './runtime-host-service-management-command.js';
 import { canDiscardRuntimeHostLifecycleDesiredArtifacts, replaceRuntimeHostLifecycle, resolveRecoverableRuntimeHostManagedDeployment, activateRuntimeHostLifecycle, verifyRuntimeHostLifecycleReady, } from './runtime-host-lifecycle-transaction.js';
 import { manageRuntimeHostManagedLifecycle } from './runtime-host-managed-lifecycle-manager.js';
-import { resolveRuntimeHostManagedPeerKeyPath, resolveRuntimeHostPeerNativePath, } from './runtime-host-peer-artifact.js';
+import { resolveRuntimeHostManagedPeerKeyPath, resolveRuntimeHostNativePath, } from './runtime-host-peer-artifact.js';
 import { assertRuntimeHostManagedOperatorConfig, assertRuntimeHostManagedOperatorDeployment, convergeRuntimeHostManagedOperator, pruneRuntimeHostManagedPeerKeys, resolveRuntimeHostManagedControlRoot, verifyRuntimeHostManagedOperator, } from './runtime-host-managed-deployment.js';
 export async function runRuntimeHostPeerManagementCli(options, overrides = {}) {
     const deps = {
@@ -50,7 +50,7 @@ async function runCanonicalRuntimeHostPeerManagementLocked(options, deps) {
     const lifecycleDeps = {
         convergeOperator: (currentConfig, desiredConfig) => convergeRuntimeHostManagedOperator(currentConfig, desiredConfig),
         verifyOperator: verifyRuntimeHostManagedOperator,
-        resolveProvider: (requested) => resolveRuntimeHostLifecycleProvider(rootId, requested),
+        resolveProvider: resolveRuntimeHostLifecycleProvider,
     };
     const resolved = await resolveRecoverableRuntimeHostManagedDeployment(rootId, lifecycleDeps, {
         ...(options.expectedTarget ? { expectedTarget: options.expectedTarget } : {}),
@@ -105,7 +105,7 @@ async function runCanonicalRuntimeHostPeerManagementLocked(options, deps) {
         stagedKeyPath = join(dirname(current.keyPath), `runtime-host-peer.${randomUUID()}.key`);
         const layout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
         const peerId = await ensureRuntimeHostPeerIdentity({
-            nativePath: await resolveRuntimeHostPeerNativePath(layout.cliPath),
+            nativePath: await resolveRuntimeHostNativePath(layout.cliPath),
             keyPath: stagedKeyPath,
         });
         desired = {
@@ -198,7 +198,7 @@ async function prepareCanonicalPeer(options, config, current) {
     const layout = resolveRuntimeHostNpmDeploymentLayout(config.deploymentRoot, config.launch.package.integrity);
     const keyPath = current?.keyPath ?? resolveRuntimeHostManagedPeerKeyPath(config.deploymentRoot);
     const peerId = await ensureRuntimeHostPeerIdentity({
-        nativePath: await resolveRuntimeHostPeerNativePath(layout.cliPath),
+        nativePath: await resolveRuntimeHostNativePath(layout.cliPath),
         keyPath,
     });
     if (current && current.peerId !== peerId) {

package/dist/runtime-host-peer-mesh-management-command.js

@@ -46,7 +46,7 @@ export async function runRuntimeHostPeerMeshManagementCli(options, overrides = {
             const resolved = await resolveRecoverableRuntimeHostManagedDeployment(options.managedRootId, {
                 convergeOperator: convergeRuntimeHostManagedOperator,
                 verifyOperator: verifyRuntimeHostManagedOperator,
-                resolveProvider: (requested) => resolveRuntimeHostLifecycleProvider(options.managedRootId, requested),
+                resolveProvider: resolveRuntimeHostLifecycleProvider,
             }, { expectedTarget: options.expectedTarget });
             if (resolved.kind === 'absent') {
                 throw new RuntimeHostServiceManagerError('not_installed', 'The managed Runtime Host deployment is not installed');