@hueyexe/opencode-ensemble 0.13.3 → 0.14.1

package/dist/index.js

@@ -1,19 +1,488 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i = 0;i < pathext.length; i++) {
+      var p = pathext[i].toLowerCase();
+      if (p && path.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat, path, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.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, module) => {
+  var fs = __require("fs");
+  var core2;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core2 = require_windows();
+  } else {
+    core2 = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve(is);
+          }
+        });
+      });
+    }
+    core2(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core2.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path = __require("path");
+  var COLON = 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 || COLON;
+    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 = (i) => new Promise((resolve, reject) => {
+      if (i === pathEnv.length)
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve(subStep(p, i, 0));
+    });
+    const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+      if (ii === pathExt.length)
+        return resolve(step(i + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve(p + ext);
+        }
+        return resolve(subStep(p, i, 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 i = 0;i < pathEnv.length; i++) {
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.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);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = 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: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : undefined
+      });
+    } catch (e) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  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, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string4 = "") => {
+    const match = string4.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path.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, module) => {
+  var fs = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs.openSync(command, "r");
+      fs.readSync(fd, buffer, 0, size, 0);
+      fs.closeSync(fd);
+    } catch (e) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var path = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = 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 = path.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.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 parse5(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse5;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  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;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse5 = require_parse();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse5(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse5(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse5;
+  module.exports._enoent = enoent;
+});
 
 // src/log.ts
 function initLog(client3) {
@@ -13287,6 +13756,94 @@ class HeyApiRegistry {
   }
 }
 
+class Auth extends HeyApiClient {
+  remove(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "providerID" }] }]);
+    return (options?.client ?? this.client).delete({
+      url: "/auth/{providerID}",
+      ...options,
+      ...params
+    });
+  }
+  set(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "providerID" },
+          { key: "auth", map: "body" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).put({
+      url: "/auth/{providerID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
+class App extends HeyApiClient {
+  log(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "service" },
+          { in: "body", key: "level" },
+          { in: "body", key: "message" },
+          { in: "body", key: "extra" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/log",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  agents(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/agent",
+      ...options,
+      ...params
+    });
+  }
+  skills(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/skill",
+      ...options,
+      ...params
+    });
+  }
+}
+
 class Config extends HeyApiClient {
   get(options) {
     return (options?.client ?? this.client).get({
@@ -13347,39 +13904,26 @@ class Global extends HeyApiClient {
   }
 }
 
-class Auth extends HeyApiClient {
-  remove(parameters, options) {
-    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "providerID" }] }]);
-    return (options?.client ?? this.client).delete({
-      url: "/auth/{providerID}",
-      ...options,
-      ...params
-    });
-  }
-  set(parameters, options) {
+class Event extends HeyApiClient {
+  subscribe(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "providerID" },
-          { key: "auth", map: "body" }
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).put({
-      url: "/auth/{providerID}",
+    return (options?.client ?? this.client).sse.get({
+      url: "/event",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
 }
 
-class Project extends HeyApiClient {
-  list(parameters, options) {
+class Config2 extends HeyApiClient {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13389,27 +13933,33 @@ class Project extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/project",
+      url: "/config",
       ...options,
       ...params
     });
   }
-  current(parameters, options) {
+  update(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { key: "config", map: "body" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/project/current",
+    return (options?.client ?? this.client).patch({
+      url: "/config",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-  initGit(parameters, options) {
+  providers(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13418,40 +13968,31 @@ class Project extends HeyApiClient {
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/project/git/init",
+    return (options?.client ?? this.client).get({
+      url: "/config/providers",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
+}
+
+class Console extends HeyApiClient {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "projectID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "name" },
-          { in: "body", key: "icon" },
-          { in: "body", key: "commands" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).patch({
-      url: "/project/{projectID}",
+    return (options?.client ?? this.client).get({
+      url: "/experimental/console",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-}
-
-class Pty extends HeyApiClient {
-  list(parameters, options) {
+  listOrgs(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13461,27 +14002,24 @@ class Pty extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/pty",
+      url: "/experimental/console/orgs",
       ...options,
       ...params
     });
   }
-  create(parameters, options) {
+  switchOrg(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "command" },
-          { in: "body", key: "args" },
-          { in: "body", key: "cwd" },
-          { in: "body", key: "title" },
-          { in: "body", key: "env" }
+          { in: "body", key: "accountID" },
+          { in: "body", key: "orgID" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/pty",
+      url: "/experimental/console/switch",
       ...options,
       ...params,
       headers: {
@@ -13491,81 +14029,70 @@ class Pty extends HeyApiClient {
       }
     });
   }
-  remove(parameters, options) {
+}
+
+class Session extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "roots" },
+          { in: "query", key: "start" },
+          { in: "query", key: "cursor" },
+          { in: "query", key: "search" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "archived" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/pty/{ptyID}",
+    return (options?.client ?? this.client).get({
+      url: "/experimental/session",
       ...options,
       ...params
     });
   }
-  get(parameters, options) {
+}
+
+class Resource extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/pty/{ptyID}",
+      url: "/experimental/resource",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "path", key: "ptyID" },
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "title" },
-          { in: "body", key: "size" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).put({
-      url: "/pty/{ptyID}",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  connect(parameters, options) {
+}
+
+class Adapter extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/pty/{ptyID}/connect",
+      url: "/experimental/workspace/adapter",
       ...options,
       ...params
     });
   }
 }
 
-class Config2 extends HeyApiClient {
-  get(parameters, options) {
+class Workspace extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13575,23 +14102,26 @@ class Config2 extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/config",
+      url: "/experimental/workspace",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
+  create(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { key: "config", map: "body" }
+          { in: "body", key: "id" },
+          { in: "body", key: "type" },
+          { in: "body", key: "branch" },
+          { in: "body", key: "extra" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).patch({
-      url: "/config",
+    return (options?.client ?? this.client).post({
+      url: "/experimental/workspace",
       ...options,
       ...params,
       headers: {
@@ -13601,7 +14131,7 @@ class Config2 extends HeyApiClient {
       }
     });
   }
-  providers(parameters, options) {
+  syncList(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13610,16 +14140,13 @@ class Config2 extends HeyApiClient {
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/config/providers",
+    return (options?.client ?? this.client).post({
+      url: "/experimental/workspace/sync-list",
       ...options,
       ...params
     });
   }
-}
-
-class Tool extends HeyApiClient {
-  ids(parameters, options) {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13629,61 +14156,41 @@ class Tool extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/experimental/tool/ids",
-      ...options,
-      ...params
-    });
-  }
-  list(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "provider" },
-          { in: "query", key: "model" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/experimental/tool",
+      url: "/experimental/workspace/status",
       ...options,
       ...params
     });
   }
-}
-
-class Workspace extends HeyApiClient {
-  list(parameters, options) {
+  remove(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "id" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/experimental/workspace",
+    return (options?.client ?? this.client).delete({
+      url: "/experimental/workspace/{id}",
       ...options,
       ...params
     });
   }
-  create(parameters, options) {
+  warp(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
           { in: "body", key: "id" },
-          { in: "body", key: "type" },
-          { in: "body", key: "branch" },
-          { in: "body", key: "extra" }
+          { in: "body", key: "sessionID" },
+          { in: "body", key: "copyChanges" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/experimental/workspace",
+      url: "/experimental/workspace/warp",
       ...options,
       ...params,
       headers: {
@@ -13693,50 +14200,50 @@ class Workspace extends HeyApiClient {
       }
     });
   }
-  remove(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "path", key: "id" },
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).delete({
-      url: "/experimental/workspace/{id}",
-      ...options,
-      ...params
-    });
+  _adapter;
+  get adapter() {
+    return this._adapter ??= new Adapter({ client: this.client });
   }
 }
 
-class Session extends HeyApiClient {
+class Experimental extends HeyApiClient {
+  _console;
+  get console() {
+    return this._console ??= new Console({ client: this.client });
+  }
+  _session;
+  get session() {
+    return this._session ??= new Session({ client: this.client });
+  }
+  _resource;
+  get resource() {
+    return this._resource ??= new Resource({ client: this.client });
+  }
+  _workspace;
+  get workspace() {
+    return this._workspace ??= new Workspace({ client: this.client });
+  }
+}
+
+class Tool extends HeyApiClient {
   list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "roots" },
-          { in: "query", key: "start" },
-          { in: "query", key: "cursor" },
-          { in: "query", key: "search" },
-          { in: "query", key: "limit" },
-          { in: "query", key: "archived" }
+          { in: "query", key: "provider" },
+          { in: "query", key: "model" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/experimental/session",
+      url: "/experimental/tool",
       ...options,
       ...params
     });
   }
-}
-
-class Resource extends HeyApiClient {
-  list(parameters, options) {
+  ids(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13746,28 +14253,13 @@ class Resource extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/experimental/resource",
+      url: "/experimental/tool/ids",
       ...options,
       ...params
     });
   }
 }
 
-class Experimental extends HeyApiClient {
-  _workspace;
-  get workspace() {
-    return this._workspace ??= new Workspace({ client: this.client });
-  }
-  _session;
-  get session() {
-    return this._session ??= new Session({ client: this.client });
-  }
-  _resource;
-  get resource() {
-    return this._resource ??= new Resource({ client: this.client });
-  }
-}
-
 class Worktree extends HeyApiClient {
   remove(parameters, options) {
     const params = buildClientParams([parameters], [
@@ -13849,242 +14341,191 @@ class Worktree extends HeyApiClient {
   }
 }
 
-class Session2 extends HeyApiClient {
-  list(parameters, options) {
+class Find extends HeyApiClient {
+  text(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "roots" },
-          { in: "query", key: "start" },
-          { in: "query", key: "search" },
-          { in: "query", key: "limit" }
+          { in: "query", key: "pattern" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session",
+      url: "/find",
       ...options,
       ...params
     });
   }
-  create(parameters, options) {
+  files(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "parentID" },
-          { in: "body", key: "title" },
-          { in: "body", key: "permission" },
-          { in: "body", key: "workspaceID" }
+          { in: "query", key: "query" },
+          { in: "query", key: "dirs" },
+          { in: "query", key: "type" },
+          { in: "query", key: "limit" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session",
+    return (options?.client ?? this.client).get({
+      url: "/find/file",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  status(parameters, options) {
+  symbols(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "query" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/status",
+      url: "/find/symbol",
       ...options,
       ...params
     });
   }
-  delete(parameters, options) {
+}
+
+class File2 extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}",
-      ...options,
-      ...params
-    });
-  }
-  get(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "path", key: "sessionID" },
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "path" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}",
+      url: "/file",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
+  read(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "title" },
-          { in: "body", key: "time" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).patch({
-      url: "/session/{sessionID}",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  children(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "path", key: "sessionID" },
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "path" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/children",
+      url: "/file/content",
       ...options,
       ...params
     });
   }
-  todo(parameters, options) {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/todo",
+      url: "/file/status",
       ...options,
       ...params
     });
   }
-  init(parameters, options) {
+}
+
+class Instance extends HeyApiClient {
+  dispose(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "modelID" },
-          { in: "body", key: "providerID" },
-          { in: "body", key: "messageID" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/init",
+      url: "/instance/dispose",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  fork(parameters, options) {
+}
+
+class Path extends HeyApiClient {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "messageID" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/fork",
+    return (options?.client ?? this.client).get({
+      url: "/path",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  abort(parameters, options) {
+}
+
+class Diff extends HeyApiClient {
+  raw(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/abort",
+    return (options?.client ?? this.client).get({
+      url: "/vcs/diff/raw",
       ...options,
       ...params
     });
   }
-  unshare(parameters, options) {
+}
+
+class Vcs extends HeyApiClient {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}/share",
+    return (options?.client ?? this.client).get({
+      url: "/vcs",
       ...options,
       ...params
     });
   }
-  share(parameters, options) {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/share",
+    return (options?.client ?? this.client).get({
+      url: "/vcs/status",
       ...options,
       ...params
     });
@@ -14093,34 +14534,30 @@ class Session2 extends HeyApiClient {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "messageID" }
+          { in: "query", key: "mode" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/diff",
+      url: "/vcs/diff",
       ...options,
       ...params
     });
   }
-  summarize(parameters, options) {
+  apply(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "providerID" },
-          { in: "body", key: "modelID" },
-          { in: "body", key: "auto" }
+          { in: "body", key: "patch" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/summarize",
+      url: "/vcs/apply",
       ...options,
       ...params,
       headers: {
@@ -14130,137 +14567,112 @@ class Session2 extends HeyApiClient {
       }
     });
   }
-  messages(parameters, options) {
+  _diff;
+  get diff2() {
+    return this._diff ??= new Diff({ client: this.client });
+  }
+}
+
+class Command extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "limit" },
-          { in: "query", key: "before" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/message",
+      url: "/command",
       ...options,
       ...params
     });
   }
-  prompt(parameters, options) {
+}
+
+class Lsp extends HeyApiClient {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "messageID" },
-          { in: "body", key: "model" },
-          { in: "body", key: "agent" },
-          { in: "body", key: "noReply" },
-          { in: "body", key: "tools" },
-          { in: "body", key: "format" },
-          { in: "body", key: "system" },
-          { in: "body", key: "variant" },
-          { in: "body", key: "parts" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/message",
+    return (options?.client ?? this.client).get({
+      url: "/lsp",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  deleteMessage(parameters, options) {
+}
+
+class Formatter extends HeyApiClient {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "messageID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}/message/{messageID}",
+    return (options?.client ?? this.client).get({
+      url: "/formatter",
       ...options,
       ...params
     });
   }
-  message(parameters, options) {
+}
+
+class Auth2 extends HeyApiClient {
+  remove(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "messageID" },
+          { in: "path", key: "name" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/message/{messageID}",
+    return (options?.client ?? this.client).delete({
+      url: "/mcp/{name}/auth",
       ...options,
       ...params
     });
   }
-  promptAsync(parameters, options) {
+  start(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
+          { in: "path", key: "name" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "messageID" },
-          { in: "body", key: "model" },
-          { in: "body", key: "agent" },
-          { in: "body", key: "noReply" },
-          { in: "body", key: "tools" },
-          { in: "body", key: "format" },
-          { in: "body", key: "system" },
-          { in: "body", key: "variant" },
-          { in: "body", key: "parts" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/prompt_async",
+      url: "/mcp/{name}/auth",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  command(parameters, options) {
+  callback(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
+          { in: "path", key: "name" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "messageID" },
-          { in: "body", key: "agent" },
-          { in: "body", key: "model" },
-          { in: "body", key: "arguments" },
-          { in: "body", key: "command" },
-          { in: "body", key: "variant" },
-          { in: "body", key: "parts" }
+          { in: "body", key: "code" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/command",
+      url: "/mcp/{name}/auth/callback",
       ...options,
       ...params,
       headers: {
@@ -14270,44 +14682,53 @@ class Session2 extends HeyApiClient {
       }
     });
   }
-  shell(parameters, options) {
+  authenticate(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
+          { in: "path", key: "name" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "agent" },
-          { in: "body", key: "model" },
-          { in: "body", key: "command" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/shell",
+      url: "/mcp/{name}/auth/authenticate",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  revert(parameters, options) {
+}
+
+class Mcp extends HeyApiClient {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "messageID" },
-          { in: "body", key: "partID" }
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/mcp",
+      ...options,
+      ...params
+    });
+  }
+  add(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "name" },
+          { in: "body", key: "config" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/revert",
+      url: "/mcp",
       ...options,
       ...params,
       headers: {
@@ -14317,107 +14738,105 @@ class Session2 extends HeyApiClient {
       }
     });
   }
-  unrevert(parameters, options) {
+  connect(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
+          { in: "path", key: "name" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/unrevert",
+      url: "/mcp/{name}/connect",
+      ...options,
+      ...params
+    });
+  }
+  disconnect(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "name" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/disconnect",
       ...options,
       ...params
     });
   }
+  _auth;
+  get auth() {
+    return this._auth ??= new Auth2({ client: this.client });
+  }
 }
 
-class Part extends HeyApiClient {
-  delete(parameters, options) {
+class Project extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "messageID" },
-          { in: "path", key: "partID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+    return (options?.client ?? this.client).get({
+      url: "/project",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
+  current(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "messageID" },
-          { in: "path", key: "partID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { key: "part", map: "body" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).patch({
-      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+    return (options?.client ?? this.client).get({
+      url: "/project/current",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-}
-
-class Permission extends HeyApiClient {
-  respond(parameters, options) {
+  initGit(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "permissionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "response" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/permissions/{permissionID}",
+      url: "/project/git/init",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  reply(parameters, options) {
+  update(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "requestID" },
+          { in: "path", key: "projectID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "reply" },
-          { in: "body", key: "message" }
+          { in: "body", key: "name" },
+          { in: "body", key: "icon" },
+          { in: "body", key: "commands" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/permission/{requestID}/reply",
+    return (options?.client ?? this.client).patch({
+      url: "/project/{projectID}",
       ...options,
       ...params,
       headers: {
@@ -14427,7 +14846,10 @@ class Permission extends HeyApiClient {
       }
     });
   }
-  list(parameters, options) {
+}
+
+class Pty extends HeyApiClient {
+  shells(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -14437,14 +14859,11 @@ class Permission extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/permission",
+      url: "/pty/shells",
       ...options,
       ...params
     });
   }
-}
-
-class Question extends HeyApiClient {
   list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
@@ -14455,24 +14874,27 @@ class Question extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/question",
+      url: "/pty",
       ...options,
       ...params
     });
   }
-  reply(parameters, options) {
+  create(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "requestID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "answers" }
+          { in: "body", key: "command" },
+          { in: "body", key: "args" },
+          { in: "body", key: "cwd" },
+          { in: "body", key: "title" },
+          { in: "body", key: "env" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/question/{requestID}/reply",
+      url: "/pty",
       ...options,
       ...params,
       headers: {
@@ -14482,62 +14904,52 @@ class Question extends HeyApiClient {
       }
     });
   }
-  reject(parameters, options) {
+  remove(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "requestID" },
+          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/question/{requestID}/reject",
+    return (options?.client ?? this.client).delete({
+      url: "/pty/{ptyID}",
       ...options,
       ...params
     });
   }
-}
-
-class Oauth extends HeyApiClient {
-  authorize(parameters, options) {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "providerID" },
+          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "method" },
-          { in: "body", key: "inputs" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/provider/{providerID}/oauth/authorize",
+    return (options?.client ?? this.client).get({
+      url: "/pty/{ptyID}",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  callback(parameters, options) {
+  update(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "providerID" },
+          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "method" },
-          { in: "body", key: "code" }
+          { in: "body", key: "title" },
+          { in: "body", key: "size" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/provider/{providerID}/oauth/callback",
+    return (options?.client ?? this.client).put({
+      url: "/pty/{ptyID}",
       ...options,
       ...params,
       headers: {
@@ -14547,151 +14959,211 @@ class Oauth extends HeyApiClient {
       }
     });
   }
-}
-
-class Provider extends HeyApiClient {
-  list(parameters, options) {
+  connectToken(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/provider",
+    return (options?.client ?? this.client).post({
+      url: "/pty/{ptyID}/connect-token",
       ...options,
       ...params
     });
   }
-  auth(parameters, options) {
+  connect(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "ptyID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/provider/auth",
+      url: "/pty/{ptyID}/connect",
       ...options,
       ...params
     });
   }
-  _oauth;
-  get oauth() {
-    return this._oauth ??= new Oauth({ client: this.client });
-  }
 }
 
-class Find extends HeyApiClient {
-  text(parameters, options) {
+class Question extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "pattern" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/find",
+      url: "/question",
       ...options,
       ...params
     });
   }
-  files(parameters, options) {
+  reply(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "requestID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "query" },
-          { in: "query", key: "dirs" },
-          { in: "query", key: "type" },
-          { in: "query", key: "limit" }
+          { in: "body", key: "answers" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/find/file",
+    return (options?.client ?? this.client).post({
+      url: "/question/{requestID}/reply",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-  symbols(parameters, options) {
+  reject(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "requestID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "query" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/find/symbol",
+    return (options?.client ?? this.client).post({
+      url: "/question/{requestID}/reject",
       ...options,
       ...params
     });
   }
 }
 
-class File2 extends HeyApiClient {
+class Permission extends HeyApiClient {
   list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "path" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/file",
+      url: "/permission",
       ...options,
       ...params
     });
   }
-  read(parameters, options) {
+  reply(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "requestID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "path" }
+          { in: "body", key: "reply" },
+          { in: "body", key: "message" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/file/content",
+    return (options?.client ?? this.client).post({
+      url: "/permission/{requestID}/reply",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-  status(parameters, options) {
+  respond(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "permissionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "body", key: "response" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/file/status",
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/permissions/{permissionID}",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
 }
 
-class Event extends HeyApiClient {
-  subscribe(parameters, options) {
+class Oauth extends HeyApiClient {
+  authorize(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "providerID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "method" },
+          { in: "body", key: "inputs" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/provider/{providerID}/oauth/authorize",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  callback(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "providerID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "method" },
+          { in: "body", key: "code" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/provider/{providerID}/oauth/callback",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
+class Provider extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -14700,60 +15172,631 @@ class Event extends HeyApiClient {
         ]
       }
     ]);
-    return (options?.client ?? this.client).sse.get({
-      url: "/event",
+    return (options?.client ?? this.client).get({
+      url: "/provider",
+      ...options,
+      ...params
+    });
+  }
+  auth(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/provider/auth",
       ...options,
       ...params
     });
   }
+  _oauth;
+  get oauth() {
+    return this._oauth ??= new Oauth({ client: this.client });
+  }
 }
 
-class Auth2 extends HeyApiClient {
-  remove(parameters, options) {
+class Session2 extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "query", key: "scope" },
+          { in: "query", key: "path" },
+          { in: "query", key: "roots" },
+          { in: "query", key: "start" },
+          { in: "query", key: "search" },
+          { in: "query", key: "limit" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session",
+      ...options,
+      ...params
+    });
+  }
+  create(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "parentID" },
+          { in: "body", key: "title" },
+          { in: "body", key: "agent" },
+          { in: "body", key: "model" },
+          { in: "body", key: "permission" },
+          { in: "body", key: "workspaceID" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  status(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/status",
+      ...options,
+      ...params
+    });
+  }
+  delete(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).delete({
-      url: "/mcp/{name}/auth",
+      url: "/session/{sessionID}",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}",
+      ...options,
+      ...params
+    });
+  }
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "title" },
+          { in: "body", key: "permission" },
+          { in: "body", key: "time" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/session/{sessionID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  children(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/children",
+      ...options,
+      ...params
+    });
+  }
+  todo(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/todo",
+      ...options,
+      ...params
+    });
+  }
+  diff(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "query", key: "messageID" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/diff",
       ...options,
       ...params
     });
   }
+  messages(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "before" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/message",
+      ...options,
+      ...params
+    });
+  }
+  prompt(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" },
+          { in: "body", key: "model" },
+          { in: "body", key: "agent" },
+          { in: "body", key: "noReply" },
+          { in: "body", key: "tools" },
+          { in: "body", key: "format" },
+          { in: "body", key: "system" },
+          { in: "body", key: "variant" },
+          { in: "body", key: "parts" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/message",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  deleteMessage(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "messageID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/message/{messageID}",
+      ...options,
+      ...params
+    });
+  }
+  message(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "messageID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/message/{messageID}",
+      ...options,
+      ...params
+    });
+  }
+  fork(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/fork",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  abort(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/abort",
+      ...options,
+      ...params
+    });
+  }
+  init(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "modelID" },
+          { in: "body", key: "providerID" },
+          { in: "body", key: "messageID" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/init",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  unshare(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/share",
+      ...options,
+      ...params
+    });
+  }
+  share(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/share",
+      ...options,
+      ...params
+    });
+  }
+  summarize(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "providerID" },
+          { in: "body", key: "modelID" },
+          { in: "body", key: "auto" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/summarize",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  promptAsync(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" },
+          { in: "body", key: "model" },
+          { in: "body", key: "agent" },
+          { in: "body", key: "noReply" },
+          { in: "body", key: "tools" },
+          { in: "body", key: "format" },
+          { in: "body", key: "system" },
+          { in: "body", key: "variant" },
+          { in: "body", key: "parts" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/prompt_async",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  command(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" },
+          { in: "body", key: "agent" },
+          { in: "body", key: "model" },
+          { in: "body", key: "arguments" },
+          { in: "body", key: "command" },
+          { in: "body", key: "variant" },
+          { in: "body", key: "parts" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/command",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  shell(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" },
+          { in: "body", key: "agent" },
+          { in: "body", key: "model" },
+          { in: "body", key: "command" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/shell",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  revert(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "messageID" },
+          { in: "body", key: "partID" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/revert",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  unrevert(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/unrevert",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Part extends HeyApiClient {
+  delete(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "messageID" },
+          { in: "path", key: "partID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      ...options,
+      ...params
+    });
+  }
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "messageID" },
+          { in: "path", key: "partID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { key: "part", map: "body" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
+class History extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { key: "body", map: "body" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/sync/history",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
+class Sync extends HeyApiClient {
   start(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/auth",
+      url: "/sync/start",
       ...options,
       ...params
     });
   }
-  callback(parameters, options) {
+  replay(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
-          { in: "query", key: "directory" },
+          {
+            in: "query",
+            key: "query_directory",
+            map: "directory"
+          },
           { in: "query", key: "workspace" },
-          { in: "body", key: "code" }
+          {
+            in: "body",
+            key: "body_directory",
+            map: "directory"
+          },
+          { in: "body", key: "events" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/auth/callback",
+      url: "/sync/replay",
       ...options,
       ...params,
       headers: {
@@ -14763,26 +15806,35 @@ class Auth2 extends HeyApiClient {
       }
     });
   }
-  authenticate(parameters, options) {
+  steal(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "body", key: "sessionID" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/auth/authenticate",
+      url: "/sync/steal",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
+  _history;
+  get history() {
+    return this._history ??= new History({ client: this.client });
+  }
 }
 
-class Mcp extends HeyApiClient {
-  status(parameters, options) {
+class Session3 extends HeyApiClient {
+  list(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -14792,24 +15844,25 @@ class Mcp extends HeyApiClient {
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/mcp",
+      url: "/api/session",
       ...options,
       ...params
     });
   }
-  add(parameters, options) {
+  prompt(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "name" },
-          { in: "body", key: "config" }
+          { in: "body", key: "prompt" },
+          { in: "body", key: "delivery" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp",
+      url: "/api/session/{sessionID}/prompt",
       ...options,
       ...params,
       headers: {
@@ -14819,41 +15872,76 @@ class Mcp extends HeyApiClient {
       }
     });
   }
-  connect(parameters, options) {
+  compact(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/connect",
+      url: "/api/session/{sessionID}/compact",
       ...options,
       ...params
     });
   }
-  disconnect(parameters, options) {
+  wait(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/disconnect",
+      url: "/api/session/{sessionID}/wait",
       ...options,
       ...params
     });
   }
-  _auth;
-  get auth() {
-    return this._auth ??= new Auth2({ client: this.client });
+  context(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/api/session/{sessionID}/context",
+      ...options,
+      ...params
+    });
+  }
+  messages(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "sessionID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/api/session/{sessionID}/message",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class V2 extends HeyApiClient {
+  _session;
+  get session() {
+    return this._session ??= new Session3({ client: this.client });
   }
 }
 
@@ -15050,220 +16138,55 @@ class Tui extends HeyApiClient {
         "Content-Type": "application/json",
         ...options?.headers,
         ...params.headers
-      }
-    });
-  }
-  publish(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { key: "body", map: "body" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).post({
-      url: "/tui/publish",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  selectSession(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "sessionID" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).post({
-      url: "/tui/select-session",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  _control;
-  get control() {
-    return this._control ??= new Control({ client: this.client });
-  }
-}
-
-class Instance extends HeyApiClient {
-  dispose(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).post({
-      url: "/instance/dispose",
-      ...options,
-      ...params
-    });
-  }
-}
-
-class Path extends HeyApiClient {
-  get(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/path",
-      ...options,
-      ...params
-    });
-  }
-}
-
-class Vcs extends HeyApiClient {
-  get(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/vcs",
-      ...options,
-      ...params
-    });
-  }
-}
-
-class Command extends HeyApiClient {
-  list(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/command",
-      ...options,
-      ...params
-    });
-  }
-}
-
-class App extends HeyApiClient {
-  log(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "body", key: "service" },
-          { in: "body", key: "level" },
-          { in: "body", key: "message" },
-          { in: "body", key: "extra" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).post({
-      url: "/log",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  agents(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/agent",
-      ...options,
-      ...params
-    });
-  }
-  skills(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/skill",
-      ...options,
-      ...params
+      }
     });
   }
-}
-
-class Lsp extends HeyApiClient {
-  status(parameters, options) {
+  publish(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { key: "body", map: "body" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/lsp",
+    return (options?.client ?? this.client).post({
+      url: "/tui/publish",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-}
-
-class Formatter extends HeyApiClient {
-  status(parameters, options) {
+  selectSession(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "body", key: "sessionID" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/formatter",
+    return (options?.client ?? this.client).post({
+      url: "/tui/select-session",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
+  _control;
+  get control() {
+    return this._control ??= new Control({ client: this.client });
+  }
 }
 
 class OpencodeClient extends HeyApiClient {
@@ -15272,58 +16195,38 @@ class OpencodeClient extends HeyApiClient {
     super(args);
     OpencodeClient.__registry.set(this, args?.key);
   }
-  _global;
-  get global() {
-    return this._global ??= new Global({ client: this.client });
-  }
   _auth;
   get auth() {
     return this._auth ??= new Auth({ client: this.client });
   }
-  _project;
-  get project() {
-    return this._project ??= new Project({ client: this.client });
+  _app;
+  get app() {
+    return this._app ??= new App({ client: this.client });
   }
-  _pty;
-  get pty() {
-    return this._pty ??= new Pty({ client: this.client });
+  _global;
+  get global() {
+    return this._global ??= new Global({ client: this.client });
+  }
+  _event;
+  get event() {
+    return this._event ??= new Event({ client: this.client });
   }
   _config;
   get config() {
     return this._config ??= new Config2({ client: this.client });
   }
-  _tool;
-  get tool() {
-    return this._tool ??= new Tool({ client: this.client });
-  }
   _experimental;
   get experimental() {
     return this._experimental ??= new Experimental({ client: this.client });
   }
+  _tool;
+  get tool() {
+    return this._tool ??= new Tool({ client: this.client });
+  }
   _worktree;
   get worktree() {
     return this._worktree ??= new Worktree({ client: this.client });
   }
-  _session;
-  get session() {
-    return this._session ??= new Session2({ client: this.client });
-  }
-  _part;
-  get part() {
-    return this._part ??= new Part({ client: this.client });
-  }
-  _permission;
-  get permission() {
-    return this._permission ??= new Permission({ client: this.client });
-  }
-  _question;
-  get question() {
-    return this._question ??= new Question({ client: this.client });
-  }
-  _provider;
-  get provider() {
-    return this._provider ??= new Provider({ client: this.client });
-  }
   _find;
   get find() {
     return this._find ??= new Find({ client: this.client });
@@ -15332,18 +16235,6 @@ class OpencodeClient extends HeyApiClient {
   get file() {
     return this._file ??= new File2({ client: this.client });
   }
-  _event;
-  get event() {
-    return this._event ??= new Event({ client: this.client });
-  }
-  _mcp;
-  get mcp() {
-    return this._mcp ??= new Mcp({ client: this.client });
-  }
-  _tui;
-  get tui() {
-    return this._tui ??= new Tui({ client: this.client });
-  }
   _instance;
   get instance() {
     return this._instance ??= new Instance({ client: this.client });
@@ -15360,10 +16251,6 @@ class OpencodeClient extends HeyApiClient {
   get command() {
     return this._command ??= new Command({ client: this.client });
   }
-  _app;
-  get app() {
-    return this._app ??= new App({ client: this.client });
-  }
   _lsp;
   get lsp() {
     return this._lsp ??= new Lsp({ client: this.client });
@@ -15372,7 +16259,53 @@ class OpencodeClient extends HeyApiClient {
   get formatter() {
     return this._formatter ??= new Formatter({ client: this.client });
   }
+  _mcp;
+  get mcp() {
+    return this._mcp ??= new Mcp({ client: this.client });
+  }
+  _project;
+  get project() {
+    return this._project ??= new Project({ client: this.client });
+  }
+  _pty;
+  get pty() {
+    return this._pty ??= new Pty({ client: this.client });
+  }
+  _question;
+  get question() {
+    return this._question ??= new Question({ client: this.client });
+  }
+  _permission;
+  get permission() {
+    return this._permission ??= new Permission({ client: this.client });
+  }
+  _provider;
+  get provider() {
+    return this._provider ??= new Provider({ client: this.client });
+  }
+  _session;
+  get session() {
+    return this._session ??= new Session2({ client: this.client });
+  }
+  _part;
+  get part() {
+    return this._part ??= new Part({ client: this.client });
+  }
+  _sync;
+  get sync() {
+    return this._sync ??= new Sync({ client: this.client });
+  }
+  _v2;
+  get v2() {
+    return this._v2 ??= new V2({ client: this.client });
+  }
+  _tui;
+  get tui() {
+    return this._tui ??= new Tui({ client: this.client });
+  }
 }
+// node_modules/@opencode-ai/sdk/dist/v2/server.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
 // src/index.ts
 import path3 from "path";
 import { mkdirSync } from "fs";
@@ -15701,6 +16634,8 @@ async function recoverOrphanedBranches(db, cwd) {
 }
 
 // src/state.ts
+import { randomUUID } from "crypto";
+
 class MemberRegistry {
   bySession = new Map;
   byTeamName = new Map;
@@ -15744,6 +16679,36 @@ class MemberRegistry {
   }
 }
 var DEFAULT_MAX_DEPTH = 10;
+var DEFAULT_PURGE_APPROVAL_TTL_MS = 10 * 60 * 1000;
+function canonicalPurgeKey(purge) {
+  if (purge.includes("*"))
+    return JSON.stringify(["*"]);
+  return JSON.stringify([...new Set(purge)].sort());
+}
+function outputSelectedAnswer(output, label) {
+  const quoted = JSON.stringify(label);
+  return output.includes(`=${quoted}`) || output.includes(`=[${quoted}]`);
+}
+function optionLabels(args) {
+  if (!args || typeof args !== "object")
+    return [];
+  const questions = args.questions;
+  if (!Array.isArray(questions))
+    return [];
+  return questions.flatMap((question) => {
+    if (!question || typeof question !== "object")
+      return [];
+    const options = question.options;
+    if (!Array.isArray(options))
+      return [];
+    return options.flatMap((option) => {
+      if (!option || typeof option !== "object")
+        return [];
+      const label = option.label;
+      return typeof label === "string" ? [label] : [];
+    });
+  });
+}
 
 class DescendantTracker {
   parents = new Map;
@@ -15770,6 +16735,65 @@ class DescendantTracker {
   }
 }
 
+class PendingPurgeApprovals {
+  pending = new Map;
+  ttlMs;
+  now;
+  createToken;
+  constructor(ttlMs = DEFAULT_PURGE_APPROVAL_TTL_MS, now = () => Date.now(), createToken = randomUUID) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+    this.createToken = createToken;
+  }
+  create(sessionId, purge) {
+    this.pruneExpired();
+    const token = this.createToken();
+    this.pending.set(token, {
+      sessionId,
+      purgeKey: canonicalPurgeKey(purge),
+      approved: false,
+      timeCreated: this.now()
+    });
+    return token;
+  }
+  approvalLabel(token) {
+    return `Approve purge ${token.slice(0, 8)}`;
+  }
+  denialLabel(token) {
+    return `Deny purge ${token.slice(0, 8)}`;
+  }
+  recordQuestionAnswer(sessionId, output, args) {
+    this.pruneExpired();
+    const labels = new Set(optionLabels(args));
+    for (const [token, approval] of this.pending.entries()) {
+      const approvalLabel = this.approvalLabel(token);
+      const denialLabel = this.denialLabel(token);
+      const hasRequiredOptions = labels.has(approvalLabel) && labels.has(denialLabel);
+      if (approval.sessionId === sessionId && hasRequiredOptions && outputSelectedAnswer(output, approvalLabel)) {
+        approval.approved = true;
+      }
+    }
+  }
+  consume(sessionId, token, purge) {
+    this.pruneExpired();
+    const approval = this.pending.get(token);
+    if (!approval || approval.sessionId !== sessionId || approval.purgeKey !== canonicalPurgeKey(purge)) {
+      throw new Error("Purge confirmation token is invalid or expired.");
+    }
+    if (!approval.approved) {
+      throw new Error("Purge was not approved by the user. Use the question tool with the exact approval option from the preview before confirming.");
+    }
+    this.pending.delete(token);
+  }
+  pruneExpired() {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [token, approval] of this.pending.entries()) {
+      if (approval.timeCreated < cutoff)
+        this.pending.delete(token);
+    }
+  }
+}
+
 // src/hooks.ts
 var TEAM_TOOL_PREFIX = "team_";
 function handleSessionStatusEvent(db, registry2, sessionId, status) {
@@ -15987,7 +17011,7 @@ function buildLeadSystemPrompt(db, teamId, config2) {
     }
     lines.push(`If user picks "I'll choose per agent", ask for each agent's model individually before each team_spawn call.`, "Pass the chosen model via the model parameter on each team_spawn call.");
   }
-  lines.push("", "Spawn teammates ONE AT A TIME. Wait for each tool result before spawning the next.", "This avoids git worktree contention. Once all are spawned, wait for their messages.", "Read-only agents (explore, plan) automatically skip worktree creation.", "For other agents that only need to read, pass worktree: false to avoid unnecessary isolation.", "", "Teammates work asynchronously and message you when done.", "Do NOT poll team_status or team_tasks_list repeatedly \u2014 wait for messages.", "After spawning all teammates, tell the user what you've set up and wait.", "When all teammates finish, summarize results and suggest next steps.", "", "MERGE WORKFLOW:", "After a teammate finishes and you shut them down, use team_merge to merge their branch.", "Do NOT tell teammates to commit \u2014 they handle that themselves.", "Do NOT run git merge manually \u2014 use team_merge which squash-merges and unstages for you.", "team_cleanup will safety-net merge any branches you forgot, but prefer explicit team_merge.", "", "Before calling team_cleanup, verify teammates have committed their work.", "team_shutdown will warn you if a teammate has uncommitted changes.", "team_cleanup will block if any worktree has uncommitted changes \u2014 merge or commit first.");
+  lines.push("", "Spawn teammates ONE AT A TIME. Wait for each tool result before spawning the next.", "This avoids git worktree contention. Once all are spawned, wait for their messages.", "Read-only agents (explore, plan) automatically skip worktree creation.", "For other agents that only need to read, pass worktree: false to avoid unnecessary isolation.", "", "Teammates work asynchronously and message you when done.", "Do NOT poll team_status or team_tasks_list repeatedly \u2014 wait for messages.", "After spawning all teammates, tell the user what you've set up and wait.", "When all teammates finish, summarize results and suggest next steps.", "", "MERGE WORKFLOW:", "After a teammate finishes and you shut them down, use team_merge to merge their branch.", "Do NOT tell teammates to commit \u2014 they handle that themselves.", "Do NOT run git merge manually \u2014 use team_merge which squash-merges and unstages for you.", "team_cleanup will safety-net merge any branches you forgot, but prefer explicit team_merge.", "", "Before calling team_cleanup, verify teammates have committed their work.", "team_shutdown will warn you if a teammate has uncommitted changes.", "team_cleanup will block if any worktree has uncommitted changes \u2014 merge or commit first.", 'To permanently delete archived teams, call team_cleanup with purge: ["team-name"] or purge: ["*"] for all archived teams.', "The first purge call is preview-only and deletes nothing.", "Use the question tool to ask the user for visible human approval before deleting archived team records or preserved Ensemble branches.", "The question must include the exact approval and denial option labels shown in the preview.", "Only if the user selects that exact approval option, call team_cleanup again with the same purge value, confirm_purge: true, and the confirm_token from the preview.");
   return lines.join(`
 `);
 }
@@ -16156,9 +17180,9 @@ function loadConfig(projectDir) {
   const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? "";
   const globalPath = path2.join(homeDir, ".config", "opencode", "ensemble.json");
   const projectPath = path2.join(projectDir, ".opencode", "ensemble.json");
-  const global = readConfigFile(globalPath);
+  const global2 = readConfigFile(globalPath);
   const project = readConfigFile(projectPath);
-  const merged = { ...DEFAULT_CONFIG, ...global, ...project };
+  const merged = { ...DEFAULT_CONFIG, ...global2, ...project };
   const timeout = process.env.OPENCODE_ENSEMBLE_TIMEOUT;
   if (timeout !== undefined)
     merged.timeoutMs = timeout === "0" ? 0 : parseInt(timeout, 10) || merged.timeoutMs;
@@ -17017,6 +18041,28 @@ function requireTeamMember(deps, sessionId) {
     throw new Error("This session is not in a team.");
   return teamInfo;
 }
+function requireCanPurgeArchivedTeams(deps, sessionId) {
+  const activeMembers = deps.db.query(`SELECT tm.session_id
+     FROM team_member tm
+     JOIN team t ON tm.team_id = t.id
+     WHERE t.status = 'active'`).all();
+  if (activeMembers.some((member) => member.session_id === sessionId)) {
+    throw new Error("Team members cannot purge archived teams");
+  }
+  const activeLeads = deps.db.query("SELECT lead_session_id FROM team WHERE status = 'active'").all();
+  if (deps.tracker.getParent(sessionId)) {
+    throw new Error("Sub-agents cannot purge archived teams");
+  }
+  if (activeLeads.some((team) => team.lead_session_id === sessionId))
+    return;
+  const activeTeamSessions = new Set([
+    ...activeMembers.map((member) => member.session_id),
+    ...activeLeads.map((team) => team.lead_session_id)
+  ]);
+  if (deps.tracker.isDescendantOf(sessionId, activeTeamSessions)) {
+    throw new Error("Sub-agents cannot purge archived teams");
+  }
+}
 
 // src/tools/team-spawn.ts
 var spawnFailures = new Map;
@@ -17471,7 +18517,340 @@ ${parts.join(`
 
 // src/tools/team-cleanup.ts
 init_merge_helper();
-async function executeTeamCleanup(deps, args, sessionId, isDirty = checkWorktreeDirty, merge2 = mergeBranch, delBranch = deleteBranch, mergeOnCleanup = true, overlapCheck = getOverlappingFiles) {
+async function listPreservedBranches(teamName, cwd) {
+  try {
+    const proc = Bun.spawn(["git", "branch", "--list", `ensemble/preserved/${teamName}/*`, "--format", "%(refname:short)"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const out = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exit = await proc.exited;
+    if (exit !== 0)
+      throw new Error(stderr.trim() || `git branch exited with code ${exit}`);
+    return out.split(`
+`).map((branch) => branch.trim()).filter(Boolean);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("not a git repository"))
+      return [];
+    throw new Error(`Failed to list preserved branches for ${teamName}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function branchExists(branch, cwd) {
+  try {
+    const proc = Bun.spawn(["git", "branch", "--list", branch, "--format", "%(refname:short)"], { cwd, stdout: "pipe", stderr: "pipe" });
+    const out = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exit = await proc.exited;
+    if (exit !== 0) {
+      if (stderr.includes("not a git repository"))
+        return false;
+      throw new Error(stderr.trim() || `git branch exited with code ${exit}`);
+    }
+    return out.split(`
+`).map((item) => item.trim()).includes(branch);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("not a git repository"))
+      return false;
+    throw new Error(`Failed to check stale Ensemble branch ${branch}: ${message}`);
+  }
+}
+function normalizeBranchName(branch) {
+  return branch.trim().replace(/^\*\s*/, "");
+}
+function resolvePurgeTargets(deps, purge) {
+  if (purge.length === 0)
+    throw new Error("Pass at least one archived team name to purge, or ['*'] for all archived teams.");
+  if (purge.includes("*") && purge.length !== 1) {
+    throw new Error("Wildcard purge cannot be combined with explicit team names. Use purge: ['*'] by itself.");
+  }
+  if (purge.includes("*")) {
+    return deps.db.query("SELECT id, name, time_updated FROM team WHERE status = 'archived' ORDER BY time_updated DESC, name ASC").all();
+  }
+  const uniqueNames = [...new Set(purge)];
+  const rows = uniqueNames.map((name) => ({
+    name,
+    team: deps.db.query("SELECT id, name, status, time_updated FROM team WHERE name = ?").get(name)
+  }));
+  const missing = rows.filter((row) => row.team === null).map((row) => row.name);
+  if (missing.length > 0)
+    throw new Error(`Team not found: ${missing.join(", ")}`);
+  const active = rows.filter((row) => row.team?.status === "active").map((row) => row.name);
+  if (active.length > 0)
+    throw new Error(`Cannot purge active team: ${active.join(", ")}`);
+  return rows.map((row) => row.team).sort((a, b) => b.time_updated - a.time_updated || a.name.localeCompare(b.name));
+}
+function deleteArchivedTeams(deps, targets) {
+  const transaction = deps.db.transaction((teams) => {
+    teams.forEach((team) => {
+      const row = deps.db.query("SELECT status FROM team WHERE id = ?").get(team.id);
+      if (!row)
+        throw new Error(`Team not found: ${team.name}`);
+      if (row.status === "active")
+        throw new Error(`Cannot purge active team: ${team.name}`);
+    });
+    validatePurgeResources(deps, teams);
+    teams.forEach((team) => {
+      deps.db.run("DELETE FROM team WHERE id = ? AND status = 'archived'", [team.id]);
+    });
+  });
+  transaction(targets);
+  targets.forEach((team) => {
+    deps.registry.unregisterTeam(team.id);
+    spawnFailures.delete(team.id);
+  });
+}
+function getPurgeMemberResources(deps, targets) {
+  return targets.flatMap((target) => deps.db.query(`SELECT t.name as team_name,
+            tm.team_id,
+            tm.name as member_name,
+            tm.worktree_dir,
+            tm.workspace_id,
+            tm.worktree_branch
+     FROM team_member tm
+     JOIN team t ON tm.team_id = t.id
+     WHERE tm.team_id = ?`).all(target.id));
+}
+function preservedBranchPrefix(resource) {
+  return `ensemble/preserved/${resource.team_name}/`;
+}
+function staleEnsembleBranchNames(resource) {
+  return [
+    `ensemble-${resource.team_name}-${resource.member_name}`,
+    `opencode/ensemble-${resource.team_name}-${resource.member_name}`
+  ];
+}
+function isPreservedBranch(resource) {
+  return resource.worktree_branch !== null && resource.worktree_branch.startsWith(preservedBranchPrefix(resource));
+}
+function isStaleEnsembleBranch(resource) {
+  return resource.worktree_branch !== null && staleEnsembleBranchNames(resource).includes(resource.worktree_branch);
+}
+function validatePurgeResources(deps, targets) {
+  const resources = getPurgeMemberResources(deps, targets);
+  const nonPreserved = resources.filter((resource) => resource.worktree_branch !== null && !isPreservedBranch(resource) && !isStaleEnsembleBranch(resource));
+  if (nonPreserved.length > 0) {
+    const details = nonPreserved.map((resource) => `${resource.team_name}/${resource.member_name} (${resource.worktree_branch})`).join(", ");
+    throw new Error(`Cannot purge archived teams: ${details} has a non-preserved worktree branch or a branch outside its preserved namespace.`);
+  }
+  const activeResourceRefs = resources.flatMap((resource) => {
+    const worktreeRefs = resource.worktree_dir ? deps.db.query(`SELECT t.name as team_name, tm.name as member_name
+         FROM team_member tm
+         JOIN team t ON tm.team_id = t.id
+         WHERE t.status = 'active' AND tm.worktree_dir = ?`).all(resource.worktree_dir) : [];
+    const workspaceRefs = resource.workspace_id ? deps.db.query(`SELECT t.name as team_name, tm.name as member_name
+         FROM team_member tm
+         JOIN team t ON tm.team_id = t.id
+         WHERE t.status = 'active' AND tm.workspace_id = ?`).all(resource.workspace_id) : [];
+    return [
+      ...worktreeRefs.map((ref) => `${resource.team_name}/${resource.member_name} worktree is also referenced by active team ${ref.team_name}/${ref.member_name}`),
+      ...workspaceRefs.map((ref) => `${resource.team_name}/${resource.member_name} workspace is also referenced by active team ${ref.team_name}/${ref.member_name}`)
+    ];
+  });
+  if (activeResourceRefs.length > 0) {
+    throw new Error(`Cannot purge archived teams: ${[...new Set(activeResourceRefs)].join(", ")}.`);
+  }
+}
+function collectStaleEnsembleBranches(deps, targets) {
+  return [...new Set(getPurgeMemberResources(deps, targets).filter(isStaleEnsembleBranch).map((resource) => resource.worktree_branch))];
+}
+function countStaleResourceRefs(deps, target) {
+  return getPurgeMemberResources(deps, [target]).reduce((count, resource) => count + (resource.worktree_dir ? 1 : 0) + (resource.workspace_id ? 1 : 0), 0);
+}
+function countStaleBranchRefs(deps, target) {
+  return collectStaleEnsembleBranches(deps, [target]).length;
+}
+async function existingWorktreeDirs(deps, resources) {
+  if (!resources.some((resource) => resource.worktree_dir))
+    return new Set;
+  try {
+    const result = await deps.client.worktree.list();
+    return new Set((result.data ?? []).map((worktree) => worktree.directory));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot purge archived teams: failed to list worktrees before stale resource cleanup: ${message}`);
+  }
+}
+async function existingWorkspaceIds(deps, resources) {
+  if (!resources.some((resource) => resource.workspace_id))
+    return new Set;
+  try {
+    const result = await deps.client.workspace.list();
+    return new Set((result.data ?? []).map((workspace) => workspace.id));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot purge archived teams: failed to list workspaces before stale resource cleanup: ${message}`);
+  }
+}
+async function cleanupStalePurgeResources(deps, targets, isDirty) {
+  const resources = getPurgeMemberResources(deps, targets).filter((resource) => resource.worktree_dir || resource.workspace_id);
+  if (resources.length === 0)
+    return;
+  const worktreeDirs = await existingWorktreeDirs(deps, resources);
+  const workspaceIds = await existingWorkspaceIds(deps, resources);
+  for (const resource of resources) {
+    if (resource.workspace_id) {
+      if (workspaceIds.has(resource.workspace_id)) {
+        try {
+          await deps.client.workspace.remove({ id: resource.workspace_id });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`Failed to remove stale workspace for ${resource.team_name}/${resource.member_name}: ${message}`);
+        }
+      }
+      deps.db.run("UPDATE team_member SET workspace_id = NULL WHERE team_id = ? AND name = ?", [resource.team_id, resource.member_name]);
+    }
+    if (resource.worktree_dir) {
+      if (worktreeDirs.has(resource.worktree_dir)) {
+        let dirty;
+        try {
+          dirty = await isDirty(resource.worktree_dir);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`Cannot purge archived teams: failed to check archived worktree for uncommitted changes at ${resource.worktree_dir}: ${message}`);
+        }
+        if (dirty) {
+          throw new Error(`Cannot purge archived teams: ${resource.team_name}/${resource.member_name} has uncommitted changes in archived worktree ${resource.worktree_dir}.`);
+        }
+        try {
+          await deps.client.worktree.remove({ worktreeRemoveInput: { directory: resource.worktree_dir } });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`Failed to remove stale worktree for ${resource.team_name}/${resource.member_name}: ${message}`);
+        }
+      }
+      deps.db.run("UPDATE team_member SET worktree_dir = NULL WHERE team_id = ? AND name = ?", [resource.team_id, resource.member_name]);
+    }
+  }
+}
+async function deleteStaleEnsembleBranches(branches, cwd, delBranch, exists) {
+  for (const branch of branches) {
+    if (!await exists(branch, cwd))
+      continue;
+    const ok = await delBranch(branch, cwd);
+    if (!ok)
+      throw new Error(`Failed to delete stale Ensemble branch: ${branch}`);
+  }
+}
+function validatePurgeTargetsStillArchived(deps, targets) {
+  const missing = [];
+  const active = [];
+  targets.forEach((target) => {
+    const row = deps.db.query("SELECT status FROM team WHERE id = ?").get(target.id);
+    if (!row)
+      missing.push(target.name);
+    else if (row.status === "active")
+      active.push(target.name);
+  });
+  if (missing.length > 0)
+    throw new Error(`Team not found: ${missing.join(", ")}`);
+  if (active.length > 0)
+    throw new Error(`Cannot purge active team: ${active.join(", ")}`);
+}
+async function collectPreservedBranches(targets, cwd, listBranches) {
+  const entries = await Promise.all(targets.map(async (target) => {
+    const prefix = `ensemble/preserved/${target.name}/`;
+    let listed;
+    try {
+      listed = await listBranches(target.name, cwd);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (message.includes("not a git repository"))
+        listed = [];
+      else
+        throw new Error(`Failed to list preserved branches for ${target.name}: ${message}`);
+    }
+    const branches = listed.map(normalizeBranchName).filter((branch) => branch.startsWith(prefix));
+    return [target.id, [...new Set(branches)]];
+  }));
+  return new Map(entries);
+}
+async function deletePreservedBranches(branchesByTeam, cwd, delBranch) {
+  const branches = [...branchesByTeam.values()].flat();
+  for (const branch of branches) {
+    const ok = await delBranch(branch, cwd);
+    if (!ok)
+      throw new Error(`Failed to delete preserved branch: ${branch}`);
+  }
+}
+function formatCount(count, noun, plural = `${noun}s`) {
+  return `${count} ${count === 1 ? noun : plural}`;
+}
+function buildPurgePreview(deps, targets, branchesByTeam) {
+  const rows = targets.map((target) => {
+    const members = deps.db.query("SELECT COUNT(*) as c FROM team_member WHERE team_id = ?").get(target.id).c;
+    const tasks = deps.db.query("SELECT COUNT(*) as c FROM team_task WHERE team_id = ?").get(target.id).c;
+    const messages = deps.db.query("SELECT COUNT(*) as c FROM team_message WHERE team_id = ?").get(target.id).c;
+    const branches = branchesByTeam.get(target.id)?.length ?? 0;
+    const staleResources = countStaleResourceRefs(deps, target);
+    const staleBranches = countStaleBranchRefs(deps, target);
+    return { ...target, members, tasks, messages, branches, staleResources, staleBranches };
+  });
+  const totals = rows.reduce((acc, row) => ({
+    members: acc.members + row.members,
+    tasks: acc.tasks + row.tasks,
+    messages: acc.messages + row.messages,
+    branches: acc.branches + row.branches,
+    staleResources: acc.staleResources + row.staleResources,
+    staleBranches: acc.staleBranches + row.staleBranches
+  }), { members: 0, tasks: 0, messages: 0, branches: 0, staleResources: 0, staleBranches: 0 });
+  const details = rows.slice(0, 10).map((row) => `- ${row.name}: ${formatCount(row.members, "member")}, ${formatCount(row.tasks, "task")}, ${formatCount(row.messages, "message")}, ${formatCount(row.branches, "preserved branch", "preserved branches")}, ${formatCount(row.staleResources, "stale resource")}, ${formatCount(row.staleBranches, "stale branch", "stale branches")}`);
+  const hidden = rows.length > 10 ? [`...and ${rows.length - 10} more archived team${rows.length - 10 === 1 ? "" : "s"}`] : [];
+  return [
+    "Permanently delete archived teams?",
+    "This will delete archived team records and cascade-delete their members, tasks, and messages.",
+    "",
+    ...details,
+    ...hidden,
+    "",
+    `Total: ${formatCount(rows.length, "team")}, ${formatCount(totals.members, "member")}, ${formatCount(totals.tasks, "task")}, ${formatCount(totals.messages, "message")}, ${formatCount(totals.branches, "preserved branch", "preserved branches")}, ${formatCount(totals.staleResources, "stale resource")}, ${formatCount(totals.staleBranches, "stale branch", "stale branches")}`
+  ].join(`
+`);
+}
+function buildPurgeConfirmationInstructions(preview, confirmToken) {
+  const approvalLabel = `Approve purge ${confirmToken.slice(0, 8)}`;
+  const denialLabel = `Deny purge ${confirmToken.slice(0, 8)}`;
+  return [
+    "Purge preview only \u2014 no teams were deleted.",
+    "",
+    preview,
+    "",
+    "Use the question tool to ask the user whether to permanently delete these archived teams.",
+    `The approval option label must be exactly: ${approvalLabel}`,
+    `The denial option label must be exactly: ${denialLabel}`,
+    `Confirmation token: ${confirmToken}`,
+    `Only if the user selects "${approvalLabel}", call team_cleanup again with the same purge value, confirm_purge: true, and confirm_token set to this token.`
+  ].join(`
+`);
+}
+async function executeTeamCleanup(deps, args, sessionId, isDirty = checkWorktreeDirty, merge2 = mergeBranch, delBranch = deleteBranch, mergeOnCleanup = true, overlapCheck = getOverlappingFiles, _approvePurge, _listBranches, _branchExists) {
+  if (args.purge && args.purge.length > 0) {
+    requireCanPurgeArchivedTeams(deps, sessionId);
+    const targets = resolvePurgeTargets(deps, args.purge);
+    if (targets.length === 0)
+      return "No archived teams to purge.";
+    validatePurgeTargetsStillArchived(deps, targets);
+    validatePurgeResources(deps, targets);
+    const branchesByTeam = await collectPreservedBranches(targets, deps.directory, _listBranches ?? listPreservedBranches);
+    const preview = buildPurgePreview(deps, targets, branchesByTeam);
+    if (!args.confirm_purge) {
+      const confirmToken = deps.purgeApprovals.create(sessionId, targets.map((target) => target.id));
+      return buildPurgeConfirmationInstructions(preview, confirmToken);
+    }
+    if (!args.confirm_token) {
+      throw new Error("A purge confirmation token is required. First call team_cleanup without confirm_purge, then use the question tool before confirming.");
+    }
+    deps.purgeApprovals.consume(sessionId, args.confirm_token, targets.map((target) => target.id));
+    validatePurgeTargetsStillArchived(deps, targets);
+    validatePurgeResources(deps, targets);
+    await cleanupStalePurgeResources(deps, targets, isDirty);
+    validatePurgeResources(deps, targets);
+    await deleteStaleEnsembleBranches(collectStaleEnsembleBranches(deps, targets), deps.directory, delBranch, _branchExists ?? branchExists);
+    const finalBranchesByTeam = await collectPreservedBranches(targets, deps.directory, _listBranches ?? listPreservedBranches);
+    await deletePreservedBranches(finalBranchesByTeam, deps.directory, delBranch);
+    deleteArchivedTeams(deps, targets);
+    const noun = targets.length === 1 ? "archived team" : "archived teams";
+    return `Permanently deleted ${targets.length} ${noun}: ${targets.map((target) => target.name).join(", ")}.`;
+  }
   const teamInfo = requireLead(deps, sessionId);
   const members = deps.db.query("SELECT name, session_id, status, worktree_dir, worktree_branch, workspace_id FROM team_member WHERE team_id = ?").all(teamInfo.teamId);
   const active = members.filter((m) => m.status !== "shutdown" && m.status !== "shutdown_requested" && m.status !== "error");
@@ -18071,6 +19450,7 @@ var plugin = async (input) => {
   const config2 = loadConfig(input.directory);
   const registry2 = new MemberRegistry;
   const tracker = new DescendantTracker;
+  const purgeApprovals = new PendingPurgeApprovals;
   const nudgedMembers = new Set;
   const progressTracker = new ProgressTracker;
   const wakeLeadTimestamps = new Map;
@@ -18079,7 +19459,7 @@ var plugin = async (input) => {
   const rawClient = new OpencodeClient({ client: pluginTransport });
   initLog(rawClient);
   const client3 = wrapThrowingClient(rawClient);
-  const deps = { db, registry: registry2, tracker, client: client3, directory: input.directory, config: config2 };
+  const deps = { db, registry: registry2, tracker, purgeApprovals, client: client3, directory: input.directory, config: config2 };
   if (!isWorktreeInstance(input.directory)) {
     log("init:recovery:start (main instance)");
     const recovery = await recoverStaleMembers(db, client3, input.directory);
@@ -18262,6 +19642,11 @@ var plugin = async (input) => {
         }
       }
     },
+    "tool.execute.after": async (input2, output) => {
+      if (input2.tool === "question") {
+        purgeApprovals.recordQuestionAnswer(input2.sessionID, output.output, input2.args);
+      }
+    },
     "experimental.chat.system.transform": async (input2, output) => {
       if (!input2.sessionID)
         return;
@@ -18434,15 +19819,30 @@ var plugin = async (input) => {
         }
       }),
       team_cleanup: tool({
-        description: "Clean up the team. All teammates must be shut down first. Removes team data and frees resources.",
+        description: "Clean up the current team, or purge archived teams after human approval. Omit purge for normal cleanup. Pass purge with archived team names, or ['*'] for all archived teams. First purge call returns a preview, exact approval and denial options, and confirmation token only. Archived worktree/workspace references and stale Ensemble-owned branches are shown in the preview and cleaned during confirmed purge. Use the question tool with those exact options, then call again with confirm_purge: true and confirm_token only if the user selected the exact approval option.",
         args: {
           force: tool.schema.boolean().default(false).describe("Force cleanup even if members are active (will abort them)"),
-          acknowledge_uncommitted: tool.schema.boolean().default(false)
+          acknowledge_uncommitted: tool.schema.boolean().default(false),
+          purge: tool.schema.array(tool.schema.string()).optional().describe("Archived team names to permanently delete, or ['*'] for all archived teams. Requires human approval."),
+          confirm_purge: tool.schema.boolean().default(false).describe("Set true only after the user explicitly selects the exact approval option from the purge preview via the question tool."),
+          confirm_token: tool.schema.string().optional().describe("Confirmation token from the purge preview. Valid only after the matching exact approval answer is selected in this session.")
         },
         async execute(args, ctx) {
-          const result = await executeTeamCleanup(deps, args, ctx.sessionID, undefined, undefined, undefined, config2.mergeOnCleanup);
+          const approvePurge = args.purge && args.purge.length > 0 && args.confirm_purge ? async (preview) => {
+            await ctx.ask({
+              permission: "team_cleanup.purge",
+              patterns: args.purge ?? [],
+              always: [],
+              metadata: {
+                title: "Purge archived teams",
+                preview
+              }
+            });
+          } : undefined;
+          const result = await executeTeamCleanup(deps, args, ctx.sessionID, undefined, undefined, undefined, config2.mergeOnCleanup, undefined, approvePurge);
           const blocked = result.includes("uncommitted");
-          ctx.metadata({ title: blocked ? "Cleanup blocked \u2014 uncommitted changes" : "Team cleaned up" });
+          const title = args.purge ? result.startsWith("No archived teams") ? "No archived teams to purge" : result.startsWith("Purge preview") ? "Purge confirmation required" : "Archived teams purged" : blocked ? "Cleanup blocked \u2014 uncommitted changes" : "Team cleaned up";
+          ctx.metadata({ title });
           return result;
         }
       }),