@letta-ai/letta-code 0.29.13 → 0.30.1

package/letta.js

@@ -5462,7 +5462,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.29.13",
+    version: "0.30.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -5488,6 +5488,8 @@ var init_package = __esm(() => {
       "dist/mcp-client.js.map",
       "dist/agent-presets.js",
       "dist/agent-presets.js.map",
+      "dist/schedules.js",
+      "dist/schedules.js.map",
       "dist/channels-public.js",
       "dist/channels-public.js.map",
       "dist/channels-slack.js",
@@ -5532,6 +5534,12 @@ var init_package = __esm(() => {
         import: "./dist/agent-presets.js",
         default: "./dist/agent-presets.js"
       },
+      "./schedules": {
+        types: "./dist/types/schedules.d.ts",
+        browser: "./dist/schedules.js",
+        import: "./dist/schedules.js",
+        default: "./dist/schedules.js"
+      },
       "./channels": {
         types: "./dist/types/channels-public.d.ts",
         browser: "./dist/channels-public.js",
@@ -5563,6 +5571,7 @@ var init_package = __esm(() => {
       "@modelcontextprotocol/sdk": "1.30.0",
       "@pierre/diffs": "1.2.2",
       "@scarf/scarf": "^1.4.0",
+      "cross-spawn": "^7.0.6",
       "cron-parser": "^5.6.1",
       glob: "^13.0.0",
       "ink-link": "^5.0.0",
@@ -5581,6 +5590,7 @@ var init_package = __esm(() => {
       "@modelcontextprotocol/server-everything": "^2026.7.4",
       "@slack/bolt": "^4.7.0",
       "@types/bun": "^1.3.7",
+      "@types/cross-spawn": "^6.0.6",
       "@types/diff": "^8.0.0",
       "@types/picomatch": "^4.0.2",
       "@types/react": "^19.2.9",
@@ -5632,6 +5642,9 @@ var init_package = __esm(() => {
         "agent-presets": [
           "./dist/types/agent-presets.d.ts"
         ],
+        schedules: [
+          "./dist/types/schedules.d.ts"
+        ],
         "app-server-protocol": [
           "./dist/types/types/app-server-protocol.d.ts"
         ],
@@ -147033,6 +147046,487 @@ var init_auto_update = __esm(() => {
   VALID_PACKAGE_MANAGERS = new Set(Object.keys(INSTALL_ARG_PREFIX));
 });
 
+// node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module3) => {
+  module3.exports = isexe;
+  isexe.sync = sync;
+  var fs3 = __require("fs");
+  function checkPathExt(path5, options3) {
+    var pathext = options3.pathExt !== undefined ? options3.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i2 = 0;i2 < pathext.length; i2++) {
+      var p = pathext[i2].toLowerCase();
+      if (p && path5.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat3, path5, options3) {
+    if (!stat3.isSymbolicLink() && !stat3.isFile()) {
+      return false;
+    }
+    return checkPathExt(path5, options3);
+  }
+  function isexe(path5, options3, cb) {
+    fs3.stat(path5, function(er, stat3) {
+      cb(er, er ? false : checkStat(stat3, path5, options3));
+    });
+  }
+  function sync(path5, options3) {
+    return checkStat(fs3.statSync(path5), path5, options3);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module3) => {
+  module3.exports = isexe;
+  isexe.sync = sync;
+  var fs3 = __require("fs");
+  function isexe(path5, options3, cb) {
+    fs3.stat(path5, function(er, stat3) {
+      cb(er, er ? false : checkStat(stat3, options3));
+    });
+  }
+  function sync(path5, options3) {
+    return checkStat(fs3.statSync(path5), options3);
+  }
+  function checkStat(stat3, options3) {
+    return stat3.isFile() && checkMode(stat3, options3);
+  }
+  function checkMode(stat3, options3) {
+    var mod = stat3.mode;
+    var uid = stat3.uid;
+    var gid = stat3.gid;
+    var myUid = options3.uid !== undefined ? options3.uid : process.getuid && process.getuid();
+    var myGid = options3.gid !== undefined ? options3.gid : process.getgid && process.getgid();
+    var u = parseInt("100", 8);
+    var g = parseInt("010", 8);
+    var o = parseInt("001", 8);
+    var ug = u | g;
+    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module3) => {
+  var fs3 = __require("fs");
+  var core2;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core2 = require_windows();
+  } else {
+    core2 = require_mode();
+  }
+  module3.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path5, options3, cb) {
+    if (typeof options3 === "function") {
+      cb = options3;
+      options3 = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve3, reject) {
+        isexe(path5, options3 || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve3(is);
+          }
+        });
+      });
+    }
+    core2(path5, options3 || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options3 && options3.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path5, options3) {
+    try {
+      return core2.sync(path5, options3 || {});
+    } catch (er) {
+      if (options3 && options3.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS((exports, module3) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path5 = __require("path");
+  var COLON2 = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON2;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i2) => new Promise((resolve3, reject) => {
+      if (i2 === pathEnv.length)
+        return opt.all && found.length ? resolve3(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path5.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve3(subStep(p, i2, 0));
+    });
+    const subStep = (p, i2, ii) => new Promise((resolve3, reject) => {
+      if (ii === pathExt.length)
+        return resolve3(step(i2 + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve3(p + ext);
+        }
+        return resolve3(subStep(p, i2, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i2 = 0;i2 < pathEnv.length; i2++) {
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path5.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j = 0;j < pathExt.length; j++) {
+        const cur = p + pathExt[j];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module3.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module3) => {
+  var pathKey = (options3 = {}) => {
+    const environment2 = options3.env || process.env;
+    const platform = options3.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment2).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module3.exports = pathKey;
+  module3.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module3) => {
+  var path5 = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env3 = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env3[getPathKey({ env: env3 })],
+        pathExt: withoutPathExt ? path5.delimiter : undefined
+      });
+    } catch (e2) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path5.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module3.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module3) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module3) => {
+  module3.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module3) => {
+  var shebangRegex = require_shebang_regex();
+  module3.exports = (string7 = "") => {
+    const match2 = string7.match(shebangRegex);
+    if (!match2) {
+      return null;
+    }
+    const [path5, argument] = match2[0].replace(/#! ?/, "").split(" ");
+    const binary = path5.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module3) => {
+  var fs3 = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs3.openSync(command, "r");
+      fs3.readSync(fd, buffer, 0, size, 0);
+      fs3.closeSync(fd);
+    } catch (e2) {}
+    return shebangCommand(buffer.toString());
+  }
+  module3.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse2 = __commonJS((exports, module3) => {
+  var path5 = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape2 = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path5.normalize(parsed.command);
+      parsed.command = escape2.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse8(command, args, options3) {
+    if (args && !Array.isArray(args)) {
+      options3 = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options3 = Object.assign({}, options3);
+    const parsed = {
+      command,
+      args,
+      options: options3,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options3.shell ? parsed : parseNonShell(parsed);
+  }
+  module3.exports = parse8;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module3) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module3.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module3) => {
+  var cp = __require("child_process");
+  var parse8 = require_parse2();
+  var enoent = require_enoent();
+  function spawn(command, args, options3) {
+    const parsed = parse8(command, args, options3);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options3) {
+    const parsed = parse8(command, args, options3);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module3.exports = spawn;
+  module3.exports.spawn = spawn;
+  module3.exports.sync = spawnSync;
+  module3.exports._parse = parse8;
+  module3.exports._enoent = enoent;
+});
+
+// src/utils/package-manager-spawn.ts
+import {
+  spawn
+} from "node:child_process";
+function isWindowsCommandShim(command) {
+  return /\.(?:cmd|bat)$/i.test(command);
+}
+function getPackageManagerProcessFactory({
+  nativeSpawn = spawn,
+  platform = process.platform,
+  windowsSpawn = import_cross_spawn.default
+} = {}) {
+  if (platform !== "win32") {
+    return nativeSpawn;
+  }
+  return (command, args, options3) => {
+    const spawnImpl = isWindowsCommandShim(command) ? windowsSpawn : nativeSpawn;
+    return spawnImpl(command, args, options3);
+  };
+}
+var import_cross_spawn;
+var init_package_manager_spawn = __esm(() => {
+  import_cross_spawn = __toESM(require_cross_spawn(), 1);
+});
+
 // src/channels/runtime-deps.ts
 var exports_runtime_deps = {};
 __export(exports_runtime_deps, {
@@ -147049,7 +147543,6 @@ __export(exports_runtime_deps, {
   __testOverrideChannelRuntimeDeps: () => __testOverrideChannelRuntimeDeps,
   CHANNEL_RUNTIME_ROOT_ENV: () => CHANNEL_RUNTIME_ROOT_ENV
 });
-import { spawn } from "node:child_process";
 import { existsSync as existsSync7 } from "node:fs";
 import { mkdir as mkdir2, symlink, writeFile as writeFile4 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
@@ -147182,6 +147675,7 @@ async function installChannelRuntime(channelId) {
   const packageManager = resolveInstallPackageManager();
   const command = getPackageManagerExecutable(packageManager);
   const args = getInstallArgs(packageManager, spec.runtimePackages);
+  const spawnInstallProcess = spawnInstallProcessOverride ?? getPackageManagerProcessFactory({ platform: resolveInstallPlatform() });
   await new Promise((resolve3, reject) => {
     const proc = spawnInstallProcess(command, args, {
       cwd: getChannelRuntimeDir(channelId),
@@ -147224,16 +147718,16 @@ async function loadChannelRuntimeModule(channelId, moduleName) {
 function __testOverrideChannelRuntimeDeps(overrides) {
   userRuntimeRootOverride = overrides?.runtimeRoot ?? null;
   bundledRuntimeRootOverride = overrides ? overrides.bundledRuntimeRoot ?? null : undefined;
-  spawnInstallProcess = overrides?.spawnImpl ?? spawn;
+  spawnInstallProcessOverride = overrides?.spawnImpl ?? null;
   packageManagerOverride = overrides?.packageManager ?? null;
   platformOverride = overrides?.platform ?? null;
 }
-var CHANNEL_RUNTIME_ROOT_ENV = "LETTA_CHANNEL_RUNTIME_ROOT", spawnInstallProcess, userRuntimeRootOverride = null, bundledRuntimeRootOverride, packageManagerOverride = null, platformOverride = null;
+var CHANNEL_RUNTIME_ROOT_ENV = "LETTA_CHANNEL_RUNTIME_ROOT", spawnInstallProcessOverride = null, userRuntimeRootOverride = null, bundledRuntimeRootOverride, packageManagerOverride = null, platformOverride = null;
 var init_runtime_deps = __esm(() => {
   init_auto_update();
+  init_package_manager_spawn();
   init_config2();
   init_plugin_registry();
-  spawnInstallProcess = spawn;
 });
 
 // src/channels/telegram/runtime.ts
@@ -173976,7 +174470,7 @@ var init_channel_turn_session = __esm(() => {
 });
 
 // src/websocket/listener/constants.ts
-var MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS2 = 1000, MAX_RETRY_DELAY_MS = 30000, LISTENER_HEARTBEAT_INTERVAL_MS = 30000, LISTENER_PONG_TIMEOUT_MS = 90000, SYSTEM_REMINDER_RE, LLM_API_ERROR_MAX_RETRIES = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, MAX_PRE_STREAM_RECOVERY = 2, MAX_POST_STOP_APPROVAL_RECOVERY = 2, PROVIDER_FALLBACK_MAP, PROVIDER_FALLBACK_NOTICE = "Anthropic API error; falling back to Bedrock...";
+var MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS2 = 1000, MAX_RETRY_DELAY_MS = 30000, LISTENER_STREAM_OPEN_TIMEOUT_MS = 30000, LISTENER_HEARTBEAT_INTERVAL_MS = 30000, LISTENER_PONG_TIMEOUT_MS = 90000, SYSTEM_REMINDER_RE, LLM_API_ERROR_MAX_RETRIES = 3, EMPTY_RESPONSE_MAX_RETRIES = 2, MAX_PRE_STREAM_RECOVERY = 2, MAX_POST_STOP_APPROVAL_RECOVERY = 2, PROVIDER_FALLBACK_MAP, PROVIDER_FALLBACK_NOTICE = "Anthropic API error; falling back to Bedrock...";
 var init_constants3 = __esm(() => {
   MAX_RETRY_DURATION_MS = 5 * 60 * 1000;
   SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -350930,7 +351424,7 @@ var require_scan = __commonJS((exports, module3) => {
 });
 
 // node_modules/picomatch/lib/parse.js
-var require_parse2 = __commonJS((exports, module3) => {
+var require_parse3 = __commonJS((exports, module3) => {
   var constants3 = require_constants();
   var utils = require_utils3();
   var {
@@ -351711,7 +352205,7 @@ var require_parse2 = __commonJS((exports, module3) => {
 var require_picomatch = __commonJS((exports, module3) => {
   var path27 = __require("path");
   var scan = require_scan();
-  var parse8 = require_parse2();
+  var parse8 = require_parse3();
   var utils = require_utils3();
   var constants3 = require_constants();
   var isObject3 = (val) => val && typeof val === "object" && !Array.isArray(val);
@@ -354390,6 +354884,7 @@ var init_client6 = __esm(() => {
 // src/lsp/servers/python.ts
 var PythonServer;
 var init_python = __esm(() => {
+  init_package_manager_spawn();
   PythonServer = {
     id: "python",
     extensions: [".py", ".pyi"],
@@ -354420,11 +354915,12 @@ var init_python = __esm(() => {
           throw new Error("LSP auto-download is disabled. Please install pyright manually: npm install -g pyright");
         }
         console.log("[LSP] Installing pyright...");
-        const { spawn: spawn9 } = await import("node:child_process");
+        const platform3 = process.platform;
+        const command = platform3 === "win32" ? "npm.cmd" : "npm";
+        const spawnPackageManager = getPackageManagerProcessFactory({ platform: platform3 });
         return new Promise((resolve20, reject) => {
-          const proc = spawn9("npm", ["install", "-g", "pyright"], {
-            stdio: "inherit"
-          });
+          const proc = spawnPackageManager(command, ["install", "-g", "pyright"], { stdio: "inherit" });
+          proc.on("error", reject);
           proc.on("exit", (code2) => {
             if (code2 === 0) {
               console.log("[LSP] Successfully installed pyright");
@@ -370426,10 +370922,6 @@ async function resolveBaseToolNamesForModel(modelIdentifier, options3) {
   } else {
     baseToolNames = TOOL_NAMES;
   }
-  if (options3?.exclude && options3.exclude.length > 0) {
-    const excludeSet = new Set(options3.exclude);
-    baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
-  }
   if (options3?.include && options3.include.length > 0) {
     const seen = new Set(baseToolNames);
     for (const name of options3.include) {
@@ -370439,6 +370931,10 @@ async function resolveBaseToolNamesForModel(modelIdentifier, options3) {
       }
     }
   }
+  if (options3?.exclude && options3.exclude.length > 0) {
+    const excludeSet = new Set(options3.exclude);
+    baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
+  }
   baseToolNames = filterWorktreeTools(baseToolNames);
   baseToolNames = resolveArtifactToolNames(baseToolNames);
   baseToolNames = maybeAppendChannelTools(baseToolNames, options3?.channelToolScope);
@@ -371630,6 +372126,28 @@ function appendArtifactToolsIfEnabled(toolNames) {
   }
   return [...withoutArtifactTools, ...ARTIFACT_TOOL_NAMES2];
 }
+function resolveIncludedToolNames(toolNames) {
+  if (!toolNames)
+    return [];
+  return toolNames.map((toolName) => {
+    const internalName = getInternalToolName(toolName);
+    if (!Object.hasOwn(TOOL_DEFINITIONS, internalName)) {
+      throw new Error(`Unknown bundled client tool: ${toolName}`);
+    }
+    return internalName;
+  });
+}
+function appendUniqueToolNames(baseToolNames, includedToolNames) {
+  const result = [...baseToolNames];
+  const seen = new Set(result);
+  for (const toolName of includedToolNames) {
+    if (!seen.has(toolName)) {
+      result.push(toolName);
+      seen.add(toolName);
+    }
+  }
+  return result;
+}
 function deriveToolsetFromModel(modelIdentifier, providerType) {
   if (providerType === "chatgpt_oauth" || providerType === "openai-codex") {
     return "codex";
@@ -371700,6 +372218,7 @@ async function prepareToolExecutionContextForResolvedTarget(params) {
     providerType,
     conversationId,
     toolsetPreference,
+    clientToolset,
     exclude: exclude3,
     clientToolAllowlist,
     externalToolScopeIds,
@@ -371713,7 +372232,9 @@ async function prepareToolExecutionContextForResolvedTarget(params) {
     agent: agent2
   } = params;
   const effectiveModel = modelIdentifier && modelIdentifier.length > 0 ? resolveModel(modelIdentifier) ?? modelIdentifier : null;
-  if (toolsetPreference === "auto") {
+  const effectiveToolsetPreference = clientToolset?.base ?? toolsetPreference;
+  const includedToolNames = resolveIncludedToolNames(clientToolset?.include);
+  if (effectiveToolsetPreference === "auto") {
     const derivedToolset = effectiveModel ? deriveToolsetFromModel(effectiveModel, providerType) : "default";
     const scopedModContext2 = buildModInvocationContext({
       agent: agent2,
@@ -371727,6 +372248,7 @@ async function prepareToolExecutionContextForResolvedTarget(params) {
     const modCapabilities2 = mergeModAdapterCapabilities(modAdapters, scopedModContext2);
     const preparedToolContext2 = await prepareToolExecutionContextForModel(effectiveModel ?? undefined, {
       exclude: exclude3,
+      include: includedToolNames,
       clientToolAllowlist,
       externalToolScopeIds,
       workingDirectory,
@@ -371752,11 +372274,11 @@ async function prepareToolExecutionContextForResolvedTarget(params) {
     conversationId,
     modelIdentifier: effectiveModel,
     permissionMode: permissionModeState?.mode ?? runtimeContext?.permissionMode ?? null,
-    toolset: toolsetPreference,
+    toolset: effectiveToolsetPreference,
     workingDirectory
   });
   const modCapabilities = mergeModAdapterCapabilities(modAdapters, scopedModContext);
-  const preparedToolContext = await prepareToolExecutionContextForSpecificTools(filterBuiltInToolNamesByClientAllowlist(getToolNamesForToolset(toolsetPreference, channelToolScope).filter((toolName) => exclude3 ? !exclude3.includes(toolName) : true), clientToolAllowlist), {
+  const preparedToolContext = await prepareToolExecutionContextForSpecificTools(filterBuiltInToolNamesByClientAllowlist(appendUniqueToolNames(getToolNamesForToolset(effectiveToolsetPreference, channelToolScope), includedToolNames).filter((toolName) => exclude3 ? !exclude3.includes(toolName) : true), clientToolAllowlist), {
     clientToolAllowlist,
     externalToolScopeIds,
     workingDirectory,
@@ -371770,7 +372292,7 @@ async function prepareToolExecutionContextForResolvedTarget(params) {
   });
   return {
     preparedToolContext,
-    toolset: toolsetPreference,
+    toolset: effectiveToolsetPreference,
     toolsetPreference,
     effectiveModel,
     agent: null
@@ -371881,6 +372403,7 @@ async function prepareToolExecutionContextForScope(params) {
     overrideProviderType,
     cachedEffectiveModel,
     exclude: exclude3,
+    clientToolset,
     clientToolAllowlist,
     externalToolScopeIds,
     workingDirectory,
@@ -371927,6 +372450,7 @@ async function prepareToolExecutionContextForScope(params) {
     providerType: effectiveProviderType,
     conversationId: conversationId ?? undefined,
     toolsetPreference,
+    clientToolset,
     exclude: exclude3,
     clientToolAllowlist,
     externalToolScopeIds,
@@ -372100,7 +372624,10 @@ var init_toolset = __esm(async () => {
   init_runtime_context();
   init_settings_manager();
   init_filter();
-  await init_manager4();
+  await __promiseAll([
+    init_manager4(),
+    init_tool_definitions()
+  ]);
   ARTIFACT_TOOL_NAMES2 = [
     "read_artifact_file",
     "write_artifact_file"
@@ -424009,6 +424536,17 @@ function validateRegistryHandleOrThrow(handle2) {
   }
 }
 
+// src/cli/startup-mode.ts
+function isHeadlessStartup(flags, stdinIsTTY, firstPositional) {
+  if (flags.prompt || flags.run) {
+    return true;
+  }
+  if (firstPositional) {
+    return false;
+  }
+  return stdinIsTTY !== true;
+}
+
 // src/cli/helpers/shared-agent-listing.ts
 function buildListSharedAgentsQuery(params) {
   return {
@@ -436614,7 +437152,7 @@ var init_conversation_runtime = __esm(async () => {
   ]);
 });
 
-// src/cron/prompt.ts
+// src/cron/scheduled-task-prompt.ts
 function pad(value, width) {
   return String(value).padStart(width, "0");
 }
@@ -436696,6 +437234,34 @@ function formatTimezoneQualifiedIso(date6, timezone) {
   const offsetMinutes = Math.round((zonedAsUtcMs - date6.getTime()) / 60000);
   return `${pad(parts.year, 4)}-${pad(parts.month, 2)}-${pad(parts.day, 2)}T${pad(parts.hour, 2)}:${pad(parts.minute, 2)}:${pad(parts.second, 2)}.${pad(millis, 3)}${formatOffset(offsetMinutes)}[${effectiveTimezone ?? "local"}]`;
 }
+function formatRecurrence(recurrence) {
+  if (recurrence.type === "one-off") {
+    return "This is a one-off scheduled task.";
+  }
+  if (recurrence.fireNumber !== undefined) {
+    return `This is fire #${recurrence.fireNumber} (cron: ${recurrence.cron}).`;
+  }
+  return `This is a recurring scheduled task (cron: ${recurrence.cron}).`;
+}
+function formatScheduledTaskPrompt(input) {
+  const lines = [
+    `Scheduled task "${input.name}" is firing.`,
+    ...input.description ? [`Description: ${input.description}`] : [],
+    `Timezone: ${formatTimezoneDisplay(input.timezone)}`,
+    `Scheduled for: ${formatTimezoneQualifiedIso(input.scheduledFor, input.timezone)}`,
+    `Current time: ${formatTimezoneQualifiedIso(input.currentTime, input.timezone)}`,
+    formatRecurrence(input.recurrence),
+    "",
+    AUTONOMOUS_NOTICE,
+    "",
+    `Prompt: ${input.prompt}`
+  ];
+  return lines.join(`
+`);
+}
+var AUTONOMOUS_NOTICE = "You are running autonomously: no user is watching this turn and questions will not be answered. Deliver results through your available channels or record them in memory, and work until the task is done or genuinely blocked.";
+
+// src/cron/prompt.ts
 function getIntendedCronOccurrence(task2, matchedAt) {
   if (!task2.recurring && task2.scheduled_for) {
     const scheduledFor = new Date(task2.scheduled_for);
@@ -436708,22 +437274,21 @@ function getIntendedCronOccurrence(task2, matchedAt) {
   return occurrence;
 }
 function formatCronPrompt(task2, timing) {
-  const timezone = typeof task2.timezone === "string" ? task2.timezone : "";
-  const lines = [
-    `Scheduled task "${task2.name}" is firing.`,
-    `Description: ${task2.description}`,
-    `Timezone: ${formatTimezoneDisplay(timezone)}`,
-    `Scheduled for: ${formatTimezoneQualifiedIso(timing.intendedOccurrence, timezone)}`,
-    `Current time: ${formatTimezoneQualifiedIso(timing.schedulerNow, timezone)}`,
-    task2.recurring ? `This is fire #${task2.fire_count + 1} (cron: ${task2.cron}).` : "This is a one-off scheduled task.",
-    "",
-    "You are running autonomously: no user is watching this turn and questions will not be answered. Deliver results through your available channels or record them in memory, and work until the task is done or genuinely blocked.",
-    "",
-    `Prompt: ${task2.prompt}`
-  ];
-  return lines.join(`
-`);
-}
+  return formatScheduledTaskPrompt({
+    name: task2.name,
+    description: task2.description,
+    timezone: typeof task2.timezone === "string" ? task2.timezone : "",
+    scheduledFor: timing.intendedOccurrence,
+    currentTime: timing.schedulerNow,
+    recurrence: task2.recurring ? {
+      type: "recurring",
+      cron: task2.cron,
+      fireNumber: task2.fire_count + 1
+    } : { type: "one-off" },
+    prompt: task2.prompt
+  });
+}
+var init_prompt = () => {};
 
 // src/cron/scheduler.ts
 function minuteKey(date6) {
@@ -437144,7 +437709,9 @@ var init_scheduler = __esm(async () => {
   init_runtime6();
   init_cron_file();
   init_parse_interval();
+  init_prompt();
   init_run_log();
+  init_prompt();
   await __promiseAll([
     init_conversation_runtime(),
     init_protocol_outbound(),
@@ -446426,6 +446993,11 @@ function isExperimentId(value) {
 function isStringArray6(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isClientToolsetConfig(value) {
+  if (!isObjectRecord2(value))
+    return false;
+  return (value.base === undefined || typeof value.base === "string" && TOOLSET_PREFERENCES.has(value.base)) && (value.include === undefined || isStringArray6(value.include));
+}
 function isStringRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && Object.values(value).every((item) => typeof item === "string");
 }
@@ -446452,7 +447024,7 @@ function isInputCommand(value) {
   }
   const payload = candidate.payload;
   if (payload.kind === "create_message") {
-    return Array.isArray(payload.messages) && (payload.client_tool_allowlist === undefined || isStringArray6(payload.client_tool_allowlist)) && (payload.external_tool_scope_ids === undefined || isStringArray6(payload.external_tool_scope_ids)) && (payload.exclude_interactive_tools === undefined || typeof payload.exclude_interactive_tools === "boolean");
+    return Array.isArray(payload.messages) && (payload.client_tool_allowlist === undefined || isStringArray6(payload.client_tool_allowlist)) && (payload.client_toolset === undefined || isClientToolsetConfig(payload.client_toolset)) && (payload.external_tool_scope_ids === undefined || isStringArray6(payload.external_tool_scope_ids)) && (payload.exclude_interactive_tools === undefined || typeof payload.exclude_interactive_tools === "boolean");
   }
   if (payload.kind === "approval_response") {
     return isValidApprovalResponseBody(payload);
@@ -446478,6 +447050,7 @@ function legacyEnvironmentMessageToInputCommand(value) {
       kind: "create_message",
       messages: candidate.messages,
       client_tool_allowlist: isStringArray6(candidate.clientToolAllowlist) ? candidate.clientToolAllowlist : undefined,
+      client_toolset: isClientToolsetConfig(candidate.clientToolset) ? candidate.clientToolset : undefined,
       external_tool_scope_ids: isStringArray6(candidate.externalToolScopeIds) ? candidate.externalToolScopeIds : undefined
     }
   };
@@ -446510,6 +447083,12 @@ function getInvalidInputReason(value) {
         reason: "Protocol violation: input.payload.client_tool_allowlist must be string[]"
       };
     }
+    if (payload.client_toolset !== undefined && !isClientToolsetConfig(payload.client_toolset)) {
+      return {
+        runtime: candidate.runtime,
+        reason: "Protocol violation: input.payload.client_toolset must contain an optional valid base and string[] include"
+      };
+    }
     if (payload.exclude_interactive_tools !== undefined && typeof payload.exclude_interactive_tools !== "boolean") {
       return {
         runtime: candidate.runtime,
@@ -447222,7 +447801,7 @@ function parseServerMessage(data) {
     return null;
   }
 }
-var EXPERIMENT_IDS, CHANNEL_ACCOUNT_CREATE_FIELDS, CHANNEL_ACCOUNT_UPDATE_FIELDS, CHANNEL_SET_CONFIG_FIELDS;
+var EXPERIMENT_IDS, TOOLSET_PREFERENCES, CHANNEL_ACCOUNT_CREATE_FIELDS, CHANNEL_ACCOUNT_UPDATE_FIELDS, CHANNEL_SET_CONFIG_FIELDS;
 var init_protocol_inbound = __esm(async () => {
   init_skill_sources();
   init_account_config7();
@@ -447233,6 +447812,15 @@ var init_protocol_inbound = __esm(async () => {
     "desktop_conversation_bootstrap",
     "tui_cron"
   ]);
+  TOOLSET_PREFERENCES = new Set([
+    "auto",
+    "codex",
+    "codex_snake",
+    "default",
+    "gemini",
+    "gemini_snake",
+    "none"
+  ]);
   CHANNEL_ACCOUNT_CREATE_FIELDS = new Set([
     "account_id",
     "display_name",
@@ -459722,6 +460310,7 @@ async function prepareListenerTurn(params) {
     connectionId,
     agentId,
     conversationId,
+    clientToolset: msg.clientToolset,
     clientToolAllowlist: msg.clientToolAllowlist,
     ...msg.excludeInteractiveTools ? { exclude: [...INTERACTIVE_USER_INPUT_TOOL_NAMES] } : {},
     externalToolScopeIds: msg.externalToolScopeIds,
@@ -464512,6 +465101,10 @@ function summarizeInputPayload(payload) {
   if (payload.kind === "create_message") {
     pushField(fields, "messages", payload.messages);
     pushField(fields, "client_tool_allowlist", payload.client_tool_allowlist);
+    if (isRecord10(payload.client_toolset)) {
+      pushField(fields, "client_toolset.base", payload.client_toolset.base);
+      pushField(fields, "client_toolset.include", payload.client_toolset.include);
+    }
     pushField(fields, "external_tool_scope_ids", payload.external_tool_scope_ids);
     pushField(fields, "exclude_interactive_tools", payload.exclude_interactive_tools);
   } else if (payload.kind === "approval_response") {
@@ -464798,6 +465391,7 @@ function createListenerMessageHandler(params) {
           agentId: parsed.runtime.agent_id,
           conversationId: parsed.runtime.conversation_id,
           clientToolAllowlist: inputPayload.client_tool_allowlist,
+          clientToolset: inputPayload.client_toolset,
           externalToolScopeIds: inputPayload.external_tool_scope_ids,
           excludeInteractiveTools: inputPayload.exclude_interactive_tools,
           messages: inputPayload.messages
@@ -465197,8 +465791,143 @@ var init_process_services = __esm(async () => {
   ]);
 });
 
+// src/websocket/listener/split-stream-lifecycle.ts
+import { WebSocket as WebSocket6 } from "ws";
+function terminateSocketIfOpenOrConnecting(socket) {
+  if (socket && (socket.readyState === WebSocket6.OPEN || socket.readyState === WebSocket6.CONNECTING)) {
+    socket.terminate();
+  }
+}
+function isCurrentSocketPair(runtime, controlSocket, streamSocket) {
+  return runtime === getActiveRuntime() && !runtime.intentionallyClosed && runtime.socket === controlSocket && runtime.streamSocket === streamSocket;
+}
+function shouldHandleControlSocketClose(runtime, controlSocket, connectionId) {
+  return runtime === getActiveRuntime() && (runtime.socket === controlSocket || runtime.connections.get(connectionId)?.writer === controlSocket);
+}
+function terminateCurrentSocketPair(runtime, controlSocket, streamSocket) {
+  if (!isCurrentSocketPair(runtime, controlSocket, streamSocket)) {
+    return;
+  }
+  runtime.streamTransport = null;
+  terminateSocketIfOpenOrConnecting(streamSocket);
+  terminateSocketIfOpenOrConnecting(controlSocket);
+}
+function terminateControlAfterStreamClose(runtime, streamSocket, code2, reason) {
+  if (runtime.streamSocket !== streamSocket) {
+    return;
+  }
+  if (code2 === 1000 && reason.toString() === "Replaced by new connection") {
+    runtime.intentionallyClosed = true;
+  }
+  runtime.streamSocket = null;
+  runtime.streamTransport = null;
+  terminateSocketIfOpenOrConnecting(runtime.socket);
+}
+function getStreamOpenTimeoutMs() {
+  const override = process.env.LETTA_LISTENER_STREAM_OPEN_TIMEOUT_MS;
+  if (override !== undefined) {
+    const parsed = Number(override);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return LISTENER_STREAM_OPEN_TIMEOUT_MS;
+}
+async function waitForStreamSocketOpen(streamSocket) {
+  if (streamSocket.readyState === WebSocket6.OPEN) {
+    return { status: "open", transport: streamSocket };
+  }
+  if (streamSocket.readyState === WebSocket6.CLOSING || streamSocket.readyState === WebSocket6.CLOSED) {
+    return { status: "closed" };
+  }
+  const timeoutMs = getStreamOpenTimeoutMs();
+  return await new Promise((resolve32) => {
+    let timeout = null;
+    let settled = false;
+    function cleanup() {
+      streamSocket.off("open", handleOpen);
+      streamSocket.off("error", handleFailure);
+      streamSocket.off("close", handleFailure);
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+    }
+    function settle(result) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve32(result);
+    }
+    function handleOpen() {
+      settle({ status: "open", transport: streamSocket });
+    }
+    function handleFailure() {
+      settle({ status: "closed" });
+    }
+    timeout = setTimeout(() => {
+      settle({ status: "timed_out", timeoutMs });
+    }, timeoutMs);
+    timeout.unref?.();
+    streamSocket.once("open", handleOpen);
+    streamSocket.once("error", handleFailure);
+    streamSocket.once("close", handleFailure);
+  });
+}
+async function prepareSplitStreamTransport({
+  runtime,
+  controlSocket,
+  streamSocket,
+  trackListenerError: trackListenerError4
+}) {
+  if (!isCurrentSocketPair(runtime, controlSocket, streamSocket)) {
+    return { kind: "stale" };
+  }
+  if (!streamSocket) {
+    return { kind: "ready", transport: null };
+  }
+  const result = await waitForStreamSocketOpen(streamSocket);
+  if (!isCurrentSocketPair(runtime, controlSocket, streamSocket)) {
+    return { kind: "stale" };
+  }
+  if (result.status !== "open") {
+    const message = result.status === "timed_out" ? `Stream WebSocket did not open within ${result.timeoutMs}ms; reconnecting paired listener sockets` : "Stream WebSocket closed before the paired listener sockets finished opening; reconnecting paired listener sockets";
+    trackListenerError4(result.status === "timed_out" ? "listener_stream_open_timeout" : "listener_stream_open_failed", new Error(message), "listener_stream_socket_open");
+    if (isDebugEnabled()) {
+      console.error(`[Listen] ${message}`);
+    }
+    terminateCurrentSocketPair(runtime, controlSocket, streamSocket);
+    return { kind: "stale" };
+  }
+  runtime.streamTransport = result.transport;
+  return { kind: "ready", transport: result.transport };
+}
+function handleListenerSocketOpenFailure({
+  runtime,
+  controlSocket,
+  streamSocket,
+  error: error54,
+  trackListenerError: trackListenerError4
+}) {
+  if (!isCurrentSocketPair(runtime, controlSocket, streamSocket)) {
+    return;
+  }
+  trackListenerError4("listener_open_handler_failed", error54, "listener_socket_open");
+  if (isDebugEnabled()) {
+    console.error("[Listen] WebSocket open handler failed:", error54);
+  }
+  terminateCurrentSocketPair(runtime, controlSocket, streamSocket);
+}
+var init_split_stream_lifecycle = __esm(() => {
+  init_debug();
+  init_constants3();
+  init_runtime6();
+});
+
 // src/websocket/listener/lifecycle.ts
-import WebSocket6 from "ws";
+import WebSocket7 from "ws";
 function trackListenerError4(errorType, error54, context3) {
   trackBoundaryError({
     errorType,
@@ -465207,7 +465936,7 @@ function trackListenerError4(errorType, error54, context3) {
   });
 }
 function safeSocketSend(socket, payload, errorType, context3) {
-  if (socket.readyState !== WebSocket6.OPEN) {
+  if (socket.readyState !== WebSocket7.OPEN) {
     return false;
   }
   try {
@@ -465344,48 +466073,6 @@ function getParsedRuntimeScope(parsed) {
     conversation_id: typeof runtime.conversation_id === "string" ? runtime.conversation_id : "default"
   };
 }
-function terminateControlAfterStreamClose(runtime, streamSocket, code2, reason) {
-  if (runtime.streamSocket !== streamSocket) {
-    return;
-  }
-  if (code2 === 1000 && reason.toString() === "Replaced by new connection") {
-    runtime.intentionallyClosed = true;
-  }
-  runtime.streamSocket = null;
-  runtime.streamTransport = null;
-  const controlSocket = runtime.socket;
-  if (controlSocket && (controlSocket.readyState === WebSocket6.OPEN || controlSocket.readyState === WebSocket6.CONNECTING)) {
-    controlSocket.terminate();
-  }
-}
-async function waitForStreamSocketOpen(streamSocket, runtime) {
-  if (streamSocket.readyState === WebSocket6.OPEN) {
-    runtime.streamTransport = streamSocket;
-    return streamSocket;
-  }
-  if (streamSocket.readyState === WebSocket6.CLOSING || streamSocket.readyState === WebSocket6.CLOSED) {
-    return null;
-  }
-  return await new Promise((resolve32) => {
-    const handleOpen = () => {
-      cleanup();
-      runtime.streamTransport = streamSocket;
-      resolve32(streamSocket);
-    };
-    const handleFailure = () => {
-      cleanup();
-      resolve32(null);
-    };
-    const cleanup = () => {
-      streamSocket.off("open", handleOpen);
-      streamSocket.off("error", handleFailure);
-      streamSocket.off("close", handleFailure);
-    };
-    streamSocket.once("open", handleOpen);
-    streamSocket.once("error", handleFailure);
-    streamSocket.once("close", handleFailure);
-  });
-}
 async function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
   const registry2 = getChannelRegistry();
   if (!registry2)
@@ -465867,7 +466554,7 @@ async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
     });
   });
   socket.on("close", (code2, reason) => {
-    if (runtime !== getActiveRuntime()) {
+    if (runtime !== getActiveRuntime() || runtime.connections.get(opts.connectionId) !== connection) {
       return;
     }
     const reasonText = reason.toString();
@@ -465908,7 +466595,7 @@ async function attachOpenListenerSocket(runtime, socket, opts, options3 = {}) {
   if (connection.cancellation.signal.aborted || runtime.connections.get(opts.connectionId) !== connection) {
     return;
   }
-  const streamTransport = streamSocket?.readyState === WebSocket6.OPEN ? streamSocket : null;
+  const streamTransport = streamSocket?.readyState === WebSocket7.OPEN ? streamSocket : null;
   await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, {
     startHeartbeat: options3.startHeartbeat ?? false,
     startCronScheduler: options3.startCronScheduler ?? true,
@@ -466018,12 +466705,12 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     streamUrl.searchParams.set("connectionName", opts.connectionName);
     streamUrl.searchParams.set("channel", "stream");
   }
-  const socket = new WebSocket6(url2.toString(), {
+  const socket = new WebSocket7(url2.toString(), {
     headers: {
       Authorization: `Bearer ${apiKey}`
     }
   });
-  const streamSocket = streamUrl ? new WebSocket6(streamUrl.toString(), {
+  const streamSocket = streamUrl ? new WebSocket7(streamUrl.toString(), {
     headers: {
       Authorization: `Bearer ${apiKey}`
     }
@@ -466037,22 +466724,41 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
   runtime.streamSocket = streamSocket;
   const transport = socket;
   const processQueuedTurn = createConnectionTurnProcessor(runtime);
-  socket.on("open", async () => {
-    let streamTransport = null;
-    if (streamSocket) {
-      streamTransport = await waitForStreamSocketOpen(streamSocket, runtime);
-    }
-    openListenerConnection({
-      runtime,
-      connectionId: opts.connectionId,
-      writer: socket,
-      streamWriter: streamTransport,
-      options: opts
-    });
-    await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, {
-      startHeartbeat: true,
-      startCronScheduler: true,
-      streamTransport
+  socket.on("open", () => {
+    (async () => {
+      const streamOpen = await prepareSplitStreamTransport({
+        runtime,
+        controlSocket: socket,
+        streamSocket,
+        trackListenerError: trackListenerError4
+      });
+      if (streamOpen.kind !== "ready") {
+        return;
+      }
+      const streamTransport = streamOpen.transport;
+      if (!isCurrentSocketPair(runtime, socket, streamSocket)) {
+        return;
+      }
+      openListenerConnection({
+        runtime,
+        connectionId: opts.connectionId,
+        writer: socket,
+        streamWriter: streamTransport,
+        options: opts
+      });
+      await startConnectedListenerRuntime(runtime, transport, opts, processQueuedTurn, {
+        startHeartbeat: true,
+        startCronScheduler: true,
+        streamTransport
+      });
+    })().catch((error54) => {
+      handleListenerSocketOpenFailure({
+        runtime,
+        controlSocket: socket,
+        streamSocket,
+        error: error54,
+        trackListenerError: trackListenerError4
+      });
     });
   });
   socket.on("message", createListenerMessageHandler({
@@ -466075,7 +466781,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     wireChannelIngress
   }));
   socket.on("close", (code2, reason) => {
-    if (runtime !== getActiveRuntime()) {
+    if (!shouldHandleControlSocketClose(runtime, socket, opts.connectionId)) {
       return;
     }
     safeEmitWsEvent("recv", "lifecycle", {
@@ -466100,7 +466806,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
     clearListenerWarmState(runtime);
     if (streamSocket) {
       streamSocket.removeAllListeners();
-      if (streamSocket.readyState === WebSocket6.OPEN || streamSocket.readyState === WebSocket6.CONNECTING) {
+      if (streamSocket.readyState === WebSocket7.OPEN || streamSocket.readyState === WebSocket7.CONNECTING) {
         streamSocket.close();
       }
     }
@@ -466190,6 +466896,7 @@ var init_lifecycle = __esm(async () => {
   init_heartbeat();
   init_permission_mode();
   init_runtime6();
+  init_split_stream_lifecycle();
   init_transport();
   await __promiseAll([
     init_scheduler(),
@@ -468718,9 +469425,7 @@ var init_messages10 = __esm(() => {
 });
 
 // src/mods/package-installer.ts
-import {
-  spawn as spawn13
-} from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync56,
@@ -469113,7 +469818,9 @@ async function runNpmInstall(params) {
       args: getNpmInstallArgs(params.installSpec),
       command: getNpmExecutable(),
       cwd: params.tempRoot,
-      spawnImpl: spawnNpmInstallProcess
+      spawnImpl: spawnNpmInstallProcessOverride ?? getPackageManagerProcessFactory({
+        platform: platformOverride2 ?? process.platform
+      })
     });
   } catch (error54) {
     const message = error54 instanceof Error ? error54.message : String(error54);
@@ -469569,13 +470276,13 @@ async function updateGitManagedModPackage(params) {
     rmSync13(tempRoot, { force: true, recursive: true });
   }
 }
-var SKIPPED_PACKAGE_COPY_NAMES, spawnNpmInstallProcess, spawnGitInstallProcess, platformOverride2 = null;
+var SKIPPED_PACKAGE_COPY_NAMES, spawnNpmInstallProcessOverride = null, spawnGitInstallProcess, platformOverride2 = null;
 var init_package_installer = __esm(() => {
   init_file_extensions();
   init_package_manifest();
   init_package_registry();
+  init_package_manager_spawn();
   SKIPPED_PACKAGE_COPY_NAMES = new Set([".git", "node_modules"]);
-  spawnNpmInstallProcess = spawn13;
   spawnGitInstallProcess = spawn13;
 });
 
@@ -471781,7 +472488,7 @@ var init_app_server_openai = __esm(async () => {
 // src/websocket/app-server.ts
 import { createServer as createServer2 } from "node:http";
 import { hostname as hostname6 } from "node:os";
-import WebSocket7, { WebSocketServer } from "ws";
+import WebSocket8, { WebSocketServer } from "ws";
 function getRequiredAddressInfo(server2) {
   const address = server2.address();
   if (!address || typeof address === "string") {
@@ -471797,12 +472504,12 @@ function getWebSocketUrl(baseUrl, path43) {
 function closeSocket(socket, code2 = 1001, reason = "closing") {
   if (!socket)
     return;
-  if (socket.readyState === WebSocket7.OPEN || socket.readyState === WebSocket7.CONNECTING) {
+  if (socket.readyState === WebSocket8.OPEN || socket.readyState === WebSocket8.CONNECTING) {
     socket.close(code2, reason);
   }
 }
 function terminateSocket(socket) {
-  if (!socket || socket.readyState === WebSocket7.CLOSED)
+  if (!socket || socket.readyState === WebSocket8.CLOSED)
     return;
   socket.terminate();
 }
@@ -471980,7 +472687,7 @@ async function startAppServer(options3 = {}) {
         client.terminate();
         continue;
       }
-      if (client.readyState === WebSocket7.OPEN) {
+      if (client.readyState === WebSocket8.OPEN) {
         client.ping();
       }
     }
@@ -473019,6 +473726,12 @@ function truncateAgentId(id2, availableWidth) {
   const suffixLen = availableWidth - 3 - prefixLen;
   return `${id2.slice(0, prefixLen)}...${id2.slice(-suffixLen)}`;
 }
+function formatAgentMemoryBlockCount(blockCount) {
+  if (blockCount === null || blockCount === undefined || blockCount <= 0) {
+    return null;
+  }
+  return `${blockCount} memory block${blockCount === 1 ? "" : "s"}`;
+}
 function formatAgentModel(agent2) {
   let handle2 = null;
   if (agent2.model) {
@@ -473808,11 +474521,13 @@ function AgentSelector({
     const isCurrent = agent2.id === currentAgentId;
     const isLocalAgent2 = isLocalAgentId(agent2.id);
     const relativeTime = formatRelativeTime3(agent2.last_run_completion);
-    const blockCount = agent2.blocks?.length ?? 0;
+    const blockCountText = formatAgentMemoryBlockCount(agent2.blocks?.length);
     const modelStr = formatAgentModel(agent2);
     const metadataParts = [relativeTime];
     if (!isLocalAgent2 && extra?.backend !== "shared") {
-      metadataParts.push(`${blockCount} memory block${blockCount === 1 ? "" : "s"}`);
+      if (blockCountText) {
+        metadataParts.push(blockCountText);
+      }
       metadataParts.push(modelStr);
     }
     if (extra?.backend === "shared" && agent2.creator?.name) {
@@ -486998,462 +487713,6 @@ var init_sse = __esm(() => {
   };
 });
 
-// node_modules/isexe/windows.js
-var require_windows = __commonJS((exports, module3) => {
-  module3.exports = isexe;
-  isexe.sync = sync2;
-  var fs15 = __require("fs");
-  function checkPathExt(path43, options3) {
-    var pathext = options3.pathExt !== undefined ? options3.pathExt : process.env.PATHEXT;
-    if (!pathext) {
-      return true;
-    }
-    pathext = pathext.split(";");
-    if (pathext.indexOf("") !== -1) {
-      return true;
-    }
-    for (var i4 = 0;i4 < pathext.length; i4++) {
-      var p2 = pathext[i4].toLowerCase();
-      if (p2 && path43.substr(-p2.length).toLowerCase() === p2) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function checkStat(stat17, path43, options3) {
-    if (!stat17.isSymbolicLink() && !stat17.isFile()) {
-      return false;
-    }
-    return checkPathExt(path43, options3);
-  }
-  function isexe(path43, options3, cb) {
-    fs15.stat(path43, function(er, stat17) {
-      cb(er, er ? false : checkStat(stat17, path43, options3));
-    });
-  }
-  function sync2(path43, options3) {
-    return checkStat(fs15.statSync(path43), path43, options3);
-  }
-});
-
-// node_modules/isexe/mode.js
-var require_mode = __commonJS((exports, module3) => {
-  module3.exports = isexe;
-  isexe.sync = sync2;
-  var fs15 = __require("fs");
-  function isexe(path43, options3, cb) {
-    fs15.stat(path43, function(er, stat17) {
-      cb(er, er ? false : checkStat(stat17, options3));
-    });
-  }
-  function sync2(path43, options3) {
-    return checkStat(fs15.statSync(path43), options3);
-  }
-  function checkStat(stat17, options3) {
-    return stat17.isFile() && checkMode(stat17, options3);
-  }
-  function checkMode(stat17, options3) {
-    var mod = stat17.mode;
-    var uid = stat17.uid;
-    var gid = stat17.gid;
-    var myUid = options3.uid !== undefined ? options3.uid : process.getuid && process.getuid();
-    var myGid = options3.gid !== undefined ? options3.gid : process.getgid && process.getgid();
-    var u2 = parseInt("100", 8);
-    var g = parseInt("010", 8);
-    var o3 = parseInt("001", 8);
-    var ug = u2 | g;
-    var ret = mod & o3 || mod & g && gid === myGid || mod & u2 && uid === myUid || mod & ug && myUid === 0;
-    return ret;
-  }
-});
-
-// node_modules/isexe/index.js
-var require_isexe = __commonJS((exports, module3) => {
-  var fs15 = __require("fs");
-  var core4;
-  if (process.platform === "win32" || global.TESTING_WINDOWS) {
-    core4 = require_windows();
-  } else {
-    core4 = require_mode();
-  }
-  module3.exports = isexe;
-  isexe.sync = sync2;
-  function isexe(path43, options3, cb) {
-    if (typeof options3 === "function") {
-      cb = options3;
-      options3 = {};
-    }
-    if (!cb) {
-      if (typeof Promise !== "function") {
-        throw new TypeError("callback not provided");
-      }
-      return new Promise(function(resolve34, reject) {
-        isexe(path43, options3 || {}, function(er, is) {
-          if (er) {
-            reject(er);
-          } else {
-            resolve34(is);
-          }
-        });
-      });
-    }
-    core4(path43, options3 || {}, function(er, is) {
-      if (er) {
-        if (er.code === "EACCES" || options3 && options3.ignoreErrors) {
-          er = null;
-          is = false;
-        }
-      }
-      cb(er, is);
-    });
-  }
-  function sync2(path43, options3) {
-    try {
-      return core4.sync(path43, options3 || {});
-    } catch (er) {
-      if (options3 && options3.ignoreErrors || er.code === "EACCES") {
-        return false;
-      } else {
-        throw er;
-      }
-    }
-  }
-});
-
-// node_modules/which/which.js
-var require_which = __commonJS((exports, module3) => {
-  var isWindows3 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-  var path43 = __require("path");
-  var COLON2 = isWindows3 ? ";" : ":";
-  var isexe = require_isexe();
-  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-  var getPathInfo = (cmd, opt) => {
-    const colon = opt.colon || COLON2;
-    const pathEnv = cmd.match(/\//) || isWindows3 && cmd.match(/\\/) ? [""] : [
-      ...isWindows3 ? [process.cwd()] : [],
-      ...(opt.path || process.env.PATH || "").split(colon)
-    ];
-    const pathExtExe = isWindows3 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-    const pathExt = isWindows3 ? pathExtExe.split(colon) : [""];
-    if (isWindows3) {
-      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
-        pathExt.unshift("");
-    }
-    return {
-      pathEnv,
-      pathExt,
-      pathExtExe
-    };
-  };
-  var which = (cmd, opt, cb) => {
-    if (typeof opt === "function") {
-      cb = opt;
-      opt = {};
-    }
-    if (!opt)
-      opt = {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    const step = (i4) => new Promise((resolve34, reject) => {
-      if (i4 === pathEnv.length)
-        return opt.all && found.length ? resolve34(found) : reject(getNotFoundError(cmd));
-      const ppRaw = pathEnv[i4];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path43.join(pathPart, cmd);
-      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve34(subStep(p2, i4, 0));
-    });
-    const subStep = (p2, i4, ii) => new Promise((resolve34, reject) => {
-      if (ii === pathExt.length)
-        return resolve34(step(i4 + 1));
-      const ext3 = pathExt[ii];
-      isexe(p2 + ext3, { pathExt: pathExtExe }, (er, is) => {
-        if (!er && is) {
-          if (opt.all)
-            found.push(p2 + ext3);
-          else
-            return resolve34(p2 + ext3);
-        }
-        return resolve34(subStep(p2, i4, ii + 1));
-      });
-    });
-    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-  };
-  var whichSync = (cmd, opt) => {
-    opt = opt || {};
-    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-    const found = [];
-    for (let i4 = 0;i4 < pathEnv.length; i4++) {
-      const ppRaw = pathEnv[i4];
-      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-      const pCmd = path43.join(pathPart, cmd);
-      const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      for (let j2 = 0;j2 < pathExt.length; j2++) {
-        const cur = p2 + pathExt[j2];
-        try {
-          const is = isexe.sync(cur, { pathExt: pathExtExe });
-          if (is) {
-            if (opt.all)
-              found.push(cur);
-            else
-              return cur;
-          }
-        } catch (ex) {}
-      }
-    }
-    if (opt.all && found.length)
-      return found;
-    if (opt.nothrow)
-      return null;
-    throw getNotFoundError(cmd);
-  };
-  module3.exports = which;
-  which.sync = whichSync;
-});
-
-// node_modules/path-key/index.js
-var require_path_key = __commonJS((exports, module3) => {
-  var pathKey = (options3 = {}) => {
-    const environment2 = options3.env || process.env;
-    const platform10 = options3.platform || process.platform;
-    if (platform10 !== "win32") {
-      return "PATH";
-    }
-    return Object.keys(environment2).reverse().find((key2) => key2.toUpperCase() === "PATH") || "Path";
-  };
-  module3.exports = pathKey;
-  module3.exports.default = pathKey;
-});
-
-// node_modules/cross-spawn/lib/util/resolveCommand.js
-var require_resolveCommand = __commonJS((exports, module3) => {
-  var path43 = __require("path");
-  var which = require_which();
-  var getPathKey = require_path_key();
-  function resolveCommandAttempt(parsed, withoutPathExt) {
-    const env5 = parsed.options.env || process.env;
-    const cwd2 = process.cwd();
-    const hasCustomCwd = parsed.options.cwd != null;
-    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
-    if (shouldSwitchCwd) {
-      try {
-        process.chdir(parsed.options.cwd);
-      } catch (err) {}
-    }
-    let resolved;
-    try {
-      resolved = which.sync(parsed.command, {
-        path: env5[getPathKey({ env: env5 })],
-        pathExt: withoutPathExt ? path43.delimiter : undefined
-      });
-    } catch (e2) {} finally {
-      if (shouldSwitchCwd) {
-        process.chdir(cwd2);
-      }
-    }
-    if (resolved) {
-      resolved = path43.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
-    }
-    return resolved;
-  }
-  function resolveCommand(parsed) {
-    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-  }
-  module3.exports = resolveCommand;
-});
-
-// node_modules/cross-spawn/lib/util/escape.js
-var require_escape = __commonJS((exports, module3) => {
-  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-  function escapeCommand(arg) {
-    arg = arg.replace(metaCharsRegExp, "^$1");
-    return arg;
-  }
-  function escapeArgument(arg, doubleEscapeMetaChars) {
-    arg = `${arg}`;
-    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
-    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
-    arg = `"${arg}"`;
-    arg = arg.replace(metaCharsRegExp, "^$1");
-    if (doubleEscapeMetaChars) {
-      arg = arg.replace(metaCharsRegExp, "^$1");
-    }
-    return arg;
-  }
-  exports.command = escapeCommand;
-  exports.argument = escapeArgument;
-});
-
-// node_modules/shebang-regex/index.js
-var require_shebang_regex = __commonJS((exports, module3) => {
-  module3.exports = /^#!(.*)/;
-});
-
-// node_modules/shebang-command/index.js
-var require_shebang_command = __commonJS((exports, module3) => {
-  var shebangRegex = require_shebang_regex();
-  module3.exports = (string7 = "") => {
-    const match4 = string7.match(shebangRegex);
-    if (!match4) {
-      return null;
-    }
-    const [path43, argument] = match4[0].replace(/#! ?/, "").split(" ");
-    const binary = path43.split("/").pop();
-    if (binary === "env") {
-      return argument;
-    }
-    return argument ? `${binary} ${argument}` : binary;
-  };
-});
-
-// node_modules/cross-spawn/lib/util/readShebang.js
-var require_readShebang = __commonJS((exports, module3) => {
-  var fs15 = __require("fs");
-  var shebangCommand = require_shebang_command();
-  function readShebang(command) {
-    const size = 150;
-    const buffer = Buffer.alloc(size);
-    let fd;
-    try {
-      fd = fs15.openSync(command, "r");
-      fs15.readSync(fd, buffer, 0, size, 0);
-      fs15.closeSync(fd);
-    } catch (e2) {}
-    return shebangCommand(buffer.toString());
-  }
-  module3.exports = readShebang;
-});
-
-// node_modules/cross-spawn/lib/parse.js
-var require_parse3 = __commonJS((exports, module3) => {
-  var path43 = __require("path");
-  var resolveCommand = require_resolveCommand();
-  var escape4 = require_escape();
-  var readShebang = require_readShebang();
-  var isWin2 = process.platform === "win32";
-  var isExecutableRegExp = /\.(?:com|exe)$/i;
-  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-  function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
-    const shebang = parsed.file && readShebang(parsed.file);
-    if (shebang) {
-      parsed.args.unshift(parsed.file);
-      parsed.command = shebang;
-      return resolveCommand(parsed);
-    }
-    return parsed.file;
-  }
-  function parseNonShell(parsed) {
-    if (!isWin2) {
-      return parsed;
-    }
-    const commandFile = detectShebang(parsed);
-    const needsShell = !isExecutableRegExp.test(commandFile);
-    if (parsed.options.forceShell || needsShell) {
-      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-      parsed.command = path43.normalize(parsed.command);
-      parsed.command = escape4.command(parsed.command);
-      parsed.args = parsed.args.map((arg) => escape4.argument(arg, needsDoubleEscapeMetaChars));
-      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-      parsed.command = process.env.comspec || "cmd.exe";
-      parsed.options.windowsVerbatimArguments = true;
-    }
-    return parsed;
-  }
-  function parse9(command, args, options3) {
-    if (args && !Array.isArray(args)) {
-      options3 = args;
-      args = null;
-    }
-    args = args ? args.slice(0) : [];
-    options3 = Object.assign({}, options3);
-    const parsed = {
-      command,
-      args,
-      options: options3,
-      file: undefined,
-      original: {
-        command,
-        args
-      }
-    };
-    return options3.shell ? parsed : parseNonShell(parsed);
-  }
-  module3.exports = parse9;
-});
-
-// node_modules/cross-spawn/lib/enoent.js
-var require_enoent = __commonJS((exports, module3) => {
-  var isWin2 = process.platform === "win32";
-  function notFoundError(original, syscall) {
-    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-      code: "ENOENT",
-      errno: "ENOENT",
-      syscall: `${syscall} ${original.command}`,
-      path: original.command,
-      spawnargs: original.args
-    });
-  }
-  function hookChildProcess(cp2, parsed) {
-    if (!isWin2) {
-      return;
-    }
-    const originalEmit = cp2.emit;
-    cp2.emit = function(name, arg1) {
-      if (name === "exit") {
-        const err = verifyENOENT(arg1, parsed);
-        if (err) {
-          return originalEmit.call(cp2, "error", err);
-        }
-      }
-      return originalEmit.apply(cp2, arguments);
-    };
-  }
-  function verifyENOENT(status, parsed) {
-    if (isWin2 && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawn");
-    }
-    return null;
-  }
-  function verifyENOENTSync(status, parsed) {
-    if (isWin2 && status === 1 && !parsed.file) {
-      return notFoundError(parsed.original, "spawnSync");
-    }
-    return null;
-  }
-  module3.exports = {
-    hookChildProcess,
-    verifyENOENT,
-    verifyENOENTSync,
-    notFoundError
-  };
-});
-
-// node_modules/cross-spawn/index.js
-var require_cross_spawn = __commonJS((exports, module3) => {
-  var cp2 = __require("child_process");
-  var parse9 = require_parse3();
-  var enoent = require_enoent();
-  function spawn14(command, args, options3) {
-    const parsed = parse9(command, args, options3);
-    const spawned = cp2.spawn(parsed.command, parsed.args, parsed.options);
-    enoent.hookChildProcess(spawned, parsed);
-    return spawned;
-  }
-  function spawnSync4(command, args, options3) {
-    const parsed = parse9(command, args, options3);
-    const result = cp2.spawnSync(parsed.command, parsed.args, parsed.options);
-    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-    return result;
-  }
-  module3.exports = spawn14;
-  module3.exports.spawn = spawn14;
-  module3.exports.sync = spawnSync4;
-  module3.exports._parse = parse9;
-  module3.exports._enoent = enoent;
-});
-
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 class ReadBuffer {
   constructor(options3) {
@@ -487529,7 +487788,7 @@ class StdioClientTransport {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
     return new Promise((resolve34, reject) => {
-      this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
+      this._process = import_cross_spawn2.default(this._serverParams.command, this._serverParams.args ?? [], {
         env: {
           ...getDefaultEnvironment(),
           ...this._serverParams.env
@@ -487633,10 +487892,10 @@ class StdioClientTransport {
     });
   }
 }
-var import_cross_spawn, DEFAULT_INHERITED_ENV_VARS;
+var import_cross_spawn2, DEFAULT_INHERITED_ENV_VARS;
 var init_stdio2 = __esm(() => {
   init_stdio();
-  import_cross_spawn = __toESM(require_cross_spawn(), 1);
+  import_cross_spawn2 = __toESM(require_cross_spawn(), 1);
   DEFAULT_INHERITED_ENV_VARS = process20.platform === "win32" ? [
     "APPDATA",
     "HOMEDRIVE",
@@ -488304,7 +488563,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.29.13"
+    version: "0.30.1"
   };
 });
 
@@ -552022,7 +552281,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     importFlagValue: values2.import,
     fromAfFlagValue: values2["from-af"]
   });
-  const isHeadless = values2.prompt || values2.run || !process.stdin.isTTY;
+  const isHeadless = isHeadlessStartup(values2, process.stdin.isTTY, command);
   const terminalThemePromise = !isHeadless ? initTerminalTheme().catch(() => {
     return;
   }) : Promise.resolve(undefined);
@@ -555327,4 +555586,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=891005FA529AE42B64756E2164756E21
+//# debugId=176DD519C90983F764756E2164756E21