@moxt-ai/mobius 0.0.195 → 0.0.197

package/dist/index.js

@@ -32,7 +32,7 @@ var createAcpClient = (handler) => client({ name: "mobius" }).onRequest(
 })).onNotification("cursor/update_todos", discardExtensionParams, async () => Promise.resolve()).onNotification("cursor/task", discardExtensionParams, async () => Promise.resolve()).onNotification("cursor/generate_image", discardExtensionParams, async () => Promise.resolve());
 
 // src/config.ts
-import { join as join5, resolve as resolve3 } from "node:path";
+import { join as join7, resolve as resolve4 } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -5060,7 +5060,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;
@@ -5070,7 +5070,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;
     }
@@ -5081,7 +5081,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;
     }
@@ -5145,7 +5145,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;
     }
@@ -21830,17 +21830,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) {
@@ -21885,6 +21899,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(path2) {
+  try {
+    await unlink(path2);
+  } 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 (path2) => {
+    await chmod(path2, 384);
+  },
+  removeControlSocket,
+  pathDelimiter: ":",
+  environmentValue: (environment, name2) => environment[name2],
+  executableExtensions: () => [""],
+  resolveExecutableTarget: async (path2) => {
+    const target = await realpath(path2);
+    await access(target, constants.X_OK);
+    return target;
+  },
+  executableLaunch: (command, args) => ({ command, arguments: args }),
+  spawnOptions: { detached: true, windowsHide: true },
+  signalCapturedProcesses,
+  terminateProcess,
+  validatePathPermissions: async (path2, directory, privateAccess, signal) => {
+    signal.throwIfAborted();
+    const metadata = await lstat(path2);
+    if (process.getuid === void 0 || metadata.uid !== process.getuid()) {
+      throw new LocalPathError("Path is not user-owned");
+    }
+    if (privateAccess) {
+      await chmod(path2, directory ? 448 : 384);
+    }
+    signal.throwIfAborted();
+  }
+};
 
 // src/platform/linux.ts
 function appendLinuxProcessTableEntry(entries, processId, encoded) {
@@ -21916,7 +22005,7 @@ async function readLinuxProcessTable() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          await readFile(join("/proc", directory.name, "stat"), "utf8")
+          await readFile(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -21941,7 +22030,7 @@ function readLinuxProcessTableSynchronously() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          readFileSync(join("/proc", directory.name, "stat"), "utf8")
+          readFileSync(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -21957,11 +22046,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;
     }
@@ -21974,7 +22063,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);
@@ -21987,6 +22076,7 @@ function processExists2(processId) {
   return processExists(processId);
 }
 var linuxPlatform = {
+  ...posixOperations,
   readProcessTable: readLinuxProcessTableWithFallback,
   readProcessTableSynchronously: readLinuxProcessTableSynchronously,
   processExists: processExists2,
@@ -22018,7 +22108,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",
@@ -22029,14 +22119,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;
   },
@@ -22066,8 +22157,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(path2) {
+  let resolvedPath;
+  try {
+    resolvedPath = await realpath3(extname(path2) === "" ? `${path2}.cmd` : path2);
+  } catch (cause) {
+    if (extname(path2) !== "" || !(cause instanceof Error) || !("code" in cause) || cause.code !== "ENOENT") {
+      throw cause;
+    }
+    resolvedPath = await realpath3(path2);
+  }
+  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(path2, _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: path2,
+          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,
@@ -22078,7 +22360,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;
@@ -22117,14 +22399,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;
@@ -22133,28 +22407,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,
@@ -22170,15 +22430,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;
@@ -22199,7 +22460,7 @@ function appendBounded(chunks, chunk, currentBytes, limitBytes) {
   chunks.push(chunk);
   return nextBytes;
 }
-function readProcessTable() {
+function readProcessTable2() {
   return hostPlatform.readProcessTable();
 }
 function selectProcessTree(entries, rootProcessId) {
@@ -22234,38 +22495,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);
@@ -22273,36 +22510,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) {
@@ -22313,8 +22524,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)
@@ -22322,8 +22533,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)
@@ -22358,9 +22569,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"]
@@ -22469,6 +22681,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(path2) {
@@ -22623,25 +22839,25 @@ var LocalAgentCatalog = class {
 
 // src/storage/state-directory.ts
 import { homedir } from "node:os";
-import { join as join4, resolve as resolve2 } from "node:path";
+import { join as join6, 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 join4(homedir(), ".mobius");
+  return join6(homedir(), ".mobius");
 }
 
 // src/config.ts
 function loadDefaultWorkspace(environment = process.env) {
   const { MOBIUS_DEFAULT_WORKSPACE: configuredWorkspace } = environment;
-  return configuredWorkspace ?? join5(readStateDirectory(environment), "workspace");
+  return configuredWorkspace ?? join7(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 });
   }
 };
@@ -22811,7 +23027,7 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open2, readFile as readFile2, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { open as open2, readFile as readFile3, realpath as realpath4, stat as stat3 } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute2, normalize } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
@@ -22834,7 +23050,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");
   };
 };
@@ -22882,7 +23098,7 @@ async function resolveCanonicalPath(requested, signal) {
     return null;
   }
   try {
-    const target = await realpath3(requested);
+    const target = await realpath4(requested);
     signal.throwIfAborted();
     if (!isAbsolute2(target) || normalize(target) !== target) {
       return null;
@@ -23490,7 +23706,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);
@@ -23503,7 +23719,7 @@ function createWritableAcpStream(output2) {
             reject(outputFailure);
             return;
           }
-          resolve9();
+          resolve10();
         });
       });
     }
@@ -23525,9 +23741,10 @@ var AgentConnection = class {
       this.connection = createAcpClient(client2).connect(inProcess.app());
       return;
     }
-    const child2 = spawn2(agent.adapterPath, [...agent.arguments], {
+    const launch = executableLaunch2(agent.adapterPath, agent.arguments);
+    const child2 = spawn2(launch.command, [...launch.arguments], {
       cwd,
-      detached: process.platform !== "win32",
+      ...platformSpawnOptions,
       env: { ...process.env, ...agent.environment },
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -23544,12 +23761,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 } })
         });
@@ -25762,7 +25979,7 @@ function sql(strings, ...params) {
     return new SQL([new StringChunk(str)]);
   }
   _sql.raw = raw;
-  function join22(chunks, separator) {
+  function join24(chunks, separator) {
     const result = [];
     for (const [i, chunk] of chunks.entries()) {
       if (i > 0 && separator !== void 0) result.push(separator);
@@ -25770,7 +25987,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join22;
+  _sql.join = join24;
   function identifier2(value) {
     return new Name(value);
   }
@@ -27915,7 +28132,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((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins?.some((join24) => join24.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)) {
@@ -28754,7 +28971,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, join22]) => {
+      return sql.join(withEntries.map(([k, join24]) => {
         const relation = tableConfig.relations[k];
         const isSingle2 = is(relation, One);
         const targetTable = aliasedTable(relation.targetTable, `d${currentDepth + 1}`);
@@ -28765,7 +28982,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join22,
+          queryConfig: join24,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -28779,7 +28996,7 @@ var SQLiteDialect = class {
           key: k,
           selection: innerQuery.selection,
           isArray: !isSingle2,
-          isOptional: (relation.optional ?? false) || join22 !== true && !!join22.where
+          isOptional: (relation.optional ?? false) || join24 !== true && !!join24.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)}`;
@@ -29395,7 +29612,7 @@ var SQLiteUpdateBase = class {
   createJoin(joinType) {
     return ((table, on) => {
       const tableName = getTableLikeName(table);
-      if (typeof tableName === "string" && this.config.joins.some((join22) => join22.alias === tableName)) throw new Error(`Alias "${tableName}" is already used in this query`);
+      if (typeof tableName === "string" && this.config.joins.some((join24) => join24.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({
@@ -32054,8 +32271,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir, readdir as readdir2, realpath as realpath4, rename, rm, stat as stat4, utimes, writeFile } from "node:fs/promises";
-import { dirname, join as join6 } from "node:path";
+import { lstat as lstat2, mkdir, readdir as readdir2, realpath as realpath5, rename, rm, stat as stat4, utimes, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join8 } 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({
@@ -32091,7 +32308,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join6(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#root = join8(stateDirectory, "tmp", "session-content", randomUUID2());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -32102,11 +32319,11 @@ var LocalExternalContentStore = class {
       await mkdir(this.#root, { mode: 448, recursive: true });
       const now = /* @__PURE__ */ new Date();
       await utimes(this.#root, now, now);
-      for (const directory of await readdir2(dirname(this.#root), { withFileTypes: true })) {
+      for (const directory of await readdir2(dirname2(this.#root), { withFileTypes: true })) {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path2 = join6(dirname(this.#root), directory.name);
+        const path2 = join8(dirname2(this.#root), directory.name);
         if (path2 === this.#root) {
           continue;
         }
@@ -32156,10 +32373,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join6(this.#root, kind);
+    const directory = join8(this.#root, kind);
     await mkdir(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path2 = join6(directory, key);
+    const path2 = join8(directory, key);
     const write = atomicWrite(path2, bytes, active);
     await write;
     active.throwIfAborted();
@@ -32192,12 +32409,12 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath4(dirname(entry.path)),
-        realpath4(entry.path),
-        lstat(entry.path)
+        realpath5(dirname2(entry.path)),
+        realpath5(entry.path),
+        lstat2(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || file2.isSymbolicLink() || dirname(resolvedPath) !== resolvedDirectory) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname2(resolvedPath) !== resolvedDirectory) {
         return null;
       }
       return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
@@ -33290,9 +33507,9 @@ var LocalAuthorizationError = class extends Error {
 };
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir6, realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { mkdir as mkdir6, realpath as realpath10, stat as stat8 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename as basename3, resolve as resolve5 } from "node:path";
+import { basename as basename3, resolve as resolve6 } from "node:path";
 import { fetch as fetch3 } from "undici";
 
 // src/agent-catalog/agent-discovery.ts
@@ -33435,8 +33652,8 @@ var LocalAgentInventory = class {
 };
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath5, rename as rename2, rm as rm2, stat as stat5 } from "node:fs/promises";
-import { delimiter, dirname as dirname2, isAbsolute as isAbsolute3, join as join7, relative, sep } from "node:path";
+import { mkdir as mkdir2, mkdtemp, open as open3, realpath as realpath6, rename as rename2, rm as rm2, stat as stat5 } from "node:fs/promises";
+import { delimiter, dirname as dirname3, isAbsolute as isAbsolute3, join as join9, 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;
@@ -33487,7 +33704,7 @@ function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function packagePath(root, packageName) {
-  return join7(root, "node_modules", ...packageName.split("/"));
+  return join9(root, "node_modules", ...packageName.split("/"));
 }
 function isContainedPath(root, candidate) {
   const difference = relative(root, candidate);
@@ -33592,14 +33809,14 @@ function verifyPackageLockEntry(lock, definition, verifyDependencyClosure) {
   }
 }
 async function verifyRequiredDependency(rootPath, lock, definition) {
-  const dependencyRoot = await realpath5(packagePath(rootPath, definition.packageName));
+  const dependencyRoot = await realpath6(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(join7(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join9(dependencyRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33621,15 +33838,15 @@ async function validateManagedNpmPackage(root, definition) {
   }
 }
 async function validateManagedNpmPackageContents(root, definition) {
-  const rootPath = await realpath5(root);
-  const packageRoot = await realpath5(packagePath(rootPath, definition.packageName));
+  const rootPath = await realpath6(root);
+  const packageRoot = await realpath6(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(join7(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
+  const metadata = await readJsonRecord(join9(packageRoot, "package.json"), PACKAGE_METADATA_LIMIT_BYTES);
   if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33637,14 +33854,14 @@ async function validateManagedNpmPackageContents(root, definition) {
     );
   }
   if (definition instanceof SriManagedNpmPackageDefinition) {
-    const lock = await readJsonRecord(join7(rootPath, "package-lock.json"), PACKAGE_LOCK_LIMIT_BYTES);
+    const lock = await readJsonRecord(join9(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(join7(packageRoot, declaredBin));
+  const executable = await resolveExecutablePath(join9(packageRoot, declaredBin));
   if (executable === null || !isContainedPath(rootPath, executable.path)) {
     throw new ManagedNpmPackageError(
       "managed_package_verification_failed",
@@ -33666,9 +33883,9 @@ var ManagedNpmPackageInstaller = class {
         throw error62;
       }
     }
-    const parent = dirname2(root);
+    const parent = dirname3(root);
     await mkdir2(parent, { mode: 448, recursive: true });
-    const staging = await mkdtemp(join7(parent, `.${definition.version}.staging-`));
+    const staging = await mkdtemp(join9(parent, `.${definition.version}.staging-`));
     try {
       const npm = await findExecutableOnPath(process.platform === "win32" ? "npm.cmd" : "npm", environment);
       if (npm === null) {
@@ -33694,14 +33911,14 @@ var ManagedNpmPackageInstaller = class {
         `${definition.packageName}@${definition.version}`
       );
       const installEnvironment = {
-        HOME: join7(staging, "home"),
+        HOME: join9(staging, "home"),
         NPM_CONFIG_AUDIT: "false",
-        NPM_CONFIG_CACHE: join7(staging, ".npm-cache"),
+        NPM_CONFIG_CACHE: join9(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: `${dirname2(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
+        PATH: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
       };
       if (definition.includeOptionalDependencies) {
         installEnvironment["NPM_CONFIG_INCLUDE"] = "optional";
@@ -33718,8 +33935,8 @@ var ManagedNpmPackageInstaller = class {
         timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
       await Promise.all([
-        rm2(join7(staging, ".npm-cache"), { force: true, recursive: true }),
-        rm2(join7(staging, "home"), { force: true, recursive: true })
+        rm2(join9(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm2(join9(staging, "home"), { force: true, recursive: true })
       ]);
       await validateManagedNpmPackage(staging, definition);
       try {
@@ -33755,7 +33972,7 @@ var ManagedNpmPackageInstaller = class {
 };
 
 // src/agent-catalog/agent-specification.ts
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/agent-catalog/version-output.ts
 function normalizeVersionOutput(output2) {
@@ -33778,7 +33995,7 @@ var LocalAgentSpecification = class {
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
     const executable = await resolveExecutablePath(
-      join8(stateDirectory, ...this.managedAgentExecutablePath),
+      join10(stateDirectory, ...this.managedAgentExecutablePath),
       platform
     );
     signal.throwIfAborted();
@@ -34154,9 +34371,10 @@ var CodexAppServerClient = class {
   #pendingFragments = [];
   constructor(options) {
     this.#handlers = options.handlers;
-    this.#child = spawn3(options.command, ["app-server"], {
+    const launch = executableLaunch2(options.command, ["app-server"]);
+    this.#child = spawn3(launch.command, [...launch.arguments], {
       cwd: options.cwd,
-      detached: process.platform !== "win32",
+      ...platformSpawnOptions,
       env: { ...process.env, ...options.environment },
       shell: false,
       stdio: ["pipe", "pipe", "pipe"]
@@ -35813,7 +36031,7 @@ var AgentProbeError = class extends Error {
 };
 
 // src/agent-catalog/agents/resolve-user-local-executable.ts
-import { isAbsolute as isAbsolute5, join as join9 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join11 } from "node:path";
 async function resolveUserLocalExecutable(executableName, context) {
   context.signal.throwIfAborted();
   const platform = context.platform ?? process.platform;
@@ -35821,7 +36039,7 @@ async function resolveUserLocalExecutable(executableName, context) {
   if (platform === "win32" || homeDirectory === void 0 || !isAbsolute5(homeDirectory)) {
     return [];
   }
-  const executable = await resolveExecutablePath(join9(homeDirectory, ".local", "bin", executableName), platform);
+  const executable = await resolveExecutablePath(join11(homeDirectory, ".local", "bin", executableName), platform);
   context.signal.throwIfAborted();
   return executable === null ? [] : [executable];
 }
@@ -35910,8 +36128,8 @@ var CursorCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/deepseek-harness-agent.ts
-import { mkdir as mkdir3, realpath as realpath6, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join10, normalize as normalize2 } from "node:path";
+import { mkdir as mkdir3, realpath as realpath7, stat as stat6, writeFile as writeFile2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute6, join as join12, normalize as normalize2 } from "node:path";
 
 // src/agent-installation/deepseek-managed-package.ts
 var DeepSeekHarnessManagedPackage = class extends SriManagedNpmPackageDefinition {
@@ -35942,13 +36160,13 @@ async function prepareAgentHome(path2, imagePrompts) {
     if (imagePrompts) {
       await mkdir3(path2, { mode: 448, recursive: true });
     }
-    const resolved = await realpath6(path2);
+    const resolved = await realpath7(path2);
     const metadata = await stat6(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 writeFile2(join10(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
+      await writeFile2(join12(resolved, "cordis.patch.yml"), DEEPSEEK_HARNESS_IMAGE_PROMPT_PATCH, {
         mode: 384
       });
     }
@@ -35996,7 +36214,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
         context.signal
       );
       if (managed.path === agent.path) {
-        selectedHome = join10(readStateDirectory(context.environment), "agents", this.id, "home");
+        selectedHome = join12(readStateDirectory(context.environment), "agents", this.id, "home");
         managedHome = true;
       }
     } catch {
@@ -36012,7 +36230,7 @@ var DeepSeekHarnessAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join10(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
+      join12(stateDirectory, "agents", this.id, DEEPSEEK_HARNESS_PACKAGE.version),
       DEEPSEEK_HARNESS_PACKAGE
     );
     signal.throwIfAborted();
@@ -36066,8 +36284,8 @@ var GeminiCliAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/grok-build-agent.ts
-import { realpath as realpath7 } from "node:fs/promises";
-import { isAbsolute as isAbsolute7, join as join11, relative as relative2, sep as sep2 } from "node:path";
+import { realpath as realpath8 } from "node:fs/promises";
+import { isAbsolute as isAbsolute7, join as join13, relative as relative2, sep as sep2 } from "node:path";
 import {
   RequestError as RequestError2
 } from "@agentclientprotocol/sdk";
@@ -36137,8 +36355,8 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
       );
       if (managed.path === agent.path) {
         return Object.freeze({
-          GROK_HOME: await realpath7(
-            join11(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
+          GROK_HOME: await realpath8(
+            join13(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION, "home")
           )
         });
       }
@@ -36149,9 +36367,9 @@ var GrokBuildAgentSpecification = class extends DirectAcpAgentDefinition {
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => {
     signal.throwIfAborted();
-    const versionRoot = await realpath7(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);
+    const versionRoot = await realpath8(join13(stateDirectory, "agents", this.id, GROK_BUILD_MANAGED_VERSION));
+    await validateManagedNpmPackage(join13(versionRoot, "package"), grokBuildManagedPackage(platform, process.arch));
+    const executable = await resolveExecutablePath(join13(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");
@@ -36251,13 +36469,13 @@ var OhMyPiAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/opencode-agent.ts
-import { join as join13 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/agent-installation/managed-agent-archive.ts
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { chmod, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath8, rename as rename3, rm as rm3, stat as stat7, writeFile as writeFile3 } from "node:fs/promises";
-import { delimiter as delimiter2, dirname as dirname3, isAbsolute as isAbsolute8, join as join12, relative as relative3, sep as sep3 } from "node:path";
+import { chmod as chmod2, copyFile, mkdir as mkdir4, mkdtemp as mkdtemp2, open as open4, realpath as realpath9, rename as rename3, rm as rm3, stat as stat7, writeFile as writeFile3 } from "node:fs/promises";
+import { delimiter as delimiter2, dirname as dirname4, isAbsolute as isAbsolute8, join as join14, relative as relative3, sep as sep3 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { fetch } from "undici";
@@ -36437,16 +36655,16 @@ async function readManifest(path2) {
 }
 async function validateManagedAgentArchive(root, definition, signal) {
   try {
-    const rootPath = await realpath8(root);
+    const rootPath = await realpath9(root);
     const rootMetadata = await stat7(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(join12(rootPath, "archive.json"));
+    const manifest = await readManifest(join14(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(join12(rootPath, "bin", definition.executableName));
+    const executable = await resolveExecutablePath(join14(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");
     }
@@ -36612,7 +36830,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
     return Object.freeze(environment);
   };
   resolveManagedAgent = async (stateDirectory, platform, signal) => await validateManagedAgentArchive(
-    join13(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
+    join15(stateDirectory, "agents", this.id, OPENCODE_MANAGED_VERSION),
     openCodeManagedArchive(platform, process.arch),
     signal
   );
@@ -36630,7 +36848,7 @@ var OpenCodeAgentSpecification = class extends DirectAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/pi-agent.ts
-import { join as join14 } from "node:path";
+import { join as join16 } from "node:path";
 import {
   methods as methods7
 } from "@agentclientprotocol/sdk";
@@ -36689,7 +36907,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join14(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+      join16(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
       PI_AGENT_PACKAGE
     );
     signal.throwIfAborted();
@@ -36727,7 +36945,7 @@ var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
 };
 
 // src/agent-catalog/agents/workbuddy-agent.ts
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/agent-installation/workbuddy-managed-package.ts
 var WORKBUDDY_MANAGED_VERSION = "2.146.0";
@@ -36773,7 +36991,7 @@ var WorkBuddyAgentSpecification = class extends DirectAcpAgentDefinition {
   resolveManagedAgent = async (stateDirectory, _platform, signal) => {
     signal.throwIfAborted();
     const executable = await validateManagedNpmPackage(
-      join15(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
+      join17(stateDirectory, "agents", this.id, WORKBUDDY_MANAGED_VERSION),
       WORKBUDDY_MANAGED_PACKAGE
     );
     signal.throwIfAborted();
@@ -36981,9 +37199,10 @@ async function probeAcpReadiness(specification, agent, environment, defaultWorks
       signal.removeEventListener("abort", abort);
     }
   }
-  const child2 = spawn4(agent.adapterPath, [...agent.arguments], {
+  const launch = executableLaunch2(agent.adapterPath, agent.arguments);
+  const child2 = spawn4(launch.command, [...launch.arguments], {
     cwd: defaultWorkspace,
-    detached: process.platform !== "win32",
+    ...platformSpawnOptions,
     env: { ...environment, ...agent.environment },
     shell: false,
     stdio: ["pipe", "pipe", "pipe"]
@@ -37116,10 +37335,10 @@ function isAgentVersionSupported(reportedVersion, minimumSupportedVersion) {
 }
 
 // src/agent-catalog/executable-discovery.ts
-import { isAbsolute as isAbsolute9, join as join17 } from "node:path";
+import { isAbsolute as isAbsolute9, join as join19 } from "node:path";
 
 // src/agent-installation/managed-adapter-installer.ts
-import { join as join16 } from "node:path";
+import { join as join18 } from "node:path";
 var ManagedAdapterInstallError = class extends Error {
   code;
   constructor(code, message, options = {}) {
@@ -37176,7 +37395,7 @@ var ManagedAdapterInstaller = class {
     this.#stateDirectory = options.stateDirectory;
   }
   install = async (specification, signal) => {
-    const root = join16(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
+    const root = join18(this.#stateDirectory, "adapters", specification.id, specification.adapterVersion);
     try {
       return await this.#npmInstaller.install(
         root,
@@ -37210,7 +37429,7 @@ async function resolveManagedAdapterExecutable(specification, context) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join17(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
+      join19(readStateDirectory(context.environment), "adapters", specification.id, specification.adapterVersion),
       specification
     );
   } catch {
@@ -37691,8 +37910,21 @@ async function unchangedIdentity(agent, signal) {
 
 // src/storage/runtime-installation-store.ts
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname4, join as join18, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir5, open as open5, readdir as readdir3, rename as rename4, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname5, join as join20, resolve as resolve5 } from "node:path";
+
+// src/filesystem/private-path.ts
+import { lstat as lstat3 } from "node:fs/promises";
+async function validateLocalPath(path2, directory, privateAccess, signal) {
+  signal.throwIfAborted();
+  const metadata = await lstat3(path2);
+  if (metadata.isSymbolicLink() || (directory ? !metadata.isDirectory() : !metadata.isFile())) {
+    throw new LocalPathError("Unsafe local path");
+  }
+  await platformSupportFor(process.platform).validatePathPermissions(path2, 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}$/;
@@ -37934,8 +38166,8 @@ async function readJsonFile(path2, signal, missingCode) {
 }
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname4(path2);
-  const temporaryPath = join18(directory, `.${randomUUID3()}.tmp`);
+  const directory = dirname5(path2);
+  const temporaryPath = join20(directory, `.${randomUUID3()}.tmp`);
   try {
     await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -37944,7 +38176,7 @@ async function writeJsonAtomically(path2, value, signal) {
     signal.throwIfAborted();
     await rename4(temporaryPath, path2);
   } 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
@@ -37961,15 +38193,17 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join18(stateDirectory, "channels");
-    this.#connectionDirectory = join18(stateDirectory, "connections");
+    this.#channelDirectory = join20(stateDirectory, "channels");
+    this.#connectionDirectory = join20(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
-    const rootDirectory = resolve4(options.stateDirectory);
-    const applicationDirectory = join18(rootDirectory, "installations", applicationId);
+    const rootDirectory = resolve5(options.stateDirectory);
+    const applicationDirectory = join20(rootDirectory, "installations", applicationId);
     try {
+      await mkdir5(rootDirectory, { mode: 448, recursive: true });
+      await validateLocalPath(rootDirectory, true, true, signal);
       await mkdir5(applicationDirectory, { mode: 448, recursive: true });
     } catch (cause) {
       throw new RuntimeInstallationStoreError(
@@ -37981,7 +38215,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join18(applicationDirectory, storedInstallationId);
+    const stateDirectory = join20(applicationDirectory, storedInstallationId);
     try {
       await mkdir5(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -37996,8 +38230,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join18(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join18(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join20(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join20(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -38120,9 +38354,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")) {
@@ -38159,7 +38393,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join18(applicationDirectory, "current.json");
+  const pointerPath = join20(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -38297,10 +38531,10 @@ function parseResumeConnectionId(arguments_) {
   return value;
 }
 async function resolveDefaultWorkspace(path2) {
-  const requestedWorkspace = resolve5(path2);
+  const requestedWorkspace = resolve6(path2);
   try {
     await mkdir6(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath9(requestedWorkspace);
+    const defaultWorkspace = await realpath10(requestedWorkspace);
     const metadata = await stat8(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
@@ -38536,7 +38770,7 @@ function isRuntimeRelayRevocation(closeCode, closeReason) {
 
 // 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/agent-installation/agent-installation-manager.ts
@@ -38803,7 +39037,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) {
@@ -38814,7 +39048,7 @@ function findSpecification(specifications, agentId) {
 }
 function resolveDefaultWorkspace2(path2) {
   try {
-    const directory = realpathSync2(resolve6(path2));
+    const directory = realpathSync2(resolve7(path2));
     if (!statSync2(directory).isDirectory()) {
       throw new Error("Default workspace is not a directory");
     }
@@ -38829,7 +39063,7 @@ function resolveDefaultWorkspace2(path2) {
 }
 function resolveIntegrationStateDirectory(path2) {
   try {
-    const directory = realpathSync2(resolve6(path2));
+    const directory = realpathSync2(resolve7(path2));
     const metadata = statSync2(directory);
     if (!metadata.isDirectory() || typeof process.getuid === "function" && metadata.uid !== process.getuid()) {
       throw new Error("Installation directory is not user-owned");
@@ -39001,9 +39235,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";
 var WorkspaceDirectoryListing = class {
   directoryId;
   directoryLabel;
@@ -39071,7 +39305,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();
@@ -39121,7 +39355,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join19(target, child2.name), signal);
+          const path2 = await this.resolvePath(join21(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -39131,7 +39365,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),
@@ -39157,15 +39391,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.
@@ -39981,7 +40215,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) {
@@ -39990,7 +40224,7 @@ var waitForTurnCompletion = (turn, waitSignal) => {
       settled = true;
       waitSignal.removeEventListener("abort", onAbort);
       if (result.kind === "completed") {
-        resolve9();
+        resolve10();
       } else {
         reject(result.error);
       }
@@ -40188,7 +40422,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
@@ -40299,7 +40533,7 @@ var LocalSqliteDatabase = class {
   orm;
   #sqlite;
   constructor(path2, label, migrations, pragmas = []) {
-    mkdirSync2(dirname6(path2), { mode: 448, recursive: true });
+    mkdirSync2(dirname7(path2), { mode: 448, recursive: true });
     this.#sqlite = new DatabaseSync2(path2);
     chmodSync(path2, 384);
     try {
@@ -40858,10 +41092,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"]
   });
@@ -41665,7 +41900,7 @@ import { WebSocket as WebSocket5 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.195",
+  version: "0.0.197",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -41674,7 +41909,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"
@@ -41688,11 +41925,23 @@ var package_default = {
     exports: {
       ".": {
         types: "./dist/index.d.ts",
-        import: "./dist/index.js"
+        import: "./dist/index.js",
+        default: "./dist/index.js"
       },
       "./runtime": {
         types: "./dist/runtime.d.ts",
-        import: "./dist/runtime.js"
+        import: "./dist/runtime.js",
+        default: "./dist/runtime.js"
+      },
+      "./process": {
+        types: "./dist/process/executable.d.ts",
+        import: "./dist/process/executable.js",
+        default: "./dist/process/executable.js"
+      },
+      "./filesystem": {
+        types: "./dist/filesystem/private-path.d.ts",
+        import: "./dist/filesystem/private-path.js",
+        default: "./dist/filesystem/private-path.js"
       }
     }
   },
@@ -41702,7 +41951,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",
@@ -42363,8 +42612,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) {
@@ -42386,12 +42635,12 @@ async function resolveFile(value, workingDirectory, signal) {
   if (path2 === null || !isAbsolute11(path2) && workingDirectory === null) {
     return null;
   }
-  const requested = workingDirectory === null ? path2 : resolve7(workingDirectory, path2);
+  const requested = workingDirectory === null ? path2 : resolve8(workingDirectory, path2);
   if (!isAbsolute11(requested) || isAbsolute11(path2) && normalize4(path2) !== path2) {
     return null;
   }
   try {
-    const target = await realpath11(requested);
+    const target = await realpath12(requested);
     signal.throwIfAborted();
     return isAbsolute11(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -42414,7 +42663,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,
@@ -43316,13 +43565,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);
@@ -43736,7 +43985,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");
@@ -43803,7 +44052,7 @@ function connectRelay(url2, signal) {
       }
       finished = true;
       cleanup();
-      resolve9(socket);
+      resolve10(socket);
     };
     function onTimeout() {
       fail(
@@ -43985,7 +44234,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();
@@ -44003,7 +44252,7 @@ async function runRelayConnection({
         }
         finished = true;
         cleanup();
-        resolve9();
+        resolve10();
       };
       const rejectConnection = (failure2) => {
         if (finished) {
@@ -44389,12 +44638,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 });
   });
@@ -44450,11 +44699,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();
@@ -44657,8 +44906,8 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 }
 
 // src/runtime.ts
-import { mkdir as mkdir7, realpath as realpath12, stat as stat11 } from "node:fs/promises";
-import { resolve as resolve8 } from "node:path";
+import { mkdir as mkdir7, realpath as realpath13, stat as stat11 } from "node:fs/promises";
+import { resolve as resolve9 } from "node:path";
 var RUNTIME_CREDENTIAL_PATTERN2 = /^[a-zA-Z0-9_-]{32,256}$/;
 var MobiusRuntimeConfigurationError = class extends Error {
   code = "runtime_configuration_invalid";
@@ -44721,10 +44970,10 @@ function loadMobiusRuntimeConnection(environment = process.env) {
   });
 }
 async function resolveWorkspace(path2) {
-  const requested = resolve8(path2);
+  const requested = resolve9(path2);
   try {
     await mkdir7(requested, { recursive: true, mode: 448 });
-    const resolved = await realpath12(requested);
+    const resolved = await realpath13(requested);
     const metadata = await stat11(resolved);
     if (!metadata.isDirectory()) {
       throw new MobiusRuntimeConfigurationError("The Runtime workspace is not a directory");