@moxt-ai/mobius 0.0.195 → 0.0.196

package/dist/cli.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 // src/cli.ts
 import { constants as constants3 } from "node:fs";
 import { mkdir as mkdir7, open as open6 } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 
 // ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -3381,7 +3381,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.195",
+  version: "0.0.196",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -3390,7 +3390,9 @@ var package_default = {
   types: "./src/index.ts",
   exports: {
     ".": "./src/index.ts",
-    "./runtime": "./src/runtime.ts"
+    "./runtime": "./src/runtime.ts",
+    "./process": "./src/process/executable.ts",
+    "./filesystem": "./src/filesystem/private-path.ts"
   },
   files: [
     "dist"
@@ -3409,6 +3411,14 @@ var package_default = {
       "./runtime": {
         types: "./dist/runtime.d.ts",
         import: "./dist/runtime.js"
+      },
+      "./process": {
+        types: "./dist/process/executable.d.ts",
+        import: "./dist/process/executable.js"
+      },
+      "./filesystem": {
+        types: "./dist/filesystem/private-path.d.ts",
+        import: "./dist/filesystem/private-path.js"
       }
     }
   },
@@ -3418,7 +3428,7 @@ var package_default = {
     directory: "packages/cli"
   },
   scripts: {
-    build: "tsc --project tsconfig.build.json && esbuild src/cli.ts src/index.ts src/runtime.ts --bundle --platform=node --format=esm --sourcemap --outdir=dist --external:@agentclientprotocol/* --external:undici",
+    build: "tsc --project tsconfig.build.json && esbuild src/cli.ts src/index.ts src/runtime.ts src/process/executable.ts src/filesystem/private-path.ts --bundle --platform=node --format=esm --sourcemap --outdir=dist --external:@agentclientprotocol/* --external:undici",
     dev: "node --watch src/cli.ts",
     prepack: "pnpm build",
     start: "node dist/cli.js",
@@ -3506,17 +3516,31 @@ function normalizeAcpCapabilities(initialized) {
 
 // src/process/executable.ts
 import { spawn } from "node:child_process";
-import { constants as constants2 } from "node:fs";
-import { access as access2, realpath as realpath2, stat as stat2 } from "node:fs/promises";
-import { join as join3, resolve } from "node:path";
+import { stat as stat2 } from "node:fs/promises";
+import { join as join5, resolve as resolve2 } from "node:path";
 
 // src/platform/linux.ts
-import { constants, readdirSync, readFileSync } from "node:fs";
-import { access, readdir, readFile, realpath, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { constants as constants2, readdirSync, readFileSync } from "node:fs";
+import { access as access2, readdir, readFile, realpath as realpath2, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
 
 // src/platform/posix.ts
 import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access, chmod, lstat, realpath, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// src/filesystem/path-error.ts
+var LocalPathError = class extends Error {
+  code = "unsafe_local_path";
+  constructor(message, options = {}) {
+    super(message, options);
+    this.name = "LocalPathError";
+  }
+};
+
+// src/platform/posix.ts
 var PROCESS_TABLE_TIMEOUT_MILLISECONDS = 1e3;
 var PROCESS_TABLE_OUTPUT_LIMIT_BYTES = 1024 * 1024;
 function parseProcessTable(output2) {
@@ -3561,6 +3585,81 @@ function processExists(processId) {
     return false;
   }
 }
+function signalCapturedProcesses(processes, rootProcessId, signal) {
+  const processIds = new Set(processes.map((identity2) => identity2.processId));
+  const signalledGroups = /* @__PURE__ */ new Set();
+  for (const identity2 of processes) {
+    const isRootProcessGroup = identity2.processGroupId === rootProcessId;
+    if (!isRootProcessGroup && !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(-identity2.processGroupId, signal);
+      signalledGroups.add(identity2.processGroupId);
+    } catch {
+    }
+  }
+  for (const identity2 of processes) {
+    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
+      continue;
+    }
+    try {
+      process.kill(identity2.processId, signal);
+    } catch {
+    }
+  }
+}
+function terminateProcess(child2, signal) {
+  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
+    return;
+  }
+  try {
+    process.kill(-child2.pid, signal);
+    return;
+  } catch {
+  }
+  child2.kill(signal);
+}
+async function removeControlSocket(path3) {
+  try {
+    await unlink(path3);
+  } catch (cause) {
+    if (!(cause instanceof Error) || !("code" in cause) || cause.code !== "ENOENT") {
+      throw cause;
+    }
+  }
+}
+var posixOperations = {
+  controlSocketPath: (installationHash) => join(tmpdir(), `mobius-${installationHash}.sock`),
+  prepareControlSocket: removeControlSocket,
+  secureControlSocket: async (path3) => {
+    await chmod(path3, 384);
+  },
+  removeControlSocket,
+  pathDelimiter: ":",
+  environmentValue: (environment, name2) => environment[name2],
+  executableExtensions: () => [""],
+  resolveExecutableTarget: async (path3) => {
+    const target = await realpath(path3);
+    await access(target, constants.X_OK);
+    return target;
+  },
+  executableLaunch: (command, args) => ({ command, arguments: args }),
+  spawnOptions: { detached: true, windowsHide: true },
+  signalCapturedProcesses,
+  terminateProcess,
+  validatePathPermissions: async (path3, directory, privateAccess, signal) => {
+    signal.throwIfAborted();
+    const metadata = await lstat(path3);
+    if (process.getuid === void 0 || metadata.uid !== process.getuid()) {
+      throw new LocalPathError("Path is not user-owned");
+    }
+    if (privateAccess) {
+      await chmod(path3, directory ? 448 : 384);
+    }
+    signal.throwIfAborted();
+  }
+};
 
 // src/platform/linux.ts
 function appendLinuxProcessTableEntry(entries, processId, encoded) {
@@ -3592,7 +3691,7 @@ async function readLinuxProcessTable() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          await readFile(join("/proc", directory.name, "stat"), "utf8")
+          await readFile(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -3617,7 +3716,7 @@ function readLinuxProcessTableSynchronously() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          readFileSync(join("/proc", directory.name, "stat"), "utf8")
+          readFileSync(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -3633,11 +3732,11 @@ async function readLinuxProcessTableWithFallback() {
   }
   for (const candidate of ["/usr/bin/ps", "/bin/ps", "/run/current-system/sw/bin/ps"]) {
     try {
-      const resolvedPath = await realpath(candidate);
+      const resolvedPath = await realpath2(candidate);
       if (!(await stat(resolvedPath)).isFile()) {
         continue;
       }
-      await access(resolvedPath, constants.X_OK);
+      await access2(resolvedPath, constants2.X_OK);
     } catch {
       continue;
     }
@@ -3650,7 +3749,7 @@ async function readLinuxProcessTableWithFallback() {
 }
 function processExists2(processId) {
   try {
-    const encoded = readFileSync(join("/proc", processId.toString(), "stat"), "utf8");
+    const encoded = readFileSync(join2("/proc", processId.toString(), "stat"), "utf8");
     const closingParenthesis = encoded.lastIndexOf(")");
     if (closingParenthesis >= 0) {
       const processState = encoded.slice(closingParenthesis + 1).trimStart().charAt(0);
@@ -3663,6 +3762,7 @@ function processExists2(processId) {
   return processExists(processId);
 }
 var linuxPlatform = {
+  ...posixOperations,
   readProcessTable: readLinuxProcessTableWithFallback,
   readProcessTableSynchronously: readLinuxProcessTableSynchronously,
   processExists: processExists2,
@@ -3694,7 +3794,7 @@ var linuxPlatform = {
 };
 
 // src/platform/macos.ts
-import { isAbsolute, join as join2 } from "node:path";
+import { isAbsolute, join as join3 } from "node:path";
 var WORKBUDDY_MACOS_EXECUTABLE_PATH = Object.freeze([
   "WorkBuddy.app",
   "Contents",
@@ -3705,14 +3805,15 @@ var WORKBUDDY_MACOS_EXECUTABLE_PATH = Object.freeze([
   "codebuddy"
 ]);
 var macosPlatform = {
+  ...posixOperations,
   readProcessTable: () => readProcessTableWithPs("/bin/ps"),
   readProcessTableSynchronously: () => [],
   processExists,
   workBuddyExecutablePaths: (environment) => {
-    const paths = [join2("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
+    const paths = [join3("/Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH)];
     const homeDirectory = environment["HOME"];
     if (homeDirectory !== void 0 && isAbsolute(homeDirectory)) {
-      paths.unshift(join2(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
+      paths.unshift(join3(homeDirectory, "Applications", ...WORKBUDDY_MACOS_EXECUTABLE_PATH));
     }
     return paths;
   },
@@ -3742,8 +3843,199 @@ var macosPlatform = {
   }
 };
 
+// src/platform/windows.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile2, realpath as realpath3 } from "node:fs/promises";
+import { dirname, extname, join as join4, resolve } from "node:path";
+import { promisify } from "node:util";
+
+// src/process/process-error.ts
+var ProcessExecutionError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ProcessExecutionError";
+  }
+};
+
+// src/platform/windows.ts
+var execute = promisify(execFile2);
+function environmentValue(environment, name2) {
+  return Object.entries(environment).find(([key]) => key.toUpperCase() === name2.toUpperCase())?.[1];
+}
+function executableExtensions(executableName, environment) {
+  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
+    return [""];
+  }
+  const configured = environmentValue(environment, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD";
+  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map((extension) => extension.startsWith(".") ? extension : `.${extension}`);
+  return extensions.length > 0 ? extensions : [".EXE"];
+}
+async function resolveExecutableTarget(path3) {
+  let resolvedPath;
+  try {
+    resolvedPath = await realpath3(extname(path3) === "" ? `${path3}.cmd` : path3);
+  } catch (cause) {
+    if (extname(path3) !== "" || !(cause instanceof Error) || !("code" in cause) || cause.code !== "ENOENT") {
+      throw cause;
+    }
+    resolvedPath = await realpath3(path3);
+  }
+  if (extname(resolvedPath).toLowerCase() === ".cmd") {
+    const shim = await readFile2(resolvedPath, "utf8");
+    const script = /"%_prog%"\s+"%dp0%[\\/]([^"\r\n]+\.(?:js|mjs|cjs))"\s+%\*/iu.exec(shim)?.[1];
+    if (script !== void 0 && shim.includes("SET dp0=%~dp0")) {
+      resolvedPath = await realpath3(resolve(dirname(resolvedPath), script));
+    } else {
+      const pnpmScript = /^\s*node\s+"%~dp0[\\/]([^"\r\n]+\.(?:js|mjs|cjs))"\s+%\*\s*$/imu.exec(shim)?.[1];
+      if (pnpmScript === void 0 || !shim.includes("@SETLOCAL")) {
+        throw new ProcessExecutionError(
+          "process_unsupported_script",
+          "Use a native executable or a verified Node entrypoint"
+        );
+      }
+      resolvedPath = await realpath3(resolve(dirname(resolvedPath), pnpmScript));
+    }
+  }
+  return resolvedPath;
+}
+function executableLaunch(command, args) {
+  if (/\.(?:js|mjs|cjs)$/iu.test(command)) {
+    return { command: process.execPath, arguments: [command, ...args] };
+  }
+  if (/\.(?:cmd|bat)$/iu.test(command)) {
+    throw new ProcessExecutionError(
+      "process_unsupported_script",
+      "Use a native executable or a verified Node entrypoint"
+    );
+  }
+  return { command, arguments: args };
+}
+function readProcessTable() {
+  const systemRoot = environmentValue(process.env, "SystemRoot");
+  if (systemRoot === void 0) {
+    return Promise.resolve([]);
+  }
+  return new Promise((resolveTable) => {
+    execFile2(
+      join4(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        "Get-CimInstance Win32_Process | ForEach-Object { '{0} {1} {0}' -f $_.ProcessId, $_.ParentProcessId }"
+      ],
+      {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 1e4,
+        signal: AbortSignal.timeout(1e4),
+        maxBuffer: 1024 * 1024
+      },
+      (error62, stdout) => resolveTable(error62 === null ? parseProcessTable(stdout) : [])
+    );
+  });
+}
+function signalCapturedProcesses2(processes, _rootProcessId, signal) {
+  for (const identity2 of [...processes].reverse()) {
+    try {
+      process.kill(identity2.processId, signal);
+    } catch {
+    }
+  }
+}
+function terminateProcess2(child2, signal) {
+  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
+    return;
+  }
+  child2.kill(signal);
+}
+var windowsPermissions = `
+$ErrorActionPreference = 'Stop'
+Import-Module (Join-Path $PSHOME 'Modules/Microsoft.PowerShell.Security/Microsoft.PowerShell.Security.psd1')
+$item = Get-Item -LiteralPath $env:MOBIUS_PERMISSION_PATH -Force
+if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'Unsafe path' }
+$sid = [Security.Principal.WindowsIdentity]::GetCurrent().User
+$acl = Get-Acl -LiteralPath $item.FullName
+$owner = $acl.GetOwner([Security.Principal.SecurityIdentifier])
+if ($owner -ne $sid -and -not ($owner.Value -eq 'S-1-5-32-544' -and ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))) { throw 'Path is not user-owned' }
+if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
+    if ($item.PSIsContainer) {
+        $private = New-Object Security.AccessControl.DirectorySecurity
+        $rule = New-Object Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'ContainerInherit,ObjectInherit', 'None', 'Allow')
+    } else {
+        $private = New-Object Security.AccessControl.FileSecurity
+        $rule = New-Object Security.AccessControl.FileSystemAccessRule($sid, 'FullControl', 'Allow')
+    }
+    $private.SetOwner($sid)
+    $private.SetAccessRuleProtection($true, $false)
+    $private.AddAccessRule($rule)
+    Set-Acl -LiteralPath $item.FullName -AclObject $private
+}
+`;
+async function validatePathPermissions(path3, _directory, privateAccess, signal) {
+  signal.throwIfAborted();
+  const systemRoot = environmentValue(process.env, "SystemRoot");
+  if (systemRoot === void 0) {
+    throw new LocalPathError("Windows system directory is unavailable");
+  }
+  try {
+    await execute(
+      join4(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-EncodedCommand",
+        Buffer.from(windowsPermissions, "utf16le").toString("base64")
+      ],
+      {
+        env: {
+          ...process.env,
+          MOBIUS_PERMISSION_PATH: path3,
+          MOBIUS_PERMISSION_PRIVATE: privateAccess ? "1" : "0"
+        },
+        windowsHide: true,
+        signal: AbortSignal.any([signal, AbortSignal.timeout(1e4)]),
+        timeout: 1e4,
+        maxBuffer: 16384
+      }
+    );
+  } catch (cause) {
+    signal.throwIfAborted();
+    throw new LocalPathError("The local path permissions could not be secured", { cause });
+  }
+}
+var windowsPlatform = {
+  controlSocketPath: (installationHash) => `\\\\.\\pipe\\mobius-${installationHash}`,
+  prepareControlSocket: async () => {
+  },
+  secureControlSocket: async () => {
+  },
+  removeControlSocket: async () => {
+  },
+  pathDelimiter: ";",
+  environmentValue,
+  executableExtensions,
+  resolveExecutableTarget,
+  executableLaunch,
+  spawnOptions: { detached: false, windowsHide: true },
+  signalCapturedProcesses: signalCapturedProcesses2,
+  terminateProcess: terminateProcess2,
+  validatePathPermissions,
+  readProcessTable,
+  readProcessTableSynchronously: () => [],
+  processExists,
+  workBuddyExecutablePaths: () => [],
+  openCodeArchives: {},
+  grokDependencies: {}
+};
+
 // src/platform/index.ts
 var fallbackPlatform = {
+  ...posixOperations,
   readProcessTable: () => readProcessTableWithPs("/usr/bin/ps"),
   readProcessTableSynchronously: () => [],
   processExists,
@@ -3754,7 +4046,7 @@ var fallbackPlatform = {
 var platforms = /* @__PURE__ */ new Map([
   ["linux", linuxPlatform],
   ["darwin", macosPlatform],
-  ["win32", { ...fallbackPlatform, readProcessTable: () => Promise.resolve([]) }]
+  ["win32", windowsPlatform]
 ]);
 function platformSupportFor(platform) {
   return platforms.get(platform) ?? fallbackPlatform;
@@ -3793,14 +4085,6 @@ var ResolvedExecutable = class {
     this.path = identity2.realPath;
   }
 };
-var ProcessExecutionError = class extends Error {
-  code;
-  constructor(code, message, options = {}) {
-    super(message, options);
-    this.code = code;
-    this.name = "ProcessExecutionError";
-  }
-};
 var ProcessResult = class {
   stderr;
   stdout;
@@ -3809,28 +4093,14 @@ var ProcessResult = class {
     this.stdout = stdout;
   }
 };
-function executableExtensions(executableName, environment, platform) {
-  if (platform !== "win32") {
-    return [""];
-  }
-  if (/\.[a-zA-Z0-9]+$/.test(executableName)) {
-    return [""];
-  }
-  const configured = environment["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD";
-  const extensions = configured.split(";").map((extension) => extension.trim()).filter((extension) => extension.length > 0).map((extension) => extension.startsWith(".") ? extension : `.${extension}`);
-  return extensions.length > 0 ? extensions : [".EXE"];
-}
 async function resolveExecutablePath(requestedPath2, platform = process.platform) {
-  const absoluteRequestedPath = resolve(requestedPath2);
+  const absoluteRequestedPath = resolve2(requestedPath2);
   try {
-    const resolvedPath = await realpath2(absoluteRequestedPath);
+    const resolvedPath = await platformSupportFor(platform).resolveExecutableTarget(absoluteRequestedPath);
     const metadata = await stat2(resolvedPath);
     if (!metadata.isFile()) {
       return null;
     }
-    if (platform !== "win32") {
-      await access2(resolvedPath, constants2.X_OK);
-    }
     return new ResolvedExecutable(
       new ExecutableIdentity(
         absoluteRequestedPath,
@@ -3846,15 +4116,16 @@ async function resolveExecutablePath(requestedPath2, platform = process.platform
   }
 }
 async function findExecutableOnPath(executableName, environment, platform = process.platform) {
-  const encodedPath = environment["PATH"] ?? "";
-  const separator = platform === "win32" ? ";" : ":";
-  const extensions = executableExtensions(executableName, environment, platform);
+  const support = platformSupportFor(platform);
+  const encodedPath = support.environmentValue(environment, "PATH") ?? "";
+  const separator = support.pathDelimiter;
+  const extensions = support.executableExtensions(executableName, environment);
   for (const entry of encodedPath.split(separator)) {
     if (entry.length === 0) {
       continue;
     }
     for (const extension of extensions) {
-      const requestedPath2 = resolve(join3(entry, `${executableName}${extension}`));
+      const requestedPath2 = resolve2(join5(entry, `${executableName}${extension}`));
       const executable = await resolveExecutablePath(requestedPath2, platform);
       if (executable !== null) {
         return executable;
@@ -3875,7 +4146,7 @@ function appendBounded(chunks, chunk, currentBytes, limitBytes) {
   chunks.push(chunk);
   return nextBytes;
 }
-function readProcessTable() {
+function readProcessTable2() {
   return hostPlatform.readProcessTable();
 }
 function selectProcessTree(entries, rootProcessId) {
@@ -3910,38 +4181,14 @@ function mergeProcessTrees(captured, current) {
   return [...processes.values()];
 }
 async function captureProcessTree(child2) {
-  if (process.platform === "win32" || child2.pid === void 0) {
+  if (child2.pid === void 0) {
     return [];
   }
   const entries = hostPlatform.readProcessTableSynchronously();
   if (entries.length > 0) {
     return selectProcessTree(entries, child2.pid);
   }
-  return selectProcessTree(await readProcessTable(), child2.pid);
-}
-function signalCapturedProcessGroups(processes, rootProcessId, signal) {
-  const processIds = new Set(processes.map((identity2) => identity2.processId));
-  const signalledGroups = /* @__PURE__ */ new Set();
-  for (const identity2 of processes) {
-    const isRootProcessGroup = identity2.processGroupId === rootProcessId;
-    if (!isRootProcessGroup && !processIds.has(identity2.processGroupId) || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(-identity2.processGroupId, signal);
-      signalledGroups.add(identity2.processGroupId);
-    } catch {
-    }
-  }
-  for (const identity2 of processes) {
-    if (identity2.processId === rootProcessId || identity2.processGroupId === rootProcessId || signalledGroups.has(identity2.processGroupId)) {
-      continue;
-    }
-    try {
-      process.kill(identity2.processId, signal);
-    } catch {
-    }
-  }
+  return selectProcessTree(await readProcessTable2(), child2.pid);
 }
 async function waitForCapturedProcessesExit(processes, rootProcessId) {
   const processIds = processes.map((identity2) => identity2.processId).filter((processId) => processId !== rootProcessId);
@@ -3949,36 +4196,10 @@ async function waitForCapturedProcessesExit(processes, rootProcessId) {
     if (processIds.every((processId) => !hostPlatform.processExists(processId))) {
       return true;
     }
-    await readProcessTable();
+    await readProcessTable2();
   }
   return processIds.every((processId) => !hostPlatform.processExists(processId));
 }
-function terminateProcess(child2) {
-  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child2.pid, "SIGTERM");
-      return;
-    } catch {
-    }
-  }
-  child2.kill("SIGTERM");
-}
-function forceTerminateProcess(child2) {
-  if (child2.exitCode !== null || child2.signalCode !== null || child2.pid === void 0) {
-    return;
-  }
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-child2.pid, "SIGKILL");
-      return;
-    } catch {
-    }
-  }
-  child2.kill("SIGKILL");
-}
 async function stopProcessTree(child2, capturedProcesses = []) {
   const childProcessId = child2.pid;
   if (childProcessId === void 0) {
@@ -3989,8 +4210,8 @@ async function stopProcessTree(child2, capturedProcesses = []) {
   if (childExited && processes.length === 0) {
     return;
   }
-  signalCapturedProcessGroups(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
-  terminateProcess(child2);
+  hostPlatform.signalCapturedProcesses(processes, childProcessId, GRACEFUL_STOP_SIGNAL);
+  hostPlatform.terminateProcess(child2, "SIGTERM");
   const [exitedAfterTermination, descendantsExitedAfterTermination] = await Promise.all([
     waitForProcessExit(child2, PROCESS_GRACEFUL_STOP_TIMEOUT_MILLISECONDS),
     waitForCapturedProcessesExit(processes, childProcessId)
@@ -3998,8 +4219,8 @@ async function stopProcessTree(child2, capturedProcesses = []) {
   if (exitedAfterTermination && descendantsExitedAfterTermination) {
     return;
   }
-  signalCapturedProcessGroups(processes, childProcessId, FORCED_STOP_SIGNAL);
-  forceTerminateProcess(child2);
+  hostPlatform.signalCapturedProcesses(processes, childProcessId, FORCED_STOP_SIGNAL);
+  hostPlatform.terminateProcess(child2, "SIGKILL");
   const [exitedAfterForce, descendantsExitedAfterForce] = await Promise.all([
     waitForProcessExit(child2, PROCESS_FORCED_STOP_TIMEOUT_MILLISECONDS),
     waitForCapturedProcessesExit(processes, childProcessId)
@@ -4034,9 +4255,10 @@ function waitForProcessExit(child2, timeoutMilliseconds) {
 async function runBoundedProcess(options) {
   options.signal.throwIfAborted();
   const outputLimitBytes = options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES;
-  const child2 = spawn(options.command, [...options.arguments], {
+  const launch = executableLaunch2(options.command, options.arguments);
+  const child2 = spawn(launch.command, [...launch.arguments], {
     cwd: options.cwd,
-    detached: process.platform !== "win32",
+    ...hostPlatform.spawnOptions,
     env: { ...options.environment },
     shell: false,
     stdio: ["ignore", "pipe", "pipe"]
@@ -4145,6 +4367,10 @@ async function runBoundedProcess(options) {
     }
   }
 }
+function executableLaunch2(command, args) {
+  return hostPlatform.executableLaunch(command, args);
+}
+var platformSpawnOptions = hostPlatform.spawnOptions;
 
 // src/agent-catalog/local-agent.ts
 function readTrustedIdentity(path3) {
@@ -4537,8 +4763,8 @@ function formatAgentDiagnostics(inventory, json2, verbose = false) {
 }
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir, mkdtemp, open, realpath as realpath3, rename, rm, stat as stat3 } from "node:fs/promises";
-import { delimiter, dirname, isAbsolute as isAbsolute2, join as join4, relative, sep } from "node:path";
+import { mkdir, mkdtemp, open, realpath as realpath4, rename, rm, stat as stat3 } from "node:fs/promises";
+import { delimiter, dirname as dirname2, isAbsolute as isAbsolute2, join as join6, relative, sep } from "node:path";
 var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
 var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -4589,7 +4815,7 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join4(root, "node_modules", ...packageName.split("/"));
+  return join6(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
@@ -4694,14 +4920,14 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   }
 }
 async function verifyRequiredDependency(rootPath, lock, definition) {
-  const dependencyRoot = await realpath3(packagePath(rootPath, definition.packageName));
+  const dependencyRoot = await realpath4(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, dependencyRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The required managed npm dependency escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join4(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join6(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4723,15 +4949,15 @@ async function validateManagedNpmPackage(root, definition) {
   }
 }
 async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath3(root);
-  const packageRoot = await realpath3(packagePath(rootPath, definition.packageName));
+  const rootPath = await realpath4(root);
+  const packageRoot = await realpath4(packagePath(rootPath, definition.packageName));
   if (!isContainedPath(rootPath, packageRoot)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
       "The managed npm package escaped its private cache"
     );
   }
-  const metadata = await readJsonRecord(join4(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join6(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4739,14 +4965,14 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    const lock = await readJsonRecord(join4(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
+    const lock = await readJsonRecord(join6(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
     verifyPackageLockEntry(lock, definition, definition.verifyDependencyClosure);
     for (const dependency of definition.requiredDependencies) {
       await verifyRequiredDependency(rootPath, lock, dependency);
     }
   }
   const declaredBin = readBinPath(metadata, definition.executableName);
-  const executable = await resolveExecutablePath(join4(packageRoot, declaredBin));
+  const executable = await resolveExecutablePath(join6(packageRoot, declaredBin));
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -4768,9 +4994,9 @@ var ManagedNpmPackageInstaller = class {
         throw error62;
       }
     }
-    const parent = dirname(root);
+    const parent = dirname2(root);
     await mkdir(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(join4(parent, `.${definition.version}.staging-`));
+    const staging = await mkdtemp(join6(parent, `.${definition.version}.staging-`));
     try {
       const npm = await findExecutableOnPath(process.platform === "win32" ? "npm.cmd" : "npm", environment);
       if (npm === null) {
@@ -4796,14 +5022,14 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join4(staging, "home"),
+        HOME: join6(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join4(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join6(staging, ".npm-cache"),
         NPM_CONFIG_FUND: "false",
         NPM_CONFIG_IGNORE_SCRIPTS: "true",
         NPM_CONFIG_PACKAGE_LOCK: "true",
         NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
-        PATH: `${dirname(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+        PATH: `${dirname2(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
       };
       if (definition.includeOptionalDependencies) {
         installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
@@ -4820,8 +5046,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm(join4(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm(join4(staging, "home"), { force: true, recursive: true })
+        rm(join6(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join6(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
@@ -4857,7 +5083,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 
 // src/agent-catalog/version-output.ts
 function normalizeVersionOutput(output2) {
@@ -4880,7 +5106,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join5(stateDirectory, ...this.managedAgentExecutablePath),
+      join7(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -10112,7 +10338,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve9) {
+function isRecursive(inst, stack, resolve10) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -10122,7 +10348,7 @@ function isRecursive(inst, stack, resolve9) {
   let result = NONE;
   const check2 = (child2) => {
     if (result !== PROVEN && child2?._zod) {
-      const answer = isRecursive(child2, stack, resolve9);
+      const answer = isRecursive(child2, stack, resolve10);
       if (answer > result)
         result = answer;
     }
@@ -10133,7 +10359,7 @@ function isRecursive(inst, stack, resolve9) {
       const desc2 = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc2.enumerable)
         continue;
-      const child2 = desc2.get ? ASSUMED : desc2.value?._zod ? isRecursive(desc2.value, stack, resolve9) : NONE;
+      const child2 = desc2.get ? ASSUMED : desc2.value?._zod ? isRecursive(desc2.value, stack, resolve10) : NONE;
       if (child2 > answer)
         answer = child2;
     }
@@ -10197,7 +10423,7 @@ function isRecursive(inst, stack, resolve9) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve9 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve10 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -25032,9 +25258,10 @@ var CodexAppServerClient = class {
   #pendingFragments = [];
   constructor(options) {
     this.#handlers = options.handlers;
-    this.#child = spawn2(options.command, ["app-server"], {
+    const launch = executableLaunch2(options.command, ["app-server"]);
+    this.#child = spawn2(launch.command, [...launch.arguments], {
       cwd: options.cwd,
-      detached: process.platform !== "win32",
+      ...platformSpawnOptions,
       env: { ...process.env, ...options.environment },
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -28767,7 +28994,7 @@ var AgentProbeError = class extends Error {
 };
 
 // src/agent-catalog/agents/resolve-user-local-executable.ts
-import { isAbsolute as isAbsolute4, join as join6 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join8 } from "node:path";
 async function resolveUserLocalExecutable(executableName, context) {
   context.signal.throwIfAborted();
   const platform = context.platform ?? process.platform;
@@ -28775,7 +29002,7 @@ async function resolveUserLocalExecutable(executableName, context) {
   if (platform === "win32" || homeDirectory === void 0 || !isAbsolute4(homeDirectory)) {
     return [];
   }
-  const executable = await resolveExecutablePath(join6(homeDirectory, ".local", "bin", executableName), platform);
+  const executable = await resolveExecutablePath(join8(homeDirectory, ".local", "bin", executableName), platform);
   context.signal.throwIfAborted();
   return executable === null ? [] : [executable];
 }
@@ -28864,8 +29091,8 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
-import { mkdir as mkdir2, realpath as realpath4, stat as stat4, writeFile } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join8, normalize } from "node:path";
+import { mkdir as mkdir2, realpath as realpath5, stat as stat4, writeFile } from "node:fs/promises";
+import { isAbsolute as isAbsolute5, join as join10, normalize } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -28883,13 +29110,13 @@ var DEEPSEEK_HARNESS_PACKAGE = new DeepSeekHarnessManagedPackage(
 
 // src/storage/state-directory.ts
 import { homedir } from "node:os";
-import { join as join7, resolve as resolve2 } from "node:path";
+import { join as join9, resolve as resolve3 } from "node:path";
 function readStateDirectory(environment = process.env) {
   const configured = environment["MOBIUS_STATE_DIRECTORY"]?.trim();
   if (configured !== void 0 && configured.length > 0) {
-    return resolve2(configured);
+    return resolve3(configured);
   }
-  return join7(homedir(), ".mobius");
+  return join9(homedir(), ".mobius");
 }
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
@@ -28907,13 +29134,13 @@ async function prepareAgentHome(path3, imagePrompts) {
     if (imagePrompts) {
       await mkdir2(path3, { mode: 448, recursive: true });
     }
-    const resolved = await realpath4(path3);
+    const resolved = await realpath5(path3);
     const metadata = await stat4(resolved);
     if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
       throw new Error("Agent home is not a user-owned directory");
     }
     if (imagePrompts) {
-      await writeFile(join8(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
+      await writeFile(join10(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
         mode: 384
       });
     }
@@ -28961,7 +29188,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join8(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join10(readStateDirectory(context.environment), "agents", this.id, "home");
         managedHome = true;
       }
     } catch {
@@ -28977,7 +29204,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join8(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join10(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -29031,8 +29258,8 @@ var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/grok-build-agent.ts
-import { realpath as realpath5 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join9, relative as relative2, sep as sep2 } from "node:path";
+import { realpath as realpath6 } from "node:fs/promises";
+import { isAbsolute as isAbsolute6, join as join11, relative as relative2, sep as sep2 } from "node:path";
 import {
   RequestError
 } from "@agentclientprotocol/sdk";
@@ -29102,8 +29329,8 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       );
       if (managed.path === agent.path) {
         return Object.freeze({
-          GROK_HOME: await realpath5(
-            join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+          GROK_HOME: await realpath6(
+            join11(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -29114,9 +29341,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath5(join9(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
-    await validateManagedNpmPackage(join9(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
-    const executable = await resolveExecutablePath(join9(versionRoot, "home", "bin", "grok"), platform);
+    const versionRoot = await realpath6(join11(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
+    await validateManagedNpmPackage(join11(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
+    const executable = await resolveExecutablePath(join11(versionRoot, "home", "bin", "grok"), platform);
     signal.throwIfAborted();
     if (executable === null || !isContainedPath2(versionRoot, executable.path)) {
       throw new AgentProbeError("managed_agent_invalid", "The managed Grok Build executable is invalid");
@@ -29216,13 +29443,13 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { chmod, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open3, realpath as realpath6, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname2, isAbsolute as isAbsolute7, join as join10, relative as relative3, sep as sep3 } from "node:path";
+import { chmod as chmod2, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp2, open as open3, realpath as realpath7, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute7, join as join12, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -29402,16 +29629,16 @@ async function readManifest(path3) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath6(root);
+    const rootPath = await realpath7(root);
     const rootMetadata = await stat5(rootPath);
     if (!rootMetadata.isDirectory() || typeof process.getuid === "function" && rootMetadata.uid !== process.getuid()) {
       throw new Error("Managed Agent root is not user-owned");
     }
-    const manifest = await readManifest(join10(rootPath, "archive.json"));
+    const manifest = await readManifest(join12(rootPath, "archive.json"));
     if (manifest["archiveSha256"] !== definition.archiveSha256 || manifest["archiveUrl"] !== definition.archiveUrl.toString() || manifest["version"] !== definition.version || typeof manifest["executableSha256"] !== "string") {
       throw new Error("Managed Agent archive identity is invalid");
     }
-    const executable = await resolveExecutablePath(join10(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join12(rootPath, "bin", definition.executableName));
     if (executable === null || !isContainedPath3(rootPath, executable.path) || await hashFile(executable.path, signal) !== manifest["executableSha256"]) {
       throw new Error("Managed Agent executable is invalid");
     }
@@ -29577,7 +29804,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
     return Object.freeze(environment);
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join11(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join13(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -29595,7 +29822,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 import {
   methods as methods4
 } from "@agentclientprotocol/sdk";
@@ -29654,7 +29881,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join12(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join14(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -29692,7 +29919,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -29738,7 +29965,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join13(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join15(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -29975,9 +30202,10 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
       signal.removeEventListener("abort", abort);
     }
   }
-  const child2 = spawn3(agent.adapterPath, [...agent.arguments], {
+  const launch = executableLaunch2(agent.adapterPath, agent.arguments);
+  const child2 = spawn3(launch.command, [...launch.arguments], {
     cwd: defaultWorkspace,
-    detached: process.platform !== "win32",
+    ...platformSpawnOptions,
     env: { ...environment, ...agent.environment },
     shell: false,
     stdio: ["pipe", "pipe", "pipe"]
@@ -30110,10 +30338,10 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute8, join as join15 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join17 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -30170,7 +30398,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join14(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join16(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -30204,7 +30432,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join15(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join17(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -30518,16 +30746,16 @@ async function discoverLocalAgentInventory(options) {
 }
 
 // src/config.ts
-import { join as join16, resolve as resolve3 } from "node:path";
+import { join as join18, resolve as resolve4 } from "node:path";
 function loadDefaultWorkspace(environment = process.env) {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
-  return configuredWorkspace ?? join16(readStateDirectory(environment), "workspace");
+  return configuredWorkspace ?? join18(readStateDirectory(environment), "workspace");
 }
 var DaemonLocalContext = class {
   environment;
   stateDirectory;
   constructor(stateDirectory, environment = process.env) {
-    this.stateDirectory = resolve3(stateDirectory);
+    this.stateDirectory = resolve4(stateDirectory);
     this.environment = Object.freeze({ ...environment, MOBIUS_STATE_DIRECTORY: this.stateDirectory });
   }
 };
@@ -30570,15 +30798,14 @@ function createDaemonConfig(connection, agents = [], installableAgents = [], loc
 // src/daemon-manager.ts
 import { spawn as spawn6 } from "node:child_process";
 import { createHash as createHash9, randomBytes } from "node:crypto";
-import { readFile as readFile3, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile4, unlink as unlink3, writeFile as writeFile5 } from "node:fs/promises";
 import { createConnection, createServer } from "node:net";
-import { tmpdir } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir5, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { mkdir as mkdir5, realpath as realpath8, stat as stat6 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename, resolve as resolve5 } from "node:path";
+import { basename, resolve as resolve6 } from "node:path";
 import { fetch as fetch3 } from "undici";
 
 // src/agent-catalog/publish-agent-catalog.ts
@@ -30749,8 +30976,21 @@ async function unchangedIdentity(agent, signal) {
 
 // src/storage/runtime-installation-store.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { mkdir as mkdir4, open as open4, readdir as readdir2, rename as rename3, unlink, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join17, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir4, open as open4, readdir as readdir2, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4, join as join19, resolve as resolve5 } from "node:path";
+
+// src/filesystem/private-path.ts
+import { lstat as lstat2 } from "node:fs/promises";
+async function validateLocalPath(path3, directory, privateAccess, signal) {
+  signal.throwIfAborted();
+  const metadata = await lstat2(path3);
+  if (metadata.isSymbolicLink() || (directory ? !metadata.isDirectory() : !metadata.isFile())) {
+    throw new LocalPathError("Unsafe local path");
+  }
+  await platformSupportFor(process.platform).validatePathPermissions(path3, directory, privateAccess, signal);
+}
+
+// src/storage/runtime-installation-store.ts
 var APPLICATION_ID_PATTERN = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){1,31}$/;
 var CONNECTION_ID_PATTERN = /^mcn_[a-f0-9]{32}$/;
 var INSTALLATION_ID_PATTERN = /^min_[a-f0-9]{32}$/;
@@ -30992,8 +31232,8 @@ async function readJsonFile(path3, signal, missingCode) {
 }
 async function writeJsonAtomically(path3, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname3(path3);
-  const temporaryPath = join17(directory, `.${randomUUID()}.tmp`);
+  const directory = dirname4(path3);
+  const temporaryPath = join19(directory, `.${randomUUID()}.tmp`);
   try {
     await mkdir4(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -31002,7 +31242,7 @@ async function writeJsonAtomically(path3, value, signal) {
     signal.throwIfAborted();
     await rename3(temporaryPath, path3);
   } catch (cause) {
-    await unlink(temporaryPath).catch(() => void 0);
+    await unlink2(temporaryPath).catch(() => void 0);
     signal.throwIfAborted();
     throw new RuntimeInstallationStoreError("connection_unavailable", "The local Runtime state cannot be written", {
       cause
@@ -31019,15 +31259,17 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join17(stateDirectory, "channels");
-    this.#connectionDirectory = join17(stateDirectory, "connections");
+    this.#channelDirectory = join19(stateDirectory, "channels");
+    this.#connectionDirectory = join19(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
-    const rootDirectory = resolve4(options.stateDirectory);
-    const applicationDirectory = join17(rootDirectory, "installations", applicationId);
+    const rootDirectory = resolve5(options.stateDirectory);
+    const applicationDirectory = join19(rootDirectory, "installations", applicationId);
     try {
+      await mkdir4(rootDirectory, { mode: 448, recursive: true });
+      await validateLocalPath(rootDirectory, true, true, signal);
       await mkdir4(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
       throw new RuntimeInstallationStoreError(
@@ -31039,7 +31281,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join17(applicationDirectory, storedInstallationId);
+    const stateDirectory = join19(applicationDirectory, storedInstallationId);
     try {
       await mkdir4(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -31054,8 +31296,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join17(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join17(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join19(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join19(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -31178,9 +31420,9 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     const connection = await this.readConnection(connectionId2, signal);
     signal.throwIfAborted();
     try {
-      await unlink(this.connectionPath(connection.connectionId));
+      await unlink2(this.connectionPath(connection.connectionId));
       signal.throwIfAborted();
-      await unlink(this.channelIndexPath(connection.channelId));
+      await unlink2(this.channelIndexPath(connection.channelId));
     } catch (cause) {
       signal.throwIfAborted();
       if (isNodeError(cause, "ENOENT")) {
@@ -31217,7 +31459,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join17(applicationDirectory, "current.json");
+  const pointerPath = join19(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -31355,10 +31597,10 @@ function parseResumeConnectionId(arguments_) {
   return value;
 }
 async function resolveDefaultWorkspace(path3) {
-  const requestedWorkspace = resolve5(path3);
+  const requestedWorkspace = resolve6(path3);
   try {
     await mkdir5(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath7(requestedWorkspace);
+    const defaultWorkspace = await realpath8(requestedWorkspace);
     const metadata = await stat6(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
@@ -31580,7 +31822,7 @@ var AuditStore = class {
 
 // src/run-daemon.ts
 import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 import { styleText } from "node:util";
 
 // src/acp/active-executions.ts
@@ -31671,7 +31913,7 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open5, readFile as readFile2, realpath as realpath8, stat as stat7 } from "node:fs/promises";
+import { open as open5, readFile as readFile3, realpath as realpath9, stat as stat7 } from "node:fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute9, normalize as normalize2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
@@ -31694,7 +31936,7 @@ var LocalRasterImage = class {
     this.sourceUri = sourceUri;
   }
   base64 = async () => {
-    const bytes = this.bytes ?? new Uint8Array(await readFile2(this.sourceUri));
+    const bytes = this.bytes ?? new Uint8Array(await readFile3(this.sourceUri));
     return Buffer.from(bytes).toString("base64");
   };
 };
@@ -31742,7 +31984,7 @@ async function resolveCanonicalPath(requested, signal) {
     return null;
   }
   try {
-    const target = await realpath8(requested);
+    const target = await realpath9(requested);
     signal.throwIfAborted();
     if (!isAbsolute9(target) || normalize2(target) !== target) {
       return null;
@@ -32323,7 +32565,7 @@ function createWritableAcpStream(output2) {
       if (outputFailure !== void 0) {
         return Promise.reject(outputFailure);
       }
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         pendingWriteFailures.add(reject);
         output2.write(chunk, (error62) => {
           pendingWriteFailures.delete(reject);
@@ -32336,7 +32578,7 @@ function createWritableAcpStream(output2) {
             reject(outputFailure);
             return;
           }
-          resolve9();
+          resolve10();
         });
       });
     }
@@ -32358,9 +32600,10 @@ var AgentConnection = class {
       this.connection = createAcpClient(client2).connect(inProcess.app());
       return;
     }
-    const child2 = spawn4(agent.adapterPath, [...agent.arguments], {
+    const launch = executableLaunch2(agent.adapterPath, agent.arguments);
+    const child2 = spawn4(launch.command, [...launch.arguments], {
       cwd,
-      detached: process.platform !== "win32",
+      ...platformSpawnOptions,
       env: { ...process.env, ...agent.environment },
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -32377,12 +32620,12 @@ var AgentConnection = class {
     stderr.on("data", (chunk) => {
       process.stderr.write(`[${agent.id}-acp] ${chunk}`);
     });
-    this.termination = new Promise((resolve9) => {
+    this.termination = new Promise((resolve10) => {
       child2.once("error", (cause) => {
-        resolve9({ kind: "failed", error: new AcpExecutionError("The ACP process could not run", { cause }) });
+        resolve10({ kind: "failed", error: new AcpExecutionError("The ACP process could not run", { cause }) });
       });
       child2.once("exit", (code, signal) => {
-        resolve9({
+        resolve10({
           kind: "failed",
           error: new AcpExecutionError("The ACP process stopped", { cause: { code, signal } })
         });
@@ -34538,7 +34781,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join23(chunks, separator) {
+  function join25(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) result.push(separator);
@@ -34546,7 +34789,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join23;
+  _sql.join = join25;
   function identifier2(value) {
     return new Name(value);
   }
@@ -36691,7 +36934,7 @@ var SQLiteSelectBase = class extends TypedQueryBuilder {
       const baseTableName = this.tableName;
       const tableName = getTableLikeName(table);
       for (const item of extractUsedTable(table)) this.usedTables.add(item);
-      if (typeof tableName === "string" && this.config.joins?.some((join23) => join23.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join25) => join25.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (!this.isPartialSelect) {
         if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") this.config.fields = { [baseTableName]: this.config.fields };
         if (typeof tableName === "string" && !is(table, SQL)) {
@@ -37530,7 +37773,7 @@ var SQLiteDialect = class {
       if (!joins2) return;
       const withEntries = Object.entries(joins2).filter(([_, v]) => v);
       if (!withEntries.length) return;
-      return sql.join(withEntries.map(([k, join23]) => {
+      return sql.join(withEntries.map(([k, join25]) => {
         const relation = tableConfig.relations[k];
         const isSingle2 = is(relation, One);
         const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -37541,7 +37784,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join23,
+          queryConfig: join25,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -37555,7 +37798,7 @@ var SQLiteDialect = class {
           key: k,
           selection: innerQuery.selection,
           isArray: !isSingle2,
-          isOptional: (relation.optional ?? false) || join23 !== true && !!join23.where
+          isOptional: (relation.optional ?? false) || join25 !== true && !!join25.where
         });
         const jsonColumns = sql.join(innerQuery.selection.map((s) => {
           return sql`${sql.raw(this.escapeString(s.key))}, ${s.selection ? sql`${jsonb}(${sql.identifier(s.key)})` : sql.identifier(s.key)}`;
@@ -38171,7 +38414,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join23) => join23.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join25) => join25.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
       if (typeof on === "function") {
         const from = this.config.from ? is(table, SQLiteTable) ? table[Table.Symbol.Columns] : is(table, Subquery) ? table._.selectedFields : is(table, SQLiteViewBase) ? table[ViewBaseConfig].selectedFields : void 0 : void 0;
         on = on(new Proxy(this.config.table[Table.Symbol.Columns], new SelectionProxyHandler({
@@ -40830,8 +41073,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
-import { lstat, mkdir as mkdir6, readdir as readdir3, realpath as realpath9, rename as rename4, rm as rm3, stat as stat8, utimes, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join18 } from "node:path";
+import { lstat as lstat3, mkdir as mkdir6, readdir as readdir3, realpath as realpath10, rename as rename4, rm as rm3, stat as stat8, utimes, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5, join as join20 } from "node:path";
 var contentRequest = /^mobius-content:(image|audio|resource):([a-f0-9]{64})$/u;
 var CONTENT_LIFETIME_MILLISECONDS = 24 * 60 * 60 * 1e3;
 var metadataSchema2 = external_exports.strictObject({
@@ -40867,7 +41110,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join18(stateDirectory, "tmp", "session-content", randomUUID3());
+    this.#root = join20(stateDirectory, "tmp", "session-content", randomUUID3());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -40878,11 +41121,11 @@ var LocalExternalContentStore = class {
       await mkdir6(this.#root, { mode: 448, recursive: true });
       const now = /* @__PURE__ */ new Date();
       await utimes(this.#root, now, now);
-      for (const directory of await readdir3(dirname4(this.#root), { withFileTypes: true })) {
+      for (const directory of await readdir3(dirname5(this.#root), { withFileTypes: true })) {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path3 = join18(dirname4(this.#root), directory.name);
+        const path3 = join20(dirname5(this.#root), directory.name);
         if (path3 === this.#root) {
           continue;
         }
@@ -40932,10 +41175,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join18(this.#root, kind);
+    const directory = join20(this.#root, kind);
     await mkdir6(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path3 = join18(directory, key);
+    const path3 = join20(directory, key);
     const write = atomicWrite(path3, bytes, active);
     await write;
     active.throwIfAborted();
@@ -40968,12 +41211,12 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath9(dirname4(entry.path)),
-        realpath9(entry.path),
-        lstat(entry.path)
+        realpath10(dirname5(entry.path)),
+        realpath10(entry.path),
+        lstat3(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || file2.isSymbolicLink() || dirname4(resolvedPath) !== resolvedDirectory) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname5(resolvedPath) !== resolvedDirectory) {
         return null;
       }
       return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
@@ -42274,7 +42517,7 @@ var AgentInstallationManager = class {
 
 // src/agent-installation/fixed-installation-executor.ts
 import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 function findSpecification(specifications, agentId) {
   for (const specification of specifications) {
     if (specification.id === agentId) {
@@ -42285,7 +42528,7 @@ function findSpecification(specifications, agentId) {
 }
 function resolveDefaultWorkspace2(path3) {
   try {
-    const directory = realpathSync2(resolve6(path3));
+    const directory = realpathSync2(resolve7(path3));
     if (!statSync2(directory).isDirectory()) {
       throw new Error("Default workspace is not a directory");
     }
@@ -42300,7 +42543,7 @@ function resolveDefaultWorkspace2(path3) {
 }
 function resolveIntegrationStateDirectory(path3) {
   try {
-    const directory = realpathSync2(resolve6(path3));
+    const directory = realpathSync2(resolve7(path3));
     const metadata = statSync2(directory);
     if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
       throw new Error("Installation directory is not user-owned");
@@ -42472,9 +42715,9 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir4, realpath as realpath10, stat as stat9 } from "node:fs/promises";
+import { readdir as readdir4, realpath as realpath11, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute10, join as join19, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename4, dirname as dirname6, isAbsolute as isAbsolute10, join as join21, normalize as normalize3, relative as relative4 } from "node:path";
 
 // src/authorization/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
@@ -42553,7 +42796,7 @@ var WorkspaceDirectoryService = class {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
-      const target = await realpath10(requested);
+      const target = await realpath11(requested);
       signal.throwIfAborted();
       const metadata = await stat9(target);
       signal.throwIfAborted();
@@ -42603,7 +42846,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path3 = await this.resolvePath(join19(target, child2.name), signal);
+          const path3 = await this.resolvePath(join21(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path3), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -42613,7 +42856,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname5(target);
+      const parent = dirname6(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -42639,15 +42882,15 @@ var WorkspaceDirectoryService = class {
 
 // src/daemon-diagnostic-log.ts
 import { appendFileSync, mkdirSync, readFileSync as readFileSync2, renameSync, statSync as statSync3, writeFileSync } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 var MAXIMUM_DAEMON_LOG_BYTES = 1 * 1024 * 1024;
 var DaemonDiagnosticLog = class {
   #directory;
   #path;
   #maximumBytes;
   constructor(stateDirectory, maximumBytes = MAXIMUM_DAEMON_LOG_BYTES) {
-    this.#directory = join20(stateDirectory, "logs");
-    this.#path = join20(this.#directory, "daemon.log");
+    this.#directory = join22(stateDirectory, "logs");
+    this.#path = join22(this.#directory, "daemon.log");
     this.#maximumBytes = maximumBytes;
   }
   // Export only correlation and failure metadata. Local messages and paths stay local.
@@ -43463,7 +43706,7 @@ var ActiveDaemonTurn = class {
 var MAX_SESSIONS_WITH_COMPLETED_RECOVERY = 32;
 var waitForTurnCompletion = (turn, waitSignal) => {
   waitSignal.throwIfAborted();
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let settled = false;
     const finish = (result) => {
       if (settled) {
@@ -43472,7 +43715,7 @@ var waitForTurnCompletion = (turn, waitSignal) => {
       settled = true;
       waitSignal.removeEventListener("abort", onAbort);
       if (result.kind === "completed") {
-        resolve9();
+        resolve10();
       } else {
         reject(result.error);
       }
@@ -43670,7 +43913,7 @@ var sessionEventCacheMigrations = [
 
 // src/infra/local-sqlite-database.ts
 import { chmodSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 
 // ../../node_modules/.pnpm/drizzle-orm@1.0.0-rc.4_@cloudflare+workers-types@5.20260918.1_@types+better-sqlite3@7.6_f872c171b7e1945bb1fa42180063dab2/node_modules/drizzle-orm/node-sqlite/session.js
@@ -43781,7 +44024,7 @@ var LocalSqliteDatabase = class {
   orm;
   #sqlite;
   constructor(path3, label, migrations, pragmas = []) {
-    mkdirSync2(dirname6(path3), { mode: 448, recursive: true });
+    mkdirSync2(dirname7(path3), { mode: 448, recursive: true });
     this.#sqlite = new DatabaseSync2(path3);
     chmodSync(path3, 384);
     try {
@@ -44340,10 +44583,11 @@ async function readCodexHistoryWithOptions(agent, cwd, nativeSessionId, signal,
     );
   }
   signal.throwIfAborted();
-  const child2 = spawn5(agent.agentIdentity.realPath, ["app-server"], {
+  const launch = executableLaunch2(agent.agentIdentity.realPath, ["app-server"]);
+  const child2 = spawn5(launch.command, [...launch.arguments], {
     cwd,
     env: { ...process.env, ...agent.environment },
-    detached: process.platform !== "win32",
+    ...platformSpawnOptions,
     shell: false,
     stdio: ["pipe", "pipe", "ignore"]
   });
@@ -45769,8 +46013,8 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { realpath as realpath11, stat as stat10 } from "node:fs/promises";
-import { basename as basename5, extname, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve7 } from "node:path";
+import { realpath as realpath12, stat as stat10 } from "node:fs/promises";
+import { basename as basename5, extname as extname2, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
@@ -45792,12 +46036,12 @@ async function resolveFile(value, workingDirectory, signal) {
   if (path3 === null || !isAbsolute11(path3) && workingDirectory === null) {
     return null;
   }
-  const requested = workingDirectory === null ? path3 : resolve7(workingDirectory, path3);
+  const requested = workingDirectory === null ? path3 : resolve8(workingDirectory, path3);
   if (!isAbsolute11(requested) || isAbsolute11(path3) && normalize4(path3) !== path3) {
     return null;
   }
   try {
-    const target = await realpath11(requested);
+    const target = await realpath12(requested);
     signal.throwIfAborted();
     return isAbsolute11(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -45820,7 +46064,7 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
   send2({
     byteLength: before.size,
     kind: FILE_BEGIN_KIND,
-    mediaType: external?.mediaType ?? raster?.mimeType ?? (extname(target).toLowerCase() === ".svg" ? "image/svg+xml" : "application/octet-stream"),
+    mediaType: external?.mediaType ?? raster?.mimeType ?? (extname2(target).toLowerCase() === ".svg" ? "image/svg+xml" : "application/octet-stream"),
     modifiedAt: before.mtime.toISOString(),
     name: external?.name ?? (basename5(target) || "file"),
     requestId: command.requestId,
@@ -46722,13 +46966,13 @@ function createNativeSessionRequestHandler(dependencies) {
         operationSignal.throwIfAborted();
         const skipPrevious = command.action === "active-turn";
         if (previous.length > 0 && !skipPrevious) {
-          await new Promise((resolve9, reject) => {
+          await new Promise((resolve10, reject) => {
             const onAbort = () => reject(operationSignal.reason);
             operationSignal.addEventListener("abort", onAbort, { once: true });
             void Promise.all(previous.map((request) => request.completion)).then(
               () => {
                 operationSignal.removeEventListener("abort", onAbort);
-                resolve9();
+                resolve10();
               },
               (error62) => {
                 operationSignal.removeEventListener("abort", onAbort);
@@ -47162,7 +47406,7 @@ var RelayConnectionError = class extends Error {
 };
 function connectRelay(url2, signal) {
   signal.throwIfAborted();
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const endpoint = new URL(url2);
     const headers = runtimeAuthorization(endpoint);
     endpoint.searchParams.delete("token");
@@ -47229,7 +47473,7 @@ function connectRelay(url2, signal) {
       }
       finished = true;
       cleanup();
-      resolve9(socket);
+      resolve10(socket);
     };
     function onTimeout() {
       fail(
@@ -47411,7 +47655,7 @@ async function runRelayConnection({
   installationObserver.connect(socket);
   onConnected();
   try {
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       let finished = false;
       const cleanup = () => {
         connectionLiveness.close();
@@ -47429,7 +47673,7 @@ async function runRelayConnection({
         }
         finished = true;
         cleanup();
-        resolve9();
+        resolve10();
       };
       const rejectConnection = (failure2) => {
         if (finished) {
@@ -47815,12 +48059,12 @@ function waitForRelayRetry(signal, timer) {
   if (signal.aborted) {
     return Promise.resolve();
   }
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const retry = timer.schedule(finish, RELAY_RECONNECT_DELAY_MILLISECONDS);
     function finish() {
       retry.cancel();
       signal.removeEventListener("abort", finish);
-      resolve9();
+      resolve10();
     }
     signal.addEventListener("abort", finish, { once: true });
   });
@@ -47876,11 +48120,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const channelHash = createHash8("sha256").update(config2.channelId).digest("hex");
-  const sessionDatabase = openAcpSessionDatabase(join21(stateDirectory, "sessions", `${channelHash}.sqlite`));
+  const sessionDatabase = openAcpSessionDatabase(join23(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
     eventsV2 = new CachedAcpSessionEventStoreV2(
-      openSessionEventCacheV2Database(join21(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
+      openSessionEventCacheV2Database(join23(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
     );
   } catch (error62) {
     sessionDatabase.close();
@@ -48147,17 +48391,17 @@ var START_TIMEOUT_MILLISECONDS = 12e4;
 var MAXIMUM_MESSAGE_BYTES = 64 * 1024;
 var CONNECTION_ID_PATTERN2 = /^mcn_[a-f0-9]{32}$/;
 async function acquireManagerLock(stateDirectory) {
-  const path3 = join22(stateDirectory, "manager.lock");
+  const path3 = join24(stateDirectory, "manager.lock");
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
       await writeFile5(path3, `${process.pid.toString()}
 `, { flag: "wx", mode: 384 });
-      return async () => await unlink2(path3).catch(() => void 0);
+      return async () => await unlink3(path3).catch(() => void 0);
     } catch (cause) {
       if (!isNodeError2(cause, "EEXIST")) {
         throw cause;
       }
-      const encoded = await readFile3(path3, "utf8").catch(() => "");
+      const encoded = await readFile4(path3, "utf8").catch(() => "");
       const pid = Number(encoded.trim());
       if (Number.isSafeInteger(pid) && pid > 1) {
         try {
@@ -48169,7 +48413,7 @@ async function acquireManagerLock(stateDirectory) {
           }
         }
       }
-      await unlink2(path3).catch(() => void 0);
+      await unlink3(path3).catch(() => void 0);
     }
   }
   return null;
@@ -48177,17 +48421,18 @@ async function acquireManagerLock(stateDirectory) {
 function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var managerPlatform = platformSupportFor(process.platform);
 function controlSocketPath(stateDirectory) {
   const installationHash = createHash9("sha256").update(stateDirectory).digest("hex").slice(0, 32);
-  return process.platform === "win32" ? `\\\\.\\pipe\\mobius-${installationHash}` : join22(tmpdir(), `mobius-${installationHash}.sock`);
+  return managerPlatform.controlSocketPath(installationHash);
 }
 function controlTokenPath(stateDirectory) {
-  return join22(stateDirectory, "manager.token");
+  return join24(stateDirectory, "manager.token");
 }
 async function readOrCreateControlToken(stateDirectory) {
   const path3 = controlTokenPath(stateDirectory);
   try {
-    return (await readFile3(path3, "utf8")).trim();
+    return (await readFile4(path3, "utf8")).trim();
   } catch (cause) {
     if (!isNodeError2(cause, "ENOENT")) {
       throw cause;
@@ -48202,7 +48447,7 @@ async function readOrCreateControlToken(stateDirectory) {
     if (!isNodeError2(cause, "EEXIST")) {
       throw cause;
     }
-    return (await readFile3(path3, "utf8")).trim();
+    return (await readFile4(path3, "utf8")).trim();
   }
 }
 function isNodeError2(error62, code) {
@@ -48421,9 +48666,9 @@ async function waitForReady(active, signal) {
     return;
   }
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(START_TIMEOUT_MILLISECONDS)]);
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve10, reject) => {
     const abort = () => reject(deadline.reason);
-    active.ready.then(resolve9, reject).finally(() => deadline.removeEventListener("abort", abort));
+    active.ready.then(resolve10, reject).finally(() => deadline.removeEventListener("abort", abort));
     deadline.addEventListener("abort", abort, { once: true });
   });
   if (active.status === "failed") {
@@ -48434,7 +48679,7 @@ function errorMessage2(error62) {
   return error62 instanceof Error ? error62.message : "Unknown failure";
 }
 async function readSocketMessage(socket, signal) {
-  return await new Promise((resolve9, reject) => {
+  return await new Promise((resolve10, reject) => {
     let encoded = "";
     const finish = (error62, value) => {
       signal.removeEventListener("abort", abort);
@@ -48442,7 +48687,7 @@ async function readSocketMessage(socket, signal) {
       socket.removeAllListeners("error");
       socket.removeAllListeners("end");
       if (error62 === void 0) {
-        resolve9(value);
+        resolve10(value);
       } else {
         reject(error62);
       }
@@ -48477,14 +48722,14 @@ async function sendControlRequest(stateDirectory, command, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(CONTROL_TIMEOUT_MILLISECONDS)]);
   const socket = createConnection(controlSocketPath(stateDirectory));
   try {
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       const abort = () => {
         socket.destroy();
         reject(deadline.reason);
       };
       socket.once("connect", () => {
         deadline.removeEventListener("abort", abort);
-        resolve9();
+        resolve10();
       });
       socket.once("error", reject);
       deadline.addEventListener("abort", abort, { once: true });
@@ -48499,6 +48744,7 @@ async function sendControlRequest(stateDirectory, command, signal) {
 async function spawnManager() {
   const child2 = spawn6(process.execPath, [process.argv[1] ?? "", "__manager"], {
     detached: true,
+    windowsHide: true,
     env: process.env,
     stdio: "ignore"
   });
@@ -48514,20 +48760,20 @@ async function waitForManagerExit(stateDirectory, signal) {
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(1e4)]);
   while (!deadline.aborted) {
     try {
-      await readFile3(join22(stateDirectory, "manager.lock"), "utf8");
+      await readFile4(join24(stateDirectory, "manager.lock"), "utf8");
     } catch (cause) {
       if (isNodeError2(cause, "ENOENT")) {
         return;
       }
       throw cause;
     }
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       const timeout = setTimeout(finish, 20);
       const abort = () => finish(deadline.reason);
       function finish(cause) {
         clearTimeout(timeout);
         deadline.removeEventListener("abort", abort);
-        cause === void 0 ? resolve9() : reject(cause);
+        cause === void 0 ? resolve10() : reject(cause);
       }
       deadline.addEventListener("abort", abort, { once: true });
     });
@@ -48577,13 +48823,13 @@ async function ensureMatchingManager(stateDirectory, managerVersion, signal) {
         await launchManager(managerVersion);
         managerStarted = true;
       }
-      await new Promise((resolve9, reject) => {
+      await new Promise((resolve10, reject) => {
         const timeout = setTimeout(finish, 50);
         const abort = () => finish(signal.reason);
         function finish(cause2) {
           clearTimeout(timeout);
           signal.removeEventListener("abort", abort);
-          cause2 === void 0 ? resolve9() : reject(cause2);
+          cause2 === void 0 ? resolve10() : reject(cause2);
         }
         signal.addEventListener("abort", abort, { once: true });
       });
@@ -48670,33 +48916,23 @@ async function runManager(installation, managerVersion, signal) {
       }
     })();
   });
-  if (process.platform !== "win32") {
-    await unlink2(socketPath).catch((cause) => {
-      if (!isNodeError2(cause, "ENOENT")) {
-        throw cause;
-      }
-    });
-  }
+  await managerPlatform.prepareControlSocket(socketPath);
   server.listen(socketPath);
-  await new Promise((resolve9, reject) => {
-    server.once("listening", resolve9);
+  await new Promise((resolve10, reject) => {
+    server.once("listening", resolve10);
     server.once("error", reject);
   });
-  if (process.platform !== "win32") {
-    await import("node:fs/promises").then(async ({ chmod: chmod2 }) => await chmod2(socketPath, 384));
-  }
+  await managerPlatform.secureControlSocket(socketPath);
   try {
-    await new Promise((resolve9) => combined.addEventListener("abort", () => resolve9(), { once: true }));
-    const serverClosed = new Promise((resolve9) => server.close(() => resolve9()));
+    await new Promise((resolve10) => combined.addEventListener("abort", () => resolve10(), { once: true }));
+    const serverClosed = new Promise((resolve10) => server.close(() => resolve10()));
     for (const socket of sockets) {
       socket.destroy();
     }
     await serverClosed;
     await supervisor.close();
   } finally {
-    if (process.platform !== "win32") {
-      await unlink2(socketPath).catch(() => void 0);
-    }
+    await managerPlatform.removeControlSocket(socketPath).catch(() => void 0);
     await releaseLock();
   }
 }
@@ -48839,7 +49075,7 @@ function createProgram() {
   });
   pair.command("list").description("list saved pairings").addOption(valueOption("--output-json <existing-file.json>", "write JSON to an existing file")).action(async (options) => {
     const installation = await openMobiusCliInstallation(shutdown.signal, process.env);
-    const outputPath = options.outputJson === void 0 ? null : resolve8(options.outputJson);
+    const outputPath = options.outputJson === void 0 ? null : resolve9(options.outputJson);
     const response = await requestManager(
       installation,
       package_default.version,