@moxt-ai/mobius 0.0.194 → 0.0.196

package/dist/runtime.js

@@ -5,8 +5,8 @@ var __export = (target, all) => {
 };
 
 // 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";
 
 // ../../node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -5034,7 +5034,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;
@@ -5044,7 +5044,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;
     }
@@ -5055,7 +5055,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;
     }
@@ -5119,7 +5119,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;
     }
@@ -21327,6 +21327,7 @@ var provenanceSchema = external_exports.discriminatedUnion("kind", [
 ]);
 var sessionEventFieldsV2 = {
   eventId: identifierStringSchema,
+  mobiusMetadata: external_exports.object({ omitted: external_exports.literal(true).optional() }).readonly().optional(),
   position: positionSchema,
   provenance: provenanceSchema,
   recordedAt: external_exports.iso.datetime({ offset: true }),
@@ -21393,7 +21394,12 @@ var sessionEventLogPageV2Schema = external_exports.object({
   truncated: external_exports.boolean(),
   version: external_exports.literal(2)
 }).readonly();
-var nativeEventPageRequestV2Schema = external_exports.object({ cursor: external_exports.string().min(1).max(512).nullable(), eventLimit: external_exports.number().int().min(1).max(1e4) }).readonly();
+var sessionEventOmissionV2Schema = external_exports.literal("agent-reasoning");
+var nativeEventPageRequestV2Schema = external_exports.object({
+  cursor: external_exports.string().min(1).max(512).nullable(),
+  eventLimit: external_exports.number().int().min(1).max(1e4),
+  omit: external_exports.array(sessionEventOmissionV2Schema).max(1).readonly().optional()
+}).readonly();
 var queuedPromptRequestEventLogV2Schema = external_exports.object({
   commandId: identifierStringSchema,
   content: external_exports.array(contentBlockV2Schema).min(1).max(100).readonly(),
@@ -21440,6 +21446,7 @@ var directoryIdentifier = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-
 var pageRequestFields = {
   cursor: external_exports.string().min(1).max(512).nullable(),
   eventLimit: external_exports.number().int().min(1).max(1e4),
+  omit: external_exports.array(sessionEventOmissionV2Schema).max(1).readonly().optional(),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 };
@@ -21797,17 +21804,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) {
@@ -21852,6 +21873,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) {
@@ -21883,7 +21979,7 @@ async function readLinuxProcessTable() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          await readFile(join("/proc", directory.name, "stat"), "utf8")
+          await readFile(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -21908,7 +22004,7 @@ function readLinuxProcessTableSynchronously() {
         appendLinuxProcessTableEntry(
           entries,
           processId,
-          readFileSync(join("/proc", directory.name, "stat"), "utf8")
+          readFileSync(join2("/proc", directory.name, "stat"), "utf8")
         );
       } catch {
       }
@@ -21924,11 +22020,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;
     }
@@ -21941,7 +22037,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);
@@ -21954,6 +22050,7 @@ function processExists2(processId) {
   return processExists(processId);
 }
 var linuxPlatform = {
+  ...posixOperations,
   readProcessTable: readLinuxProcessTableWithFallback,
   readProcessTableSynchronously: readLinuxProcessTableSynchronously,
   processExists: processExists2,
@@ -21985,7 +22082,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",
@@ -21996,14 +22093,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;
   },
@@ -22033,8 +22131,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,
@@ -22045,7 +22334,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;
@@ -22084,14 +22373,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;
@@ -22100,28 +22381,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,
@@ -22137,15 +22404,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;
@@ -22166,7 +22434,7 @@ function appendBounded(chunks, chunk, currentBytes, limitBytes) {
   chunks.push(chunk);
   return nextBytes;
 }
-function readProcessTable() {
+function readProcessTable2() {
   return hostPlatform.readProcessTable();
 }
 function selectProcessTree(entries, rootProcessId) {
@@ -22201,38 +22469,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);
@@ -22240,36 +22484,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) {
@@ -22280,8 +22498,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)
@@ -22289,8 +22507,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)
@@ -22325,9 +22543,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"]
@@ -22436,6 +22655,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) {
@@ -22728,8 +22951,8 @@ var LocalAgentInventory = class {
 };
 
 // src/agent-installation/managed-npm-package.ts
-import { mkdir, mkdtemp, open as open2, 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 as open2, 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;
@@ -22780,7 +23003,7 @@ function isRecord3(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);
@@ -22885,14 +23108,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",
@@ -22914,15 +23137,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",
@@ -22930,14 +23153,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",
@@ -22959,9 +23182,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) {
@@ -22987,14 +23210,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";
@@ -23011,8 +23234,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 {
@@ -23048,7 +23271,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) {
@@ -23071,7 +23294,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();
@@ -23553,9 +23776,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"]
@@ -25212,7 +25436,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;
@@ -25220,7 +25444,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];
 }
@@ -25309,8 +25533,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 {
@@ -25328,13 +25552,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
@@ -25352,13 +25576,13 @@ async function prepareAgentHome(path2, imagePrompts) {
     if (imagePrompts) {
       await mkdir2(path2, { mode: 448, recursive: true });
     }
-    const resolved = await realpath4(path2);
+    const resolved = await realpath5(path2);
     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
       });
     }
@@ -25406,7 +25630,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 {
@@ -25422,7 +25646,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();
@@ -25476,8 +25700,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";
@@ -25547,8 +25771,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")
           )
         });
       }
@@ -25559,9 +25783,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");
@@ -25661,13 +25885,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";
@@ -25847,16 +26071,16 @@ async function readManifest(path2) {
 }
 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");
     }
@@ -26022,7 +26246,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
   );
@@ -26040,7 +26264,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";
@@ -26099,7 +26323,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();
@@ -26137,7 +26361,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";
@@ -26183,7 +26407,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();
@@ -26420,9 +26644,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"]
@@ -26555,10 +26780,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 = {}) {
@@ -26615,7 +26840,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,
@@ -26649,7 +26874,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 {
@@ -27074,16 +27299,16 @@ async function publishAgentCatalog(config2, signal) {
 }
 
 // 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 });
   }
 };
@@ -27197,7 +27422,7 @@ var AuditStore = class {
 
 // src/run-daemon.ts
 import { createHash as createHash7, randomUUID as randomUUID8 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join22 } from "node:path";
 import { styleText } from "node:util";
 
 // src/acp/active-executions.ts
@@ -27288,7 +27513,7 @@ import {
 } from "@agentclientprotocol/sdk";
 
 // src/authorization/local-raster.ts
-import { open as open4, readFile as readFile2, realpath as realpath7, stat as stat6 } from "node:fs/promises";
+import { open as open4, readFile as readFile3, realpath as realpath8, stat as stat6 } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute9, normalize as normalize2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var MAX_LOCAL_RASTER_BYTES = 128 * 1024 * 1024;
@@ -27311,7 +27536,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");
   };
 };
@@ -27359,7 +27584,7 @@ async function resolveCanonicalPath(requested, signal) {
     return null;
   }
   try {
-    const target = await realpath7(requested);
+    const target = await realpath8(requested);
     signal.throwIfAborted();
     if (!isAbsolute9(target) || normalize2(target) !== target) {
       return null;
@@ -27940,7 +28165,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);
@@ -27953,7 +28178,7 @@ function createWritableAcpStream(output2) {
             reject(outputFailure);
             return;
           }
-          resolve9();
+          resolve10();
         });
       });
     }
@@ -27975,9 +28200,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"]
@@ -27994,12 +28220,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 } })
         });
@@ -30155,7 +30381,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);
@@ -30163,7 +30389,7 @@ function sql(strings, ...params) {
     }
     return new SQL(result);
   }
-  _sql.join = join22;
+  _sql.join = join24;
   function identifier2(value) {
     return new Name(value);
   }
@@ -32308,7 +32534,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)) {
@@ -33147,7 +33373,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}`);
@@ -33158,7 +33384,7 @@ var SQLiteDialect = class {
           table: targetTable,
           mode: isSingle2 ? "first" : "many",
           schema,
-          queryConfig: join22,
+          queryConfig: join24,
           tableConfig: schema[relation.targetTableName],
           relationWhere: filter,
           isNested: true,
@@ -33172,7 +33398,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)}`;
@@ -33788,7 +34014,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({
@@ -36447,8 +36673,8 @@ var AcpContentExternalizer = class {
 
 // src/external-content/local-external-content-store.ts
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat, mkdir as mkdir4, readdir as readdir2, realpath as realpath8, rename as rename3, rm as rm3, stat as stat7, utimes, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join17 } from "node:path";
+import { lstat as lstat2, mkdir as mkdir4, readdir as readdir2, realpath as realpath9, rename as rename3, rm as rm3, stat as stat7, utimes, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4, join as join19 } 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({
@@ -36484,7 +36710,7 @@ var LocalExternalContentStore = class {
   #expirationTimer;
   #cleanup = Promise.resolve();
   constructor(stateDirectory) {
-    this.#root = join17(stateDirectory, "tmp", "session-content", randomUUID2());
+    this.#root = join19(stateDirectory, "tmp", "session-content", randomUUID2());
     this.#expirationTimer = setInterval(() => {
       void this.#expire().catch(() => void 0);
     }, 6e4);
@@ -36495,11 +36721,11 @@ var LocalExternalContentStore = class {
       await mkdir4(this.#root, { mode: 448, recursive: true });
       const now = /* @__PURE__ */ new Date();
       await utimes(this.#root, now, now);
-      for (const directory of await readdir2(dirname3(this.#root), { withFileTypes: true })) {
+      for (const directory of await readdir2(dirname4(this.#root), { withFileTypes: true })) {
         if (!directory.isDirectory() || !/^[a-f0-9-]{36}$/u.test(directory.name)) {
           continue;
         }
-        const path2 = join17(dirname3(this.#root), directory.name);
+        const path2 = join19(dirname4(this.#root), directory.name);
         if (path2 === this.#root) {
           continue;
         }
@@ -36549,10 +36775,10 @@ var LocalExternalContentStore = class {
     }
     await this.#expire();
     active.throwIfAborted();
-    const directory = join17(this.#root, kind);
+    const directory = join19(this.#root, kind);
     await mkdir4(directory, { mode: 448, recursive: true });
     active.throwIfAborted();
-    const path2 = join17(directory, key);
+    const path2 = join19(directory, key);
     const write = atomicWrite(path2, bytes, active);
     await write;
     active.throwIfAborted();
@@ -36585,12 +36811,12 @@ var LocalExternalContentStore = class {
     }
     try {
       const [resolvedDirectory, resolvedPath, file2] = await Promise.all([
-        realpath8(dirname3(entry.path)),
-        realpath8(entry.path),
-        lstat(entry.path)
+        realpath9(dirname4(entry.path)),
+        realpath9(entry.path),
+        lstat2(entry.path)
       ]);
       signal.throwIfAborted();
-      if (!file2.isFile() || file2.isSymbolicLink() || dirname3(resolvedPath) !== resolvedDirectory) {
+      if (!file2.isFile() || file2.isSymbolicLink() || dirname4(resolvedPath) !== resolvedDirectory) {
         return null;
       }
       return { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
@@ -37891,7 +38117,7 @@ var AgentInstallationManager = class {
 
 // src/agent-installation/fixed-installation-executor.ts
 import { realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve5 } from "node:path";
 function findSpecification(specifications, agentId) {
   for (const specification of specifications) {
     if (specification.id === agentId) {
@@ -37902,7 +38128,7 @@ function findSpecification(specifications, agentId) {
 }
 function resolveDefaultWorkspace(path2) {
   try {
-    const directory = realpathSync2(resolve4(path2));
+    const directory = realpathSync2(resolve5(path2));
     if (!statSync2(directory).isDirectory()) {
       throw new Error("Default workspace is not a directory");
     }
@@ -37917,7 +38143,7 @@ function resolveDefaultWorkspace(path2) {
 }
 function resolveIntegrationStateDirectory(path2) {
   try {
-    const directory = realpathSync2(resolve4(path2));
+    const directory = realpathSync2(resolve5(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");
@@ -38089,9 +38315,9 @@ var FixedInstallationExecutor = class {
 };
 
 // src/authorization/workspace-directory.ts
-import { readdir as readdir3, realpath as realpath9, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir3, realpath as realpath10, stat as stat8 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute10, join as join18, normalize as normalize3, relative as relative4 } from "node:path";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute10, join as join20, normalize as normalize3, relative as relative4 } from "node:path";
 
 // src/authorization/local-authorization-error.ts
 var LocalAuthorizationError = class extends Error {
@@ -38170,7 +38396,7 @@ var WorkspaceDirectoryService = class {
       throw new LocalAuthorizationError("The local directory path is invalid");
     }
     try {
-      const target = await realpath9(requested);
+      const target = await realpath10(requested);
       signal.throwIfAborted();
       const metadata = await stat8(target);
       signal.throwIfAborted();
@@ -38220,7 +38446,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join18(target, child2.name), signal);
+          const path2 = await this.resolvePath(join20(target, child2.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child2.name });
         } catch (cause) {
           signal.throwIfAborted();
@@ -38230,7 +38456,7 @@ var WorkspaceDirectoryService = class {
         }
       }
       entries.sort((a, b) => a.name.localeCompare(b.name));
-      const parent = dirname4(target);
+      const parent = dirname5(target);
       return new WorkspaceDirectoryListing(
         id,
         this.label(target),
@@ -38256,15 +38482,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 join19 } from "node:path";
+import { join as join21 } 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 = join19(stateDirectory, "logs");
-    this.#path = join19(this.#directory, "daemon.log");
+    this.#directory = join21(stateDirectory, "logs");
+    this.#path = join21(this.#directory, "daemon.log");
     this.#maximumBytes = maximumBytes;
   }
   // Export only correlation and failure metadata. Local messages and paths stay local.
@@ -39080,7 +39306,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) {
@@ -39089,7 +39315,7 @@ var waitForTurnCompletion = (turn, waitSignal) => {
       settled = true;
       waitSignal.removeEventListener("abort", onAbort);
       if (result.kind === "completed") {
-        resolve9();
+        resolve10();
       } else {
         reject(result.error);
       }
@@ -39287,7 +39513,7 @@ var sessionEventCacheMigrations = [
 
 // src/infra/local-sqlite-database.ts
 import { chmodSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname6 } 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
@@ -39398,7 +39624,7 @@ var LocalSqliteDatabase = class {
   orm;
   #sqlite;
   constructor(path2, label, migrations, pragmas = []) {
-    mkdirSync2(dirname5(path2), { mode: 448, recursive: true });
+    mkdirSync2(dirname6(path2), { mode: 448, recursive: true });
     this.#sqlite = new DatabaseSync2(path2);
     chmodSync(path2, 384);
     try {
@@ -39957,10 +40183,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"]
   });
@@ -40764,7 +40991,7 @@ import { WebSocket as WebSocket5 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.194",
+  version: "0.0.196",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -40773,7 +41000,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"
@@ -40792,6 +41021,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"
       }
     }
   },
@@ -40801,7 +41038,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",
@@ -41462,8 +41699,8 @@ function createAgentSettingsDiscoveryHandler(dependencies) {
 
 // src/artifacts/local-file-streamer.ts
 import { createReadStream as createReadStream2 } from "node:fs";
-import { realpath as realpath10, stat as stat9 } from "node:fs/promises";
-import { basename as basename4, extname, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve5 } from "node:path";
+import { realpath as realpath11, stat as stat9 } from "node:fs/promises";
+import { basename as basename4, extname as extname2, isAbsolute as isAbsolute11, normalize as normalize4, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
@@ -41485,12 +41722,12 @@ async function resolveFile(value, workingDirectory, signal) {
   if (path2 === null || !isAbsolute11(path2) && workingDirectory === null) {
     return null;
   }
-  const requested = workingDirectory === null ? path2 : resolve5(workingDirectory, path2);
+  const requested = workingDirectory === null ? path2 : resolve6(workingDirectory, path2);
   if (!isAbsolute11(requested) || isAbsolute11(path2) && normalize4(path2) !== path2) {
     return null;
   }
   try {
-    const target = await realpath10(requested);
+    const target = await realpath11(requested);
     signal.throwIfAborted();
     return isAbsolute11(target) && normalize4(target) === target ? target : null;
   } catch {
@@ -41513,7 +41750,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 ?? (basename4(target) || "file"),
     requestId: command.requestId,
@@ -41803,6 +42040,78 @@ async function executeSessionConfigure(socket, command, config2, directories, au
 }
 
 // src/daemon-history-commands.ts
+function isAgentReasoning(event) {
+  return event?.type === "acp" && event.payload.sessionUpdate === "agent_thought_chunk";
+}
+function omitAgentReasoning(events) {
+  const retained = [];
+  let previousReasoningMessageId;
+  for (const event of events) {
+    if (event.type !== "acp" || event.payload.sessionUpdate !== "agent_thought_chunk") {
+      previousReasoningMessageId = void 0;
+      retained.push(event);
+      continue;
+    }
+    const messageId = event.payload.messageId ?? null;
+    if (previousReasoningMessageId === void 0 || previousReasoningMessageId !== messageId) {
+      retained.push({
+        ...event,
+        mobiusMetadata: { omitted: true },
+        payload: { ...event.payload, content: { text: "", type: "text" } }
+      });
+    }
+    previousReasoningMessageId = messageId;
+  }
+  return retained;
+}
+async function loadHistoryPage(sessionId, eventLimit, initialCursor, omitReasoning, queuedPromptRequests, load, eventLogV2) {
+  let cursor = initialCursor;
+  let loaded = [];
+  let sessionGenerationId = null;
+  let sourceNextCursor = null;
+  do {
+    const replay = await load(eventLimit, cursor);
+    if (sessionGenerationId !== null && replay.sessionGenerationId !== sessionGenerationId) {
+      throw new AcpExecutionError("The Session reloaded while history was loading", {}, "session_reloaded");
+    }
+    sessionGenerationId = replay.sessionGenerationId;
+    const events2 = replay.events.map(
+      (event, index2) => eventLogV2.event(
+        sessionId,
+        replay.sessionGenerationId,
+        replay.startPosition + index2,
+        event,
+        "1970-01-01T00:00:00.000Z"
+      )
+    );
+    loaded = [...events2, ...loaded];
+    sourceNextCursor = replay.nextCursor;
+    const visible2 = omitReasoning ? omitAgentReasoning(loaded) : loaded;
+    const reasoningContinuesBeforePage = sourceNextCursor !== null && isAgentReasoning(loaded[0]);
+    if (visible2.length >= eventLimit && !reasoningContinuesBeforePage) {
+      break;
+    }
+    cursor = sourceNextCursor;
+  } while (cursor !== null);
+  if (sessionGenerationId === null) {
+    throw new AcpExecutionError("The Session history is unavailable", {}, "session_history_unavailable");
+  }
+  const visible = omitReasoning ? omitAgentReasoning(loaded) : loaded;
+  const events = visible.slice(-eventLimit);
+  const firstPosition = events[0] === void 0 ? 0 : Number(events[0].position);
+  const nextCursor = firstPosition <= 1 ? null : (firstPosition - 1).toString();
+  return {
+    events: {
+      events,
+      nextCursor,
+      sessionGenerationId,
+      tailCursor: events.at(-1)?.eventId ?? "",
+      truncated: nextCursor !== null,
+      version: 2
+    },
+    queuedPromptRequests
+  };
+}
 async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, directories, audit, diagnostics, sessions, nativeSessions, eventLogV2, signal) {
   let agentId;
   try {
@@ -41826,35 +42135,23 @@ async function executeSessionLiveHistoryV2PageLoad(socket, command, config2, dir
       signal
     };
     const recovery = eventLogV2.promptRequestRecovery(command.sessionId);
-    const replay = await sessions.loadSessionEventsV2(loadOptions, command.eventLimit, command.cursor);
-    signal.throwIfAborted();
-    const events = replay.events.map(
-      (event, index2) => eventLogV2.event(
-        command.sessionId,
-        replay.sessionGenerationId,
-        replay.startPosition + index2,
-        event,
-        "1970-01-01T00:00:00.000Z"
-      )
+    const events = await loadHistoryPage(
+      command.sessionId,
+      command.eventLimit,
+      command.cursor,
+      command.omit?.includes("agent-reasoning") === true,
+      recovery.queuedPromptRequests,
+      async (eventLimit, cursor) => await sessions.loadSessionEventsV2(loadOptions, eventLimit, cursor),
+      eventLogV2
     );
-    const tailCursor = events.at(-1)?.eventId ?? "";
+    signal.throwIfAborted();
     audit.record({
       commandId: command.requestId,
       event: "session_event_log_v2_loaded",
       sessionId: command.sessionId
     });
     send(socket, {
-      events: {
-        events: {
-          events,
-          nextCursor: replay.nextCursor,
-          sessionGenerationId: replay.sessionGenerationId,
-          tailCursor,
-          truncated: replay.truncated,
-          version: 2
-        },
-        queuedPromptRequests: recovery.queuedPromptRequests
-      },
+      events,
       kind: SESSION_LIVE_HISTORY_V2_PAGE_LOADED_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -41893,46 +42190,30 @@ async function executeSessionPreviewHistoryPageLoad(socket, command, config2, di
       command.additionalDirectoryIds,
       signal
     );
-    const replay = await sessions.previewNativeSessionEventsV2(
-      {
-        additionalDirectories: resolved.additionalDirectories,
-        agent: await resolveCatalogAgent(config2, command.agentId, signal),
-        cwd: resolved.cwd,
-        sessionId: command.sessionId,
-        signal
-      },
+    const loadOptions = {
+      additionalDirectories: resolved.additionalDirectories,
+      agent: await resolveCatalogAgent(config2, command.agentId, signal),
+      cwd: resolved.cwd,
+      sessionId: command.sessionId,
+      signal
+    };
+    const events = await loadHistoryPage(
       command.sessionId,
       command.eventLimit,
-      command.cursor
+      command.cursor,
+      command.omit?.includes("agent-reasoning") === true,
+      [],
+      async (eventLimit, cursor) => await sessions.previewNativeSessionEventsV2(loadOptions, command.sessionId, eventLimit, cursor),
+      eventLogV2
     );
     signal.throwIfAborted();
-    const events = replay.events.map(
-      (event, index2) => eventLogV2.event(
-        command.sessionId,
-        replay.sessionGenerationId,
-        replay.startPosition + index2,
-        event,
-        "1970-01-01T00:00:00.000Z"
-      )
-    );
-    const tailCursor = events.at(-1)?.eventId ?? "";
     audit.record({
       commandId: command.requestId,
       event: "session_event_log_v2_loaded",
       sessionId: command.sessionId
     });
     send(socket, {
-      events: {
-        events: {
-          events,
-          nextCursor: replay.nextCursor,
-          sessionGenerationId: replay.sessionGenerationId,
-          tailCursor,
-          truncated: replay.truncated,
-          version: 2
-        },
-        queuedPromptRequests: []
-      },
+      events,
       kind: SESSION_PREVIEW_HISTORY_PAGE_LOADED_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -42371,13 +42652,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);
@@ -42811,7 +43092,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");
@@ -42878,7 +43159,7 @@ function connectRelay(url2, signal) {
       }
       finished = true;
       cleanup();
-      resolve9(socket);
+      resolve10(socket);
     };
     function onTimeout() {
       fail(
@@ -43060,7 +43341,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();
@@ -43078,7 +43359,7 @@ async function runRelayConnection({
         }
         finished = true;
         cleanup();
-        resolve9();
+        resolve10();
       };
       const rejectConnection = (failure2) => {
         if (finished) {
@@ -43464,12 +43745,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 });
   });
@@ -43525,11 +43806,11 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
     stateDirectory
   });
   const channelHash = createHash7("sha256").update(config2.channelId).digest("hex");
-  const sessionDatabase = openAcpSessionDatabase(join20(stateDirectory, "sessions", `${channelHash}.sqlite`));
+  const sessionDatabase = openAcpSessionDatabase(join22(stateDirectory, "sessions", `${channelHash}.sqlite`));
   let eventsV2;
   try {
     eventsV2 = new CachedAcpSessionEventStoreV2(
-      openSessionEventCacheV2Database(join20(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
+      openSessionEventCacheV2Database(join22(stateDirectory, "sessions", `${channelHash}.events.sqlite`))
     );
   } catch (error62) {
     sessionDatabase.close();
@@ -43732,15 +44013,28 @@ async function runDaemon(config2, audit, signal, timer = systemDaemonTimer, opti
 }
 
 // src/pairing/pair-local-machine.ts
-import { mkdir as mkdir6, realpath as realpath11, stat as stat10 } from "node:fs/promises";
+import { mkdir as mkdir6, realpath as realpath12, stat as stat10 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename as basename6, resolve as resolve7 } from "node:path";
+import { basename as basename6, resolve as resolve8 } from "node:path";
 import { fetch as fetch4 } from "undici";
 
 // src/storage/runtime-installation-store.ts
 import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
-import { mkdir as mkdir5, open as open5, readdir as readdir4, rename as rename4, unlink, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname6, join as join21, resolve as resolve6 } from "node:path";
+import { mkdir as mkdir5, open as open5, readdir as readdir4, rename as rename4, unlink as unlink2, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname7, join as join23, resolve as resolve7 } 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}$/;
@@ -43982,8 +44276,8 @@ async function readJsonFile(path2, signal, missingCode) {
 }
 async function writeJsonAtomically(path2, value, signal) {
   signal.throwIfAborted();
-  const directory = dirname6(path2);
-  const temporaryPath = join21(directory, `.${randomUUID9()}.tmp`);
+  const directory = dirname7(path2);
+  const temporaryPath = join23(directory, `.${randomUUID9()}.tmp`);
   try {
     await mkdir5(directory, { mode: 448, recursive: true });
     signal.throwIfAborted();
@@ -43992,7 +44286,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
@@ -44009,15 +44303,17 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     this.applicationId = applicationId;
     this.installationId = installationId2;
     this.stateDirectory = stateDirectory;
-    this.#channelDirectory = join21(stateDirectory, "channels");
-    this.#connectionDirectory = join21(stateDirectory, "connections");
+    this.#channelDirectory = join23(stateDirectory, "channels");
+    this.#connectionDirectory = join23(stateDirectory, "connections");
   }
   static open = async (options, signal) => {
     signal.throwIfAborted();
     const applicationId = validateApplicationId(options.applicationId);
-    const rootDirectory = resolve6(options.stateDirectory);
-    const applicationDirectory = join21(rootDirectory, "installations", applicationId);
+    const rootDirectory = resolve7(options.stateDirectory);
+    const applicationDirectory = join23(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(
@@ -44029,7 +44325,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
       );
     }
     const storedInstallationId = await readOrCreateInstallationId(applicationDirectory, signal);
-    const stateDirectory = join21(applicationDirectory, storedInstallationId);
+    const stateDirectory = join23(applicationDirectory, storedInstallationId);
     try {
       await mkdir5(stateDirectory, { mode: 448, recursive: true });
     } catch (cause) {
@@ -44044,8 +44340,8 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
     signal.throwIfAborted();
     return new _RuntimeInstallationStore(applicationId, storedInstallationId, stateDirectory);
   };
-  connectionPath = (connectionId2) => join21(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
-  channelIndexPath = (channelId) => join21(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
+  connectionPath = (connectionId2) => join23(this.#connectionDirectory, `${validateConnectionId(connectionId2)}.json`);
+  channelIndexPath = (channelId) => join23(this.#channelDirectory, channelIndexFileName(validateIdentifier(channelId, "invalid_channel_id")));
   readConnection = async (connectionId2, signal) => {
     const stored = decodeConnection(
       await readJsonFile(this.connectionPath(connectionId2), signal, "connection_not_found")
@@ -44168,9 +44464,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")) {
@@ -44207,7 +44503,7 @@ var RuntimeInstallationStore = class _RuntimeInstallationStore {
   };
 };
 async function readOrCreateInstallationId(applicationDirectory, signal) {
-  const pointerPath = join21(applicationDirectory, "current.json");
+  const pointerPath = join23(applicationDirectory, "current.json");
   try {
     return decodeInstallationPointer(await readJsonFile(pointerPath, signal, "installation_not_found")).installationId;
   } catch (cause) {
@@ -44299,10 +44595,10 @@ function validatePairingId(value) {
   return value;
 }
 async function resolveDefaultWorkspace2(path2) {
-  const requestedWorkspace = resolve7(path2);
+  const requestedWorkspace = resolve8(path2);
   try {
     await mkdir6(requestedWorkspace, { recursive: true, mode: 448 });
-    const defaultWorkspace = await realpath11(requestedWorkspace);
+    const defaultWorkspace = await realpath12(requestedWorkspace);
     const metadata = await stat10(defaultWorkspace);
     if (!metadata.isDirectory()) {
       throw new PairingClientError("invalid_workspace", "The default workspace is not a directory");
@@ -44545,10 +44841,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");