@hueyexe/opencode-ensemble 0.14.2 → 0.15.1

package/dist/index.js

@@ -1,18 +1,488 @@
+import { createRequire } from "node:module";
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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) {
@@ -26,11 +496,11 @@ function log(msg) {
 var _client = null;
 
 // src/process.ts
-import { Buffer } from "node:buffer";
+import { Buffer as Buffer2 } from "node:buffer";
 import { spawn } from "node:child_process";
 function collect(stream, chunks) {
   stream?.on("data", (chunk) => {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    chunks.push(Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk));
   });
 }
 function runCommand(args, options = {}) {
@@ -54,13 +524,13 @@ function runCommand(args, options = {}) {
     collect(child.stdout, stdout);
     collect(child.stderr, stderr);
     child.on("error", (error45) => {
-      finish({ exitCode: 1, stdout: Buffer.concat(stdout).toString("utf8"), stderr: error45.message });
+      finish({ exitCode: 1, stdout: Buffer2.concat(stdout).toString("utf8"), stderr: error45.message });
     });
     child.on("close", (code) => {
       finish({
         exitCode: code ?? 1,
-        stdout: Buffer.concat(stdout).toString("utf8"),
-        stderr: Buffer.concat(stderr).toString("utf8")
+        stdout: Buffer2.concat(stdout).toString("utf8"),
+        stderr: Buffer2.concat(stderr).toString("utf8")
       });
     });
   });
@@ -70,14 +540,43 @@ var init_process = () => {};
 // src/tools/merge-helper.ts
 var exports_merge_helper = {};
 __export(exports_merge_helper, {
+  teamWorktreeName: () => teamWorktreeName,
+  teamResourceSlug: () => teamResourceSlug,
+  teamResourceSegment: () => teamResourceSegment,
   preservedBranchName: () => preservedBranchName,
   preserveBranch: () => preserveBranch,
   mergeBranchRaw: () => mergeBranchRaw,
   mergeBranch: () => mergeBranch,
   gitReset: () => gitReset,
+  getTeamResourceParts: () => getTeamResourceParts,
   getOverlappingFiles: () => getOverlappingFiles,
   deleteBranch: () => deleteBranch
 });
+function shortTeamId(teamId) {
+  return (teamId.split("_").at(-1) || teamId).slice(0, 6);
+}
+function resourcePart(value) {
+  const part = value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  return part || "unnamed";
+}
+function getTeamResourceParts(db, teamId) {
+  const row = db.query(`SELECT t.id as team_id, t.name as team_name, p.name as project_name
+     FROM team t
+     JOIN project p ON t.project_id = p.id
+     WHERE t.id = ?`).get(teamId);
+  if (!row)
+    throw new Error(`Team not found: ${teamId}`);
+  return { projectName: row.project_name, teamName: row.team_name, teamId: row.team_id };
+}
+function teamResourceSlug(projectName, teamName, teamId) {
+  return `${resourcePart(projectName)}-${resourcePart(teamName)}#${shortTeamId(teamId)}`;
+}
+function teamResourceSegment(teamName, teamId) {
+  return `${resourcePart(teamName)}#${shortTeamId(teamId)}`;
+}
+function teamWorktreeName(projectName, teamName, teamId, memberName) {
+  return `ensemble-${teamResourceSlug(projectName, teamName, teamId)}-${memberName}`;
+}
 async function preserveBranch(sourceBranch, targetBranch, cwd) {
   const result = await runCommand(["git", "branch", targetBranch, sourceBranch], { cwd });
   if (result.exitCode !== 0) {
@@ -128,8 +627,8 @@ async function getOverlappingFiles(branch, cwd) {
   const localFiles = [...new Set([...localChanged, ...localUntracked])];
   return localFiles.filter((f) => agentFiles.has(f));
 }
-function preservedBranchName(teamName, memberName) {
-  return `ensemble/preserved/${teamName}/${memberName}`;
+function preservedBranchName(projectName, teamName, teamId, memberName) {
+  return `ensemble/preserved/${resourcePart(projectName)}/${teamResourceSegment(teamName, teamId)}/${resourcePart(memberName)}`;
 }
 var init_merge_helper = __esm(() => {
   init_process();
@@ -13321,6 +13820,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({
@@ -13381,39 +13968,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: [
@@ -13423,27 +13997,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: [
@@ -13452,40 +14032,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: [
@@ -13495,27 +14066,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: {
@@ -13525,81 +14093,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: [
@@ -13609,23 +14166,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: {
@@ -13635,7 +14195,7 @@ class Config2 extends HeyApiClient {
       }
     });
   }
-  providers(parameters, options) {
+  syncList(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
@@ -13644,16 +14204,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: [
@@ -13663,61 +14220,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: {
@@ -13727,50 +14264,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: [
@@ -13780,28 +14317,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], [
@@ -13883,326 +14405,338 @@ 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" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "path" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}",
+    return (options?.client ?? this.client).get({
+      url: "/file",
       ...options,
       ...params
     });
   }
-  get(parameters, options) {
+  read(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/content",
       ...options,
       ...params
     });
   }
-  update(parameters, options) {
+  status(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" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).patch({
-      url: "/session/{sessionID}",
+    return (options?.client ?? this.client).get({
+      url: "/file/status",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
+      ...params
+    });
+  }
+}
+
+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
     });
   }
-  children(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" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/children",
+      url: "/path",
       ...options,
       ...params
     });
   }
-  todo(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).get({
-      url: "/session/{sessionID}/todo",
+      url: "/vcs/diff/raw",
       ...options,
       ...params
     });
   }
-  init(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" },
-          { 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",
+    return (options?.client ?? this.client).get({
+      url: "/vcs",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
+      ...params
+    });
+  }
+  status(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
       }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/vcs/status",
+      ...options,
+      ...params
     });
   }
-  fork(parameters, options) {
+  diff(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: "mode" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/fork",
+    return (options?.client ?? this.client).get({
+      url: "/vcs/diff",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  abort(parameters, options) {
+  apply(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "body", key: "patch" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/abort",
+      url: "/vcs/apply",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-  unshare(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" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/session/{sessionID}/share",
+    return (options?.client ?? this.client).get({
+      url: "/command",
       ...options,
       ...params
     });
   }
-  share(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" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/share",
+    return (options?.client ?? this.client).get({
+      url: "/lsp",
       ...options,
       ...params
     });
   }
-  diff(parameters, options) {
+}
+
+class Formatter extends HeyApiClient {
+  status(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" },
-          { in: "query", key: "messageID" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/diff",
+      url: "/formatter",
       ...options,
       ...params
     });
   }
-  summarize(parameters, options) {
+}
+
+class Auth2 extends HeyApiClient {
+  remove(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: "providerID" },
-          { in: "body", key: "modelID" },
-          { in: "body", key: "auto" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/summarize",
+    return (options?.client ?? this.client).delete({
+      url: "/mcp/{name}/auth",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  messages(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: "query", key: "limit" },
-          { in: "query", key: "before" }
+          { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/session/{sessionID}/message",
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/auth",
       ...options,
       ...params
     });
   }
-  prompt(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: "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: "body", key: "code" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/message",
+      url: "/mcp/{name}/auth/callback",
       ...options,
       ...params,
       headers: {
@@ -14212,61 +14746,53 @@ class Session2 extends HeyApiClient {
       }
     });
   }
-  deleteMessage(parameters, options) {
+  authenticate(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).delete({
-      url: "/session/{sessionID}/message/{messageID}",
+    return (options?.client ?? this.client).post({
+      url: "/mcp/{name}/auth/authenticate",
       ...options,
       ...params
     });
   }
-  message(parameters, options) {
+}
+
+class Mcp 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).get({
-      url: "/session/{sessionID}/message/{messageID}",
+      url: "/mcp",
       ...options,
       ...params
     });
   }
-  promptAsync(parameters, options) {
+  add(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: "body", key: "name" },
+          { in: "body", key: "config" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/prompt_async",
+      url: "/mcp",
       ...options,
       ...params,
       headers: {
@@ -14276,114 +14802,86 @@ class Session2 extends HeyApiClient {
       }
     });
   }
-  command(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" },
-          { 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: "query", key: "workspace" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/session/{sessionID}/command",
+      url: "/mcp/{name}/connect",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  shell(parameters, options) {
+  disconnect(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}/disconnect",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  revert(parameters, options) {
+  _auth;
+  get auth() {
+    return this._auth ??= new Auth2({ client: this.client });
+  }
+}
+
+class Project extends HeyApiClient {
+  list(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).post({
-      url: "/session/{sessionID}/revert",
+    return (options?.client ?? this.client).get({
+      url: "/project",
       ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
+      ...params
     });
   }
-  unrevert(parameters, options) {
+  current(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",
+    return (options?.client ?? this.client).get({
+      url: "/project/current",
       ...options,
       ...params
     });
   }
-}
-
-class Part extends HeyApiClient {
-  delete(parameters, options) {
+  initGit(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).post({
+      url: "/project/git/init",
       ...options,
       ...params
     });
@@ -14392,17 +14890,17 @@ class Part extends HeyApiClient {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "sessionID" },
-          { in: "path", key: "messageID" },
-          { in: "path", key: "partID" },
+          { in: "path", key: "projectID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { key: "part", map: "body" }
+          { in: "body", key: "name" },
+          { in: "body", key: "icon" },
+          { in: "body", key: "commands" }
         ]
       }
     ]);
     return (options?.client ?? this.client).patch({
-      url: "/session/{sessionID}/message/{messageID}/part/{partID}",
+      url: "/project/{projectID}",
       ...options,
       ...params,
       headers: {
@@ -14414,21 +14912,53 @@ class Part extends HeyApiClient {
   }
 }
 
-class Permission extends HeyApiClient {
-  respond(parameters, options) {
+class Pty extends HeyApiClient {
+  shells(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/pty/shells",
+      ...options,
+      ...params
+    });
+  }
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/pty",
+      ...options,
+      ...params
+    });
+  }
+  create(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: "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: "/session/{sessionID}/permissions/{permissionID}",
+      url: "/pty",
       ...options,
       ...params,
       headers: {
@@ -14438,20 +14968,52 @@ class Permission extends HeyApiClient {
       }
     });
   }
-  reply(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).delete({
+      url: "/pty/{ptyID}",
+      ...options,
+      ...params
+    });
+  }
+  get(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}",
+      ...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: "reply" },
-          { in: "body", key: "message" }
+          { in: "body", key: "title" },
+          { in: "body", key: "size" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/permission/{requestID}/reply",
+    return (options?.client ?? this.client).put({
+      url: "/pty/{ptyID}",
       ...options,
       ...params,
       headers: {
@@ -14461,17 +15023,34 @@ class Permission 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).post({
+      url: "/pty/{ptyID}/connect-token",
+      ...options,
+      ...params
+    });
+  }
+  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: "/permission",
+      url: "/pty/{ptyID}/connect",
       ...options,
       ...params
     });
@@ -14534,6 +15113,70 @@ class Question extends HeyApiClient {
   }
 }
 
+class Permission 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: "/permission",
+      ...options,
+      ...params
+    });
+  }
+  reply(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "requestID" },
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "body", key: "reply" },
+          { in: "body", key: "message" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/permission/{requestID}/reply",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  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: "body", key: "response" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/session/{sessionID}/permissions/{permissionID}",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+}
+
 class Oauth extends HeyApiClient {
   authorize(parameters, options) {
     const params = buildClientParams([parameters], [
@@ -14620,174 +15263,213 @@ class Provider extends HeyApiClient {
   }
 }
 
-class Find extends HeyApiClient {
-  text(parameters, options) {
+class Session2 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: "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: "/find",
+      url: "/session",
       ...options,
       ...params
     });
   }
-  files(parameters, options) {
+  create(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
           { 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: "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: "/find/file",
+      url: "/session/status",
       ...options,
       ...params
     });
   }
-  symbols(parameters, options) {
+  delete(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "sessionID" },
           { 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).delete({
+      url: "/session/{sessionID}",
       ...options,
       ...params
     });
   }
-}
-
-class File2 extends HeyApiClient {
-  list(parameters, options) {
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "sessionID" },
           { 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: "/session/{sessionID}",
       ...options,
       ...params
     });
   }
-  read(parameters, options) {
+  update(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "query", key: "path" }
+          { in: "body", key: "title" },
+          { in: "body", key: "permission" },
+          { in: "body", key: "time" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).get({
-      url: "/file/content",
+    return (options?.client ?? this.client).patch({
+      url: "/session/{sessionID}",
       ...options,
-      ...params
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
     });
   }
-  status(parameters, options) {
+  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: "/file/status",
+      url: "/session/{sessionID}/children",
       ...options,
       ...params
     });
   }
-}
-
-class Event extends HeyApiClient {
-  subscribe(parameters, options) {
+  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).sse.get({
-      url: "/event",
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/todo",
       ...options,
       ...params
     });
   }
-}
-
-class Auth2 extends HeyApiClient {
-  remove(parameters, options) {
+  diff(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "messageID" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).delete({
-      url: "/mcp/{name}/auth",
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/diff",
       ...options,
       ...params
     });
   }
-  start(parameters, options) {
+  messages(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "query", key: "workspace" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "before" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/auth",
+    return (options?.client ?? this.client).get({
+      url: "/session/{sessionID}/message",
       ...options,
       ...params
     });
   }
-  callback(parameters, options) {
+  prompt(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" },
-          { in: "body", key: "code" }
+          { 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: "/mcp/{name}/auth/callback",
+      url: "/session/{sessionID}/message",
       ...options,
       ...params,
       headers: {
@@ -14797,53 +15479,53 @@ class Auth2 extends HeyApiClient {
       }
     });
   }
-  authenticate(parameters, options) {
+  deleteMessage(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
+          { in: "path", key: "sessionID" },
+          { in: "path", key: "messageID" },
           { in: "query", key: "directory" },
           { in: "query", key: "workspace" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/auth/authenticate",
+    return (options?.client ?? this.client).delete({
+      url: "/session/{sessionID}/message/{messageID}",
       ...options,
       ...params
     });
   }
-}
-
-class Mcp extends HeyApiClient {
-  status(parameters, options) {
+  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: "/mcp",
+      url: "/session/{sessionID}/message/{messageID}",
       ...options,
       ...params
     });
   }
-  add(parameters, options) {
+  fork(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: "messageID" }
         ]
       }
     ]);
     return (options?.client ?? this.client).post({
-      url: "/mcp",
+      url: "/session/{sessionID}/fork",
       ...options,
       ...params,
       headers: {
@@ -14853,41 +15535,532 @@ class Mcp extends HeyApiClient {
       }
     });
   }
-  connect(parameters, options) {
+  abort(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: "/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: "query", key: "directory" },
+          { in: "query", key: "workspace" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/sync/start",
+      ...options,
+      ...params
+    });
+  }
+  replay(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          {
+            in: "query",
+            key: "query_directory",
+            map: "directory"
+          },
+          { in: "query", key: "workspace" },
+          {
+            in: "body",
+            key: "body_directory",
+            map: "directory"
+          },
+          { in: "body", key: "events" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/sync/replay",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  steal(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: "/sync/steal",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  _history;
+  get history() {
+    return this._history ??= new History({ client: this.client });
+  }
+}
+
+class Session3 extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "query", key: "directory" },
+          { in: "query", key: "workspace" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "order" },
+          { in: "query", key: "path" },
+          { in: "query", key: "roots" },
+          { in: "query", key: "start" },
+          { in: "query", key: "search" },
+          { in: "query", key: "cursor" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/api/session",
+      ...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: "prompt" },
+          { in: "body", key: "delivery" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/api/session/{sessionID}/prompt",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  compact(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: "/api/session/{sessionID}/compact",
+      ...options,
+      ...params
+    });
+  }
+  wait(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: "/api/session/{sessionID}/wait",
+      ...options,
+      ...params
+    });
+  }
+  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" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "order" },
+          { in: "query", key: "cursor" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/api/session/{sessionID}/message",
+      ...options,
+      ...params
+    });
+  }
+}
+
+class Model extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/api/model",
       ...options,
       ...params
     });
   }
-  disconnect(parameters, options) {
+}
+
+class Provider2 extends HeyApiClient {
+  list(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/api/provider",
+      ...options,
+      ...params
+    });
+  }
+  get(parameters, options) {
     const params = buildClientParams([parameters], [
       {
         args: [
-          { in: "path", key: "name" },
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
+          { in: "path", key: "providerID" },
+          { in: "query", key: "location" }
         ]
       }
     ]);
-    return (options?.client ?? this.client).post({
-      url: "/mcp/{name}/disconnect",
+    return (options?.client ?? this.client).get({
+      url: "/api/provider/{providerID}",
       ...options,
       ...params
     });
   }
-  _auth;
-  get auth() {
-    return this._auth ??= new Auth2({ client: this.client });
+}
+
+class V2 extends HeyApiClient {
+  _session;
+  get session() {
+    return this._session ??= new Session3({ client: this.client });
+  }
+  _model;
+  get model() {
+    return this._model ??= new Model({ client: this.client });
+  }
+  _provider;
+  get provider() {
+    return this._provider ??= new Provider2({ client: this.client });
   }
 }
 
@@ -15135,248 +16308,51 @@ class Tui extends HeyApiClient {
   }
 }
 
-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) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/lsp",
-      ...options,
-      ...params
-    });
-  }
-}
-
-class Formatter extends HeyApiClient {
-  status(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "query", key: "directory" },
-          { in: "query", key: "workspace" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).get({
-      url: "/formatter",
-      ...options,
-      ...params
-    });
-  }
-}
-
 class OpencodeClient extends HeyApiClient {
   static __registry = new HeyApiRegistry;
   constructor(args) {
     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 });
   }
   _file;
-  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 });
+  get file() {
+    return this._file ??= new File2({ client: this.client });
   }
   _instance;
   get instance() {
@@ -15394,10 +16370,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 });
@@ -15406,13 +16378,59 @@ 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 "node:path";
 import { mkdirSync } from "node:fs";
 
 // src/db.ts
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import path from "node:path";
 
 // src/schema.ts
@@ -15489,26 +16507,142 @@ var MIGRATIONS = [
      CHECK(plan_approval IN ('none', 'pending', 'approved', 'rejected'));`,
   `ALTER TABLE team ADD COLUMN lead_agent TEXT;`,
   `ALTER TABLE team_member ADD COLUMN workspace_id TEXT;`,
-  `ALTER TABLE team_member ADD COLUMN reported_to_lead INTEGER NOT NULL DEFAULT 0;`
+  `ALTER TABLE team_member ADD COLUMN reported_to_lead INTEGER NOT NULL DEFAULT 0;`,
+  `PRAGMA foreign_keys=OFF;
+   ALTER TABLE team RENAME TO team_old_m8;
+   CREATE TABLE IF NOT EXISTS project (
+     id              TEXT PRIMARY KEY,
+     name            TEXT NOT NULL,
+     path            TEXT NOT NULL,
+     status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived')),
+     time_created    INTEGER NOT NULL,
+     time_updated    INTEGER NOT NULL
+   );
+   INSERT OR IGNORE INTO project (id, name, path, status, time_created, time_updated)
+     VALUES ('default', 'Default Project', '', 'active', strftime('%s','now') * 1000, strftime('%s','now') * 1000);
+   CREATE TABLE team (
+     id              TEXT PRIMARY KEY,
+     name            TEXT NOT NULL,
+     project_id      TEXT NOT NULL DEFAULT 'default' REFERENCES project(id) ON DELETE CASCADE,
+     lead_session_id TEXT NOT NULL,
+     status          TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'archived')),
+     delegate        INTEGER NOT NULL DEFAULT 0,
+     time_created    INTEGER NOT NULL,
+     time_updated    INTEGER NOT NULL,
+     lead_agent      TEXT
+   );
+   INSERT INTO team (id, name, project_id, lead_session_id, status, delegate, time_created, time_updated, lead_agent)
+     SELECT id, name, 'default', lead_session_id, status, delegate, time_created, time_updated, lead_agent FROM team_old_m8;
+   DROP TABLE team_old_m8;
+
+   ALTER TABLE team_member RENAME TO team_member_old_m8;
+   CREATE TABLE team_member (
+     team_id          TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     name             TEXT NOT NULL,
+     session_id       TEXT NOT NULL,
+     agent            TEXT NOT NULL,
+     status           TEXT NOT NULL DEFAULT 'ready'
+                        CHECK(status IN ('ready', 'busy', 'shutdown_requested', 'shutdown', 'error')),
+     execution_status TEXT NOT NULL DEFAULT 'idle'
+                        CHECK(execution_status IN ('idle', 'starting', 'running',
+                          'cancel_requested', 'cancelling', 'cancelled',
+                          'completing', 'completed', 'failed', 'timed_out')),
+     model            TEXT,
+     prompt           TEXT,
+     time_created     INTEGER NOT NULL,
+     time_updated     INTEGER NOT NULL,
+     worktree_dir     TEXT,
+     worktree_branch  TEXT,
+     plan_approval    TEXT NOT NULL DEFAULT 'none'
+                        CHECK(plan_approval IN ('none', 'pending', 'approved', 'rejected')),
+     workspace_id     TEXT,
+     reported_to_lead INTEGER NOT NULL DEFAULT 0,
+     PRIMARY KEY (team_id, name)
+   );
+   INSERT INTO team_member (team_id, name, session_id, agent, status, execution_status, model, prompt, time_created, time_updated, worktree_dir, worktree_branch, plan_approval, workspace_id, reported_to_lead)
+     SELECT team_id, name, session_id, agent, status, execution_status, model, prompt, time_created, time_updated, worktree_dir, worktree_branch, plan_approval, workspace_id, reported_to_lead FROM team_member_old_m8;
+   DROP TABLE team_member_old_m8;
+
+   ALTER TABLE team_task RENAME TO team_task_old_m8;
+   CREATE TABLE team_task (
+     id            TEXT PRIMARY KEY,
+     team_id       TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     content       TEXT NOT NULL,
+     status        TEXT NOT NULL DEFAULT 'pending'
+                     CHECK(status IN ('pending', 'in_progress', 'completed', 'cancelled', 'blocked')),
+     priority      TEXT NOT NULL DEFAULT 'medium'
+                     CHECK(priority IN ('high', 'medium', 'low')),
+     assignee      TEXT,
+     depends_on    TEXT,
+     time_created  INTEGER NOT NULL,
+     time_updated  INTEGER NOT NULL
+   );
+   INSERT INTO team_task (id, team_id, content, status, priority, assignee, depends_on, time_created, time_updated)
+     SELECT id, team_id, content, status, priority, assignee, depends_on, time_created, time_updated FROM team_task_old_m8;
+   DROP TABLE team_task_old_m8;
+
+   ALTER TABLE team_message RENAME TO team_message_old_m8;
+   CREATE TABLE team_message (
+     id            TEXT PRIMARY KEY,
+     team_id       TEXT NOT NULL REFERENCES team(id) ON DELETE CASCADE,
+     from_name     TEXT NOT NULL,
+     to_name       TEXT,
+     content       TEXT NOT NULL,
+     delivered     INTEGER NOT NULL DEFAULT 0,
+     time_created  INTEGER NOT NULL,
+     read          INTEGER NOT NULL DEFAULT 0
+   );
+   INSERT INTO team_message (id, team_id, from_name, to_name, content, delivered, time_created, read)
+     SELECT id, team_id, from_name, to_name, content, delivered, time_created, read FROM team_message_old_m8;
+   DROP TABLE team_message_old_m8;
+
+   CREATE INDEX IF NOT EXISTS team_lead_idx ON team(lead_session_id);
+   CREATE INDEX IF NOT EXISTS team_status_idx ON team(status);
+   CREATE INDEX IF NOT EXISTS team_project_idx ON team(project_id, status);
+   CREATE UNIQUE INDEX IF NOT EXISTS team_active_project_name_idx ON team(project_id, name) WHERE status = 'active';
+   CREATE INDEX IF NOT EXISTS team_member_session_idx ON team_member(session_id);
+   CREATE INDEX IF NOT EXISTS team_member_status_idx ON team_member(team_id, status);
+   CREATE INDEX IF NOT EXISTS team_task_team_idx ON team_task(team_id);
+   CREATE INDEX IF NOT EXISTS team_task_assignee_idx ON team_task(assignee);
+   CREATE INDEX IF NOT EXISTS team_task_status_idx ON team_task(team_id, status);
+   CREATE INDEX IF NOT EXISTS team_message_team_idx ON team_message(team_id);
+   CREATE INDEX IF NOT EXISTS team_message_to_idx ON team_message(to_name);
+   CREATE INDEX IF NOT EXISTS team_message_undelivered_idx ON team_message(team_id, delivered) WHERE delivered = 0;
+   CREATE INDEX IF NOT EXISTS team_message_unread_idx ON team_message(team_id, read) WHERE read = 0;
+   PRAGMA foreign_keys=ON;`
 ];
 function applyMigrations(db) {
   const { user_version: current } = db.query("PRAGMA user_version").get();
+  if (current > MIGRATIONS.length) {
+    throw new Error(`Database schema version ${current} is newer than this plugin supports (${MIGRATIONS.length}). Upgrade opencode-ensemble before continuing.`);
+  }
   for (let i = current;i < MIGRATIONS.length; i++) {
     const migration = MIGRATIONS[i];
-    if (migration)
-      db.exec(migration);
-    db.exec(`PRAGMA user_version = ${i + 1}`);
+    const { foreign_keys: foreignKeys } = db.query("PRAGMA foreign_keys").get();
+    db.exec("PRAGMA foreign_keys = OFF");
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      if (migration)
+        db.exec(migration);
+      db.exec(`PRAGMA user_version = ${i + 1}`);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    } finally {
+      db.exec(`PRAGMA foreign_keys = ${foreignKeys ? "ON" : "OFF"}`);
+    }
   }
 }
 
 // src/db.ts
-var requireRuntimeModule = createRequire(import.meta.url);
+var requireRuntimeModule = createRequire2(import.meta.url);
 var instance;
 
 class NodeSqliteAdapter {
   db;
   constructor(filename) {
-    const sqlite = requireRuntimeModule("node:sqlite");
+    const sqlite = requireRuntimeModule(["node", "sqlite"].join(":"));
     this.db = new sqlite.DatabaseSync(filename);
   }
   exec(sql) {
@@ -15616,6 +16750,20 @@ function validateTeamName(name) {
     return "Team name must be lowercase alphanumeric with hyphens only";
   return;
 }
+var PROJECT_ADJECTIVES = ["amber", "brave", "calm", "copper", "crisp", "dark", "ember", "frost", "quiet", "silver", "steady", "swift"];
+var PROJECT_NOUNS = ["atlas", "beacon", "comet", "harbor", "lab", "orbit", "river", "signal", "sparrow", "summit", "vector", "voyage"];
+function generateProjectName() {
+  const adjective = PROJECT_ADJECTIVES[Math.floor(Math.random() * PROJECT_ADJECTIVES.length)] ?? "quiet";
+  const noun = PROJECT_NOUNS[Math.floor(Math.random() * PROJECT_NOUNS.length)] ?? "project";
+  return `${adjective}-${noun}`;
+}
+function validateProjectName(name) {
+  if (name.length < 1 || name.length > 64)
+    return "Project name must be 1-64 characters";
+  if (!NAME_PATTERN.test(name))
+    return "Project name must be lowercase alphanumeric with hyphens only";
+  return;
+}
 function isWorktreeInstance(directory) {
   return directory.includes("/worktree/") && directory.includes("/ensemble-");
 }
@@ -15662,17 +16810,19 @@ function hasReportedCompletion(db, teamId, memberName) {
 init_merge_helper();
 init_process();
 async function recoverStaleMembers(db, client3, cwd) {
-  const stale = db.query(`SELECT tm.session_id, tm.worktree_branch, tm.name, tm.team_id, t.name as team_name
-     FROM team_member tm
-     JOIN team t ON tm.team_id = t.id
-     WHERE tm.status = 'busy' AND t.status = 'active'`).all();
+  const stale = db.query(`SELECT tm.session_id, tm.worktree_branch, tm.name, tm.team_id, t.name as team_name, p.name as project_name
+      FROM team_member tm
+      JOIN team t ON tm.team_id = t.id
+      JOIN project p ON t.project_id = p.id
+      WHERE tm.status = 'busy' AND t.status = 'active'
+        AND (? IS NULL OR t.project_id = ? OR t.project_id = 'default')`).all(cwd ?? null, cwd ?? null);
   const result = db.run(`UPDATE team_member SET status = 'error', execution_status = 'idle', time_updated = ?
-     WHERE status = 'busy'
-       AND team_id IN (SELECT id FROM team WHERE status = 'active')`, [Date.now()]);
+      WHERE status = 'busy'
+        AND team_id IN (SELECT id FROM team WHERE status = 'active' AND (? IS NULL OR project_id = ? OR project_id = 'default'))`, [Date.now(), cwd ?? null, cwd ?? null]);
   if (client3) {
     for (const member of stale) {
       if (cwd && member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-        const safeBranch = preservedBranchName(member.team_name, member.name);
+        const safeBranch = preservedBranchName(member.project_name, member.team_name, member.team_id, member.name);
         const ok = await preserveBranch(member.worktree_branch, safeBranch, cwd);
         if (ok) {
           db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, member.team_id, member.name]);
@@ -15753,24 +16903,25 @@ function rehydrateRegistry(db, registry2) {
 }
 async function recoverOrphanedBranches(db, cwd) {
   let removed = 0;
-  const archivedTeams = db.query(`SELECT t.name FROM team t
+  const archivedTeams = db.query(`SELECT t.id, t.name, p.name as project_name FROM team t
+     JOIN project p ON t.project_id = p.id
      WHERE t.status = 'archived'
+      AND t.project_id = ?
      AND NOT EXISTS (
-       SELECT 1 FROM team_member tm
-       WHERE tm.team_id = t.id AND tm.status NOT IN ('shutdown', 'error')
-     )`).all();
+        SELECT 1 FROM team_member tm
+        WHERE tm.team_id = t.id AND tm.status NOT IN ('shutdown', 'error')
+      )`).all(cwd);
   if (archivedTeams.length === 0)
     return { removed: 0 };
-  const archivedNames = new Set(archivedTeams.map((t) => t.name));
+  const archivedPrefixes = archivedTeams.flatMap((t) => [
+    `ensemble/preserved/${t.project_name}/${teamResourceSegment(t.name, t.id)}/`,
+    `ensemble/preserved/${t.name}/`
+  ]);
   const result = await runCommand(["git", "branch", "--list", "ensemble/preserved/*"], { cwd });
   const branches = result.stdout.split(`
 `).map((b) => b.trim().replace(/^\* /, "")).filter(Boolean);
   for (const branch of branches) {
-    const parts = branch.split("/");
-    if (parts.length < 4)
-      continue;
-    const teamName = parts[2];
-    if (!teamName || !archivedNames.has(teamName))
+    if (!archivedPrefixes.some((prefix) => branch.startsWith(prefix)))
       continue;
     try {
       const deleteResult = await runCommand(["git", "branch", "-D", branch], { cwd });
@@ -16372,9 +17523,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;
@@ -16507,6 +17658,11 @@ var DASHBOARD_HEAD = `<!DOCTYPE html>
 details summary::-webkit-details-marker{display:none}details summary{list-style:none}
 :focus-visible{outline:2px solid rgba(96,165,250,.85);outline-offset:2px}
 select{-webkit-appearance:none;appearance:none;background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 24 24' fill='none' stroke='%235e6a82' stroke-width='2.5'%3E%3Cpath d='M6 9l6 6 6-6'/%3E%3C/svg%3E");background-repeat:no-repeat;background-position:right 8px center;padding-right:22px}
+.project-link[aria-current="true"]{color:#e2e8f0}
+.team-link[aria-current="true"]{color:#e2e8f0;border-left-color:#22c55e;background:rgba(34,197,94,.06)}
+#content.nav-collapsed{grid-template-columns:2rem minmax(0,1fr)}
+#projects[hidden]{display:none!important}
+#project-rail[hidden]{display:none!important}
 .xp{max-height:0;overflow:hidden;transition:max-height .3s ease-out}.xp-open{max-height:3000px;transition:max-height .5s ease-in}
 .card-sel{outline:2px solid rgba(59,130,246,.4);outline-offset:1px}
 .md pre{background:#1a1f2e;border:1px solid #1e2433;border-radius:6px;padding:8px 12px;overflow-x:auto;margin:6px 0;font-size:12px;line-height:1.5}
@@ -16527,8 +17683,7 @@ select{-webkit-appearance:none;appearance:none;background-image:url("data:image/
 <header class="fixed top-0 inset-x-0 h-11 bg-base-950/95 backdrop-blur border-b border-base-800 flex items-center justify-between px-3 sm:px-4 z-50">
 <div class="flex items-center gap-2 sm:gap-3 min-w-0 flex-1">
 <span class="font-mono font-semibold text-[13px] tracking-[.08em] text-txt-200">ensemble</span>
-<span class="text-base-700">|</span>
-<select id="sel" class="bg-base-900 border border-base-700 rounded-md px-2 py-[3px] text-[11px] text-txt-200 font-mono outline-none cursor-pointer hover:border-base-600 transition-colors max-w-[180px] sm:max-w-[320px] min-w-0"></select>
+<span id="crumb" class="text-[11px] text-txt-500 font-mono truncate"></span>
 </div>
 <div class="flex items-center gap-2 sm:gap-4 shrink-0">
 <div id="hring" class="w-6 h-6 rounded-full" title="Team health"></div>
@@ -16547,7 +17702,10 @@ select{-webkit-appearance:none;appearance:none;background-image:url("data:image/
 <div class="text-txt-400 text-sm">Waiting for a team</div>
 <div class="text-txt-500 text-[11px]">Run <code class="px-1.5 py-0.5 bg-base-900 rounded text-txt-300 font-mono text-[11px]">team_create</code> in OpenCode to get started</div>
 </div>
-<div id="content" class="hidden max-w-[1600px] mx-auto">
+<div id="content" class="hidden max-w-[1720px] mx-auto grid grid-cols-1 lg:grid-cols-[260px_minmax(0,1fr)] gap-4 items-start">
+<div id="project-rail" hidden class="lg:sticky lg:top-[88px]"><button id="nav-expand" type="button" aria-label="Show project navigation" aria-controls="projects" aria-expanded="false" class="h-8 w-8 rounded border border-base-800 text-txt-500 hover:text-txt-200 hover:border-base-700 transition-colors">&gt;</button></div>
+<aside id="projects" aria-label="Project navigation" class="bg-base-950/60 border-r border-base-800/70 pr-3 lg:sticky lg:top-[88px]"></aside>
+<div class="min-w-0">
 <section id="attention" aria-label="Team attention" class="mb-3"></section>
 <div class="grid grid-cols-1 xl:grid-cols-[minmax(360px,1.35fr)_minmax(320px,.8fr)] gap-4 items-start">
 <section aria-label="Agent roster"><div id="agents" class="grid gap-2" style="grid-template-columns:repeat(auto-fill,minmax(300px,1fr))"></div></section>
@@ -16557,6 +17715,7 @@ select{-webkit-appearance:none;appearance:none;background-image:url("data:image/
 </div>
 </div>
 </div>
+</div>
 </main>
 <div id="tl" aria-label="Event timeline" class="fixed bottom-0 inset-x-0 h-10 bg-base-900/90 backdrop-blur border-t border-base-800 px-4 flex items-center z-40 overflow-x-auto scroll hidden"></div>
 <div id="sco" role="dialog" aria-modal="true" aria-hidden="true" aria-labelledby="shortcuts-title" tabindex="-1" onclick="closeShortcuts()">
@@ -16575,9 +17734,9 @@ select{-webkit-appearance:none;appearance:none;background-image:url("data:image/
 <div id="drawer-bg" onclick="closeDrawer()"></div>
 <div id="drawer" class="scroll p-4" tabindex="-1" inert role="dialog" aria-modal="true" aria-labelledby="drawer-title" aria-hidden="true"><h2 id="drawer-title" class="sr-only">Agent detail</h2></div>`;
 
-// src/dashboard-js-part1.ts
-var DASHBOARD_JS_PART1 = `
-let S=null,selId=null,fails=0,pollT=Date.now(),prevMC=0,selCard=-1;
+// src/dashboard-js-core.ts
+var DASHBOARD_JS_CORE = `
+let S=null,selId=null,selProjectId=null,fails=0,pollT=Date.now(),prevMC=0,selCard=-1,navCollapsed=false;
 const expCards=new Set(),expMsgs=new Set();
 const E=s=>s?String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;'):'';
 const D=ms=>{const s=Math.floor(Math.abs(ms)/1000);return s<60?s+'s':s<3600?Math.floor(s/60)+'m':Math.floor(s/3600)+'h'};
@@ -16640,13 +17799,21 @@ function allTeams(){
   const archived=[...S.teams.filter(t=>t.status!=='active')].sort((a,b)=>b.timeUpdated-a.timeUpdated);
   return{active,archived};
 }
-function cur(){const{active,archived}=allTeams(),all=[...active,...archived];if(!all.length)return null;if(selId){const t=all.find(t=>t.id===selId);if(t)return t}return active[0]||all[0]}
+function allProjects(){return S?.projects?[...S.projects].sort((a,b)=>b.timeUpdated-a.timeUpdated):[]}
+function projectLabel(p){return p?(p.name||p.path||p.id):''}
+function curProject(){const ps=allProjects();if(!ps.length)return null;if(selProjectId){const p=ps.find(p=>p.id===selProjectId);if(p)return p}var t=cur();return t?ps.find(p=>p.id===t.projectId)||ps[0]:ps[0]}
+function cur(){const{active,archived}=allTeams(),all=[...active,...archived];if(!all.length)return null;if(selId){const t=all.find(t=>t.id===selId);if(t){selProjectId=t.projectId;return t}}const p=selProjectId&&S?.projects?.find(p=>p.id===selProjectId);const pt=p?[...(p.teams||[])].filter(t=>t.status==='active'):[ ];const t=pt.sort((a,b)=>b.timeUpdated-a.timeUpdated)[0]||active[0]||all[0];if(t){selId=t.id;selProjectId=t.projectId}return t}
 
 function deriveHealth(t){
   const mm=t.members||[];if(!mm.length)return{w:0,i:0,e:0,d:0,total:0};
   return{w:mm.filter(m=>m.status==='busy').length,i:mm.filter(m=>m.status==='ready').length,e:mm.filter(m=>m.status==='error').length,d:mm.filter(m=>m.status==='shutdown'||m.status==='shutdown_requested').length,total:mm.length};
 }
 
+function coarseTeamStatus(t){const h=deriveHealth(t),blocked=(t.tasks||[]).filter(x=>x.status==='blocked').length;if(h.e)return{label:'error',color:'red',dot:'bg-red-500'};if(blocked)return{label:'blocked',color:'amber',dot:'bg-amber-500'};if(h.w)return{label:'working',color:'blue',dot:'bg-blue-500'};if(h.i)return{label:'idle',color:'muted',dot:'bg-txt-500'};return{label:t.status==='active'?'empty':t.status,color:'muted',dot:'bg-base-600'}}
+function projectStatus(p){const teams=p.teams||[],counts={working:0,blocked:0,error:0,idle:0,done:0};teams.forEach(t=>{const s=coarseTeamStatus(t).label;if(s==='working')counts.working++;else if(s==='blocked')counts.blocked++;else if(s==='error')counts.error++;else if(s==='idle'||s==='empty')counts.idle++;else counts.done++});if(counts.error)return{label:'error',color:'red',dot:'bg-red-500',counts};if(counts.blocked)return{label:'blocked',color:'amber',dot:'bg-amber-500',counts};if(counts.working)return{label:'working',color:'blue',dot:'bg-blue-500',counts};return{label:'idle',color:'muted',dot:'bg-txt-500',counts}}
+function statusTitleProject(p){const s=projectStatus(p),teams=p.teams||[];return projectLabel(p)+'\\nStatus: '+s.label+'\\nTeams: '+teams.length+'\\nWorking: '+s.counts.working+' · Blocked: '+s.counts.blocked+' · Error: '+s.counts.error+' · Idle: '+s.counts.idle}
+function statusTitleTeam(t){const h=deriveHealth(t),tasks=t.tasks||[],blocked=tasks.filter(x=>x.status==='blocked').length,active=tasks.filter(x=>x.status==='in_progress').length,pending=tasks.filter(x=>x.status==='pending').length,done=tasks.filter(x=>x.status==='completed').length;return t.name+'\\nStatus: '+coarseTeamStatus(t).label+'\\nAgents: '+h.total+' total, '+h.w+' working, '+h.i+' idle, '+h.e+' error\\nTasks: '+active+' active, '+blocked+' blocked, '+pending+' pending, '+done+' done'}
+
 function lastMessageFor(name,msgs){return msgs.filter(m=>m.fromName===name||m.toName===name).sort((a,b)=>b.timeCreated-a.timeCreated)[0]||null}
 function activeTaskFor(name,tasks){return tasks.find(x=>x.assignee===name&&x.status==='in_progress')||tasks.find(x=>x.assignee===name&&x.status==='blocked')||null}
 function blockedTaskFor(name,tasks){return tasks.find(x=>x.assignee===name&&x.status==='blocked')||null}
@@ -16707,18 +17874,135 @@ function deriveThreads(msgs){
 }
 `;
 
-// src/dashboard-js-part2.ts
-var DASHBOARD_JS_PART2 = `
+// src/dashboard-js-events.ts
+var DASHBOARD_JS_EVENTS = `
+function toggleMsg(id){if(expMsgs.has(id))expMsgs.delete(id);else expMsgs.add(id);render()}
+
+function applyNavCollapse(){
+  const content=document.getElementById('content'),projects=document.getElementById('projects'),rail=document.getElementById('project-rail'),toggle=document.getElementById('nav-toggle'),expand=document.getElementById('nav-expand');
+  content.classList.toggle('nav-collapsed',navCollapsed);
+  projects.hidden=navCollapsed;
+  projects.setAttribute('aria-hidden',String(navCollapsed));
+  rail.hidden=!navCollapsed;
+  if(toggle)toggle.setAttribute('aria-expanded',String(!navCollapsed));
+  expand.setAttribute('aria-expanded',String(!navCollapsed));
+  if(document.activeElement===toggle&&navCollapsed)expand.focus();
+  if(document.activeElement===expand&&!navCollapsed&&toggle)toggle.focus();
+}
+
+function render(){
+  rSel();const t=cur();
+  const empty=document.getElementById('empty'),content=document.getElementById('content');
+  if(!t){empty.classList.remove('hidden');empty.classList.add('flex');content.classList.add('hidden');document.getElementById('tl').classList.add('hidden');return}
+  empty.classList.add('hidden');empty.classList.remove('flex');content.classList.remove('hidden');
+  applyNavCollapse();
+  const p=curProject();document.getElementById('crumb').textContent=p?' / '+projectLabel(p)+' / '+t.name:'';
+  rHealth(t);rSum(t);rAttention(t);rAgents(t);rTasks(t);rActivity(t);rTimeline(t);
+}
+
+function selectProject(id){selProjectId=id;const p=S?.projects?.find(p=>p.id===id);const t=(p?.teams||[]).filter(t=>t.status==='active').sort((a,b)=>b.timeUpdated-a.timeUpdated)[0]||(p?.teams||[])[0];if(t)selId=t.id;selCard=-1;render()}
+function selectTeam(id){selId=id;selCard=-1;render()}
+
+function conn(ok){
+  document.getElementById('cd').className='w-[7px] h-[7px] rounded-full '+(ok?'bg-emerald-500 pulse':'bg-red-500');
+  document.getElementById('ct').textContent=ok?D(Date.now()-pollT)+' ago':'reconnecting to dashboard state';
+}
+
+async function poll(){try{S=await(await fetch('/api/state')).json();fails=0;pollT=Date.now();conn(true);render()}catch{if(++fails>=3)conn(false)}}
+
+function setBackgroundInert(locked){
+  document.querySelectorAll('header,main,#sum,#tl').forEach(function(el){
+    el.inert=locked;
+    if(locked)el.setAttribute('aria-hidden','true');
+    else el.removeAttribute('aria-hidden');
+  });
+}
+
+function modalOpen(){return document.getElementById('sco').classList.contains('show')||document.getElementById('drawer').classList.contains('open')}
+
+function trapFocus(root,e){
+  const nodes=[...root.querySelectorAll('button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])')].filter(function(el){return !el.disabled&&!el.inert&&el.offsetParent!==null});
+  if(!nodes.length){e.preventDefault();root.focus();return}
+  const first=nodes[0],last=nodes[nodes.length-1];
+  if(e.shiftKey&&document.activeElement===first){e.preventDefault();last.focus();return}
+  if(!e.shiftKey&&document.activeElement===last){e.preventDefault();first.focus();return}
+}
+
+function openShortcuts(){
+  const el=document.getElementById('sco');
+  setBackgroundInert(true);
+  el.classList.add('show');
+  el.setAttribute('aria-hidden','false');
+  document.getElementById('sco').focus();
+}
+
+function closeShortcuts(){
+  const el=document.getElementById('sco');
+  el.classList.remove('show');
+  el.setAttribute('aria-hidden','true');
+  if(!modalOpen())setBackgroundInert(false);
+}
+
+// Clock update every second
+setInterval(function(){var t=cur();if(t)rClock(t);if(fails<3)conn(true)},1000);
+
+// Poll every 2.5s
+setInterval(poll,2500);
+
+document.addEventListener('click',function(e){
+  const id=e.target&&e.target.id;
+  if(id!=='nav-toggle'&&id!=='nav-expand')return;
+  navCollapsed=id==='nav-toggle';
+  applyNavCollapse();
+});
+
+// Keyboard shortcuts
+document.addEventListener('keydown',function(e){
+  const shortcutsOpen=document.getElementById('sco').classList.contains('show');
+  if(shortcutsOpen&&e.key==='Tab'){trapFocus(document.getElementById('sco'),e);return}
+  if(shortcutsOpen&&e.key==='Escape'){e.preventDefault();closeShortcuts();return}
+  const drawerOpen=document.getElementById('drawer').classList.contains('open');
+  if(drawerOpen&&e.key==='Tab'){trapFocus(document.getElementById('drawer'),e);return}
+  if(drawerOpen&&e.key==='Escape'){e.preventDefault();closeDrawer();return}
+  if(drawerOpen&&e.key==='?'){e.preventDefault();return}
+  if(e.target.tagName==='INPUT'||e.target.tagName==='SELECT'||e.target.tagName==='TEXTAREA')return;
+  var t=cur();if(!t)return;
+  var mm=[...(t.members||[])].sort((a,b)=>rankAgent(a,b,t));
+  if(e.key==='?'){e.preventDefault();shortcutsOpen?closeShortcuts():openShortcuts();return}
+  if(e.key==='Escape'){closeDrawer();expMsgs.clear();selCard=-1;closeShortcuts();render();return}
+  if(e.key==='j'&&mm.length){e.preventDefault();selCard=Math.min(selCard+1,mm.length-1);render();return}
+  if(e.key==='k'&&mm.length){e.preventDefault();selCard=Math.max(selCard-1,0);render();return}
+  if(e.key==='Enter'&&selCard>=0&&selCard<mm.length){e.preventDefault();openDrawer(mm[selCard].name);return}
+  if(e.key>='1'&&e.key<='9'){
+    var teams=allTeams(),all=[...teams.active,...teams.archived];
+    var idx=parseInt(e.key)-1;
+    if(idx<all.length){selId=all[idx].id;render()}
+  }
+});
+
+// Initial poll
+poll();
+
+console.log('%c Ensemble Mission Control','font-size:14px;font-weight:bold;color:#22c55e');
+`;
+
+// src/dashboard-js-render.ts
+var DASHBOARD_JS_RENDER = `
 function rSel(){
-  const el=document.getElementById('sel'),{active,archived}=allTeams(),c=cur();
-  if(!active.length&&!archived.length){el.innerHTML='<option>No teams</option>';return}
-  let h='';
-  if(active.length){h+='<optgroup label="Active">';h+=active.map(t=>'<option value="'+t.id+'">'+E(t.name)+' ('+relT(t.timeUpdated)+')</option>').join('');h+='</optgroup>'}
-  if(archived.length){h+='<optgroup label="Archived">';h+=archived.slice(0,5).map(t=>'<option value="'+t.id+'">'+E(t.name)+'</option>').join('');if(archived.length>5)h+='<option disabled>+ '+(archived.length-5)+' more</option>';h+='</optgroup>'}
-  if(el._lh!==h){el.innerHTML=h;el._lh=h}
-  if(c)el.value=c.id;
+  const el=document.getElementById('projects'),ps=allProjects(),c=cur(),cp=curProject();
+  const head=renderProjectNavHeader();
+  if(!ps.length){patch(el,head+'<div class="text-center text-txt-500 text-[12px] py-6">No projects yet</div>');return}
+  let h='<nav class="text-[12px]" aria-label="Projects">'+head+'<div class="space-y-4">';
+  ps.forEach(function(p){h+=renderProjectSection(p,cp,c)});
+  h+='</div></nav>';
+  patch(el,h);
 }
 
+function renderProjectNavHeader(){return '<div class="flex items-center justify-between gap-2 mb-3"><div class="text-[10px] uppercase tracking-[.18em] text-txt-500">Projects</div><button id="nav-toggle" type="button" aria-label="Hide project navigation" aria-controls="projects" aria-expanded="true" class="text-[10px] text-txt-500 border border-base-800 rounded px-1.5 py-[2px] hover:text-txt-200 hover:border-base-700 transition-colors">hide</button></div>'}
+function renderProjectSection(p,cp,c){const teams=p.teams||[];return '<section>'+renderProjectButton(p,cp)+'<div class="mt-2 ml-[7px] border-l border-base-800/80">'+[...teams].sort((a,b)=>b.timeUpdated-a.timeUpdated).map(t=>renderTeamLink(t,c)).join('')+'</div></section>'}
+function renderProjectButton(p,cp){const teams=p.teams||[],active=teams.filter(t=>t.status==='active').length,sel=cp&&cp.id===p.id,pss=projectStatus(p);return '<button type="button" aria-current="'+(sel?'true':'false')+'" title="'+E(statusTitleProject(p))+'" class="project-link group w-full text-left text-txt-300 hover:text-txt-100 transition-colors" data-project="'+E(p.id)+'" onclick="selectProject(this.dataset.project)"><div class="flex items-center gap-2 min-w-0"><span class="w-[5px] h-[5px] rounded-full '+pss.dot+(pss.label==='working'?' pulse':'')+' shrink-0"></span><span class="font-mono font-semibold truncate">'+E(projectLabel(p))+'</span>'+chip(pss.label,pss.color)+'</div><div class="mt-1 ml-3 text-[10px] text-txt-500">'+active+' team'+(active!==1?'s':'')+'</div></button>'}
+function renderTeamLink(t,c){const ss=coarseTeamStatus(t),tsel=c&&c.id===t.id;return '<button type="button" title="'+E(statusTitleTeam(t))+'" class="team-link block w-full text-left border-l-2 border-transparent -ml-px py-1.5 pl-3 pr-2 text-[11px] text-txt-500 hover:text-txt-200 hover:bg-base-900/70 transition-colors" aria-current="'+(tsel?'true':'false')+'" data-team="'+E(t.id)+'" onclick="selectTeam(this.dataset.team)"><div class="flex items-center gap-2 min-w-0"><span class="w-[5px] h-[5px] rounded-full '+ss.dot+(ss.label==='working'?' pulse':'')+' shrink-0"></span><span class="truncate font-mono">'+E(t.name)+'</span><span class="ml-auto text-[9px] uppercase tracking-wide text-txt-500">'+E(ss.label)+'</span></div></button>'}
+
 function rHealth(t){
   const el=document.getElementById('hring'),h=deriveHealth(t);
   if(!h.total){el.style.background='conic-gradient(#2a3144 0deg,#2a3144 360deg)';return}
@@ -16968,100 +18252,9 @@ function rTimeline(t){
 }
 `;
 
-// src/dashboard-js-part3.ts
-var DASHBOARD_JS_PART3 = `
-function toggleMsg(id){if(expMsgs.has(id))expMsgs.delete(id);else expMsgs.add(id);render()}
-
-function render(){
-  rSel();const t=cur();
-  const empty=document.getElementById('empty'),content=document.getElementById('content');
-  if(!t){empty.classList.remove('hidden');empty.classList.add('flex');content.classList.add('hidden');document.getElementById('tl').classList.add('hidden');return}
-  empty.classList.add('hidden');empty.classList.remove('flex');content.classList.remove('hidden');
-  rHealth(t);rSum(t);rAttention(t);rAgents(t);rTasks(t);rActivity(t);rTimeline(t);
-}
-
-function conn(ok){
-  document.getElementById('cd').className='w-[7px] h-[7px] rounded-full '+(ok?'bg-emerald-500 pulse':'bg-red-500');
-  document.getElementById('ct').textContent=ok?D(Date.now()-pollT)+' ago':'reconnecting to dashboard state';
-}
-
-async function poll(){try{S=await(await fetch('/api/state')).json();fails=0;pollT=Date.now();conn(true);render()}catch{if(++fails>=3)conn(false)}}
-
-function setBackgroundInert(locked){
-  document.querySelectorAll('header,main,#sum,#tl').forEach(function(el){
-    el.inert=locked;
-    if(locked)el.setAttribute('aria-hidden','true');
-    else el.removeAttribute('aria-hidden');
-  });
-}
-
-function modalOpen(){return document.getElementById('sco').classList.contains('show')||document.getElementById('drawer').classList.contains('open')}
-
-function trapFocus(root,e){
-  const nodes=[...root.querySelectorAll('button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])')].filter(function(el){return !el.disabled&&!el.inert&&el.offsetParent!==null});
-  if(!nodes.length){e.preventDefault();root.focus();return}
-  const first=nodes[0],last=nodes[nodes.length-1];
-  if(e.shiftKey&&document.activeElement===first){e.preventDefault();last.focus();return}
-  if(!e.shiftKey&&document.activeElement===last){e.preventDefault();first.focus();return}
-}
-
-function openShortcuts(){
-  const el=document.getElementById('sco');
-  setBackgroundInert(true);
-  el.classList.add('show');
-  el.setAttribute('aria-hidden','false');
-  document.getElementById('sco').focus();
-}
-
-function closeShortcuts(){
-  const el=document.getElementById('sco');
-  el.classList.remove('show');
-  el.setAttribute('aria-hidden','true');
-  if(!modalOpen())setBackgroundInert(false);
-}
-
-// Clock update every second
-setInterval(function(){var t=cur();if(t)rClock(t);if(fails<3)conn(true)},1000);
-
-// Poll every 2.5s
-setInterval(poll,2500);
-
-// Keyboard shortcuts
-document.addEventListener('keydown',function(e){
-  const shortcutsOpen=document.getElementById('sco').classList.contains('show');
-  if(shortcutsOpen&&e.key==='Tab'){trapFocus(document.getElementById('sco'),e);return}
-  if(shortcutsOpen&&e.key==='Escape'){e.preventDefault();closeShortcuts();return}
-  const drawerOpen=document.getElementById('drawer').classList.contains('open');
-  if(drawerOpen&&e.key==='Tab'){trapFocus(document.getElementById('drawer'),e);return}
-  if(drawerOpen&&e.key==='Escape'){e.preventDefault();closeDrawer();return}
-  if(drawerOpen&&e.key==='?'){e.preventDefault();return}
-  if(e.target.tagName==='INPUT'||e.target.tagName==='SELECT'||e.target.tagName==='TEXTAREA')return;
-  var t=cur();if(!t)return;
-  var mm=[...(t.members||[])].sort((a,b)=>rankAgent(a,b,t));
-  if(e.key==='?'){e.preventDefault();shortcutsOpen?closeShortcuts():openShortcuts();return}
-  if(e.key==='Escape'){closeDrawer();expMsgs.clear();selCard=-1;closeShortcuts();render();return}
-  if(e.key==='j'&&mm.length){e.preventDefault();selCard=Math.min(selCard+1,mm.length-1);render();return}
-  if(e.key==='k'&&mm.length){e.preventDefault();selCard=Math.max(selCard-1,0);render();return}
-  if(e.key==='Enter'&&selCard>=0&&selCard<mm.length){e.preventDefault();openDrawer(mm[selCard].name);return}
-  if(e.key>='1'&&e.key<='9'){
-    var teams=allTeams(),all=[...teams.active,...teams.archived];
-    var idx=parseInt(e.key)-1;
-    if(idx<all.length){selId=all[idx].id;render()}
-  }
-});
-
-// Select handler
-document.getElementById('sel').addEventListener('change',function(){selId=this.value;render()});
-
-// Initial poll
-poll();
-
-console.log('%c Ensemble Mission Control','font-size:14px;font-weight:bold;color:#22c55e');
-`;
-
 // src/dashboard.ts
 var DASHBOARD_HTML = DASHBOARD_HEAD + `
-<script>` + DASHBOARD_JS_PART1 + DASHBOARD_JS_PART2 + DASHBOARD_JS_PART3 + `</script>
+<script>` + DASHBOARD_JS_CORE + DASHBOARD_JS_RENDER + DASHBOARD_JS_EVENTS + `</script>
 </body></html>`;
 function parseDependsOn(value) {
   if (!value)
@@ -17078,30 +18271,33 @@ function parseDependsOn(value) {
   return [];
 }
 function buildState(db) {
-  const teams = db.query("SELECT id, name, status, lead_agent, time_created, time_updated FROM team ORDER BY time_created DESC").all();
+  const projects = db.query("SELECT id, name, path, status, time_created, time_updated FROM project ORDER BY time_updated DESC").all();
+  const teams = db.query("SELECT id, name, project_id, status, lead_agent, time_created, time_updated FROM team ORDER BY time_created DESC").all();
   const memberStmt = db.query("SELECT name, agent, status, execution_status, worktree_branch, prompt, model, plan_approval, time_created, time_updated FROM team_member WHERE team_id = ?");
   const taskStmt = db.query("SELECT id, content, status, priority, assignee, depends_on, time_created, time_updated FROM team_task WHERE team_id = ?");
   const msgStmt = db.query("SELECT id, from_name, to_name, content, delivered, read, time_created FROM team_message WHERE team_id = ? ORDER BY time_created DESC LIMIT 50");
-  return {
-    teams: teams.map((t) => ({
+  const mappedTeams = teams.map((t) => {
+    const members = memberStmt.all(t.id).map((m) => ({
+      name: m.name,
+      agent: m.agent,
+      status: m.status,
+      executionStatus: m.execution_status,
+      worktreeBranch: m.worktree_branch,
+      prompt: m.prompt,
+      model: m.model,
+      planApproval: m.plan_approval,
+      timeCreated: m.time_created,
+      timeUpdated: m.time_updated
+    }));
+    return {
       id: t.id,
       name: t.name,
+      projectId: t.project_id,
       status: t.status,
       leadAgent: t.lead_agent,
       timeCreated: t.time_created,
       timeUpdated: t.time_updated,
-      members: memberStmt.all(t.id).map((m) => ({
-        name: m.name,
-        agent: m.agent,
-        status: m.status,
-        executionStatus: m.execution_status,
-        worktreeBranch: m.worktree_branch,
-        prompt: m.prompt,
-        model: m.model,
-        planApproval: m.plan_approval,
-        timeCreated: m.time_created,
-        timeUpdated: m.time_updated
-      })),
+      members,
       tasks: taskStmt.all(t.id).map((tk) => ({
         id: tk.id,
         content: tk.content,
@@ -17121,7 +18317,34 @@ function buildState(db) {
         read: msg.read === 1,
         timeCreated: msg.time_created
       }))
-    }))
+    };
+  });
+  const teamsByProject = new Map;
+  mappedTeams.forEach((team) => {
+    const projectId = team.projectId;
+    teamsByProject.set(projectId, [...teamsByProject.get(projectId) ?? [], team]);
+  });
+  return {
+    projects: projects.flatMap((project) => {
+      const projectTeams = teamsByProject.get(project.id) ?? [];
+      if (projectTeams.length === 0)
+        return [];
+      return {
+        id: project.id,
+        name: project.name,
+        path: project.path,
+        status: project.status,
+        timeCreated: project.time_created,
+        timeUpdated: project.time_updated,
+        activeTeams: projectTeams.filter((team) => team.status === "active").length,
+        workingAgents: projectTeams.reduce((count, team) => {
+          const members = team.members;
+          return count + members.filter((member) => member.status === "busy").length;
+        }, 0),
+        teams: projectTeams
+      };
+    }),
+    teams: mappedTeams
   };
 }
 function sendJson(res, data) {
@@ -17204,7 +18427,13 @@ async function executeTeamCreate(deps, args, sessionId) {
   const nameError = validateTeamName(args.name);
   if (nameError)
     throw new Error(nameError);
-  const existing = deps.db.query("SELECT id FROM team WHERE name = ? AND status = 'active'").get(args.name);
+  if (args.project_name) {
+    const projectNameError = validateProjectName(args.project_name);
+    if (projectNameError)
+      throw new Error(projectNameError);
+  }
+  const projectId = deps.directory;
+  const existing = deps.db.query("SELECT id FROM team WHERE name = ? AND project_id = ? AND status = 'active'").get(args.name, projectId);
   if (existing)
     throw new Error(`Team "${args.name}" already exists`);
   const lead = findTeamBySession(deps.db, deps.registry, sessionId);
@@ -17212,7 +18441,11 @@ async function executeTeamCreate(deps, args, sessionId) {
     throw new Error(`This session already belongs to team "${lead.teamName}"`);
   const id = generateId("team");
   const now = Date.now();
-  deps.db.run("INSERT INTO team (id, name, lead_session_id, status, delegate, time_created, time_updated) VALUES (?, ?, ?, 'active', 0, ?, ?)", [id, args.name, sessionId, now, now]);
+  const projectName = args.project_name ?? generateProjectName();
+  deps.db.run(`INSERT INTO project (id, name, path, status, time_created, time_updated)
+     VALUES (?, ?, ?, 'active', ?, ?)
+     ON CONFLICT(id) DO UPDATE SET time_updated = excluded.time_updated`, [projectId, projectName, projectId, now, now]);
+  deps.db.run("INSERT INTO team (id, name, project_id, lead_session_id, status, delegate, time_created, time_updated) VALUES (?, ?, ?, ?, 'active', 0, ?, ?)", [id, args.name, projectId, sessionId, now, now]);
   return `Team "${args.name}" created. You are the lead. Use team_spawn to add teammates.`;
 }
 
@@ -17277,6 +18510,7 @@ function requireCanPurgeArchivedTeams(deps, sessionId) {
 }
 
 // src/tools/team-spawn.ts
+init_merge_helper();
 var spawnFailures = new Map;
 function parseModelId(model) {
   const slash = model.indexOf("/");
@@ -17333,7 +18567,8 @@ async function executeTeamSpawn(deps, args, sessionId) {
   let worktreeDir = null;
   let worktreeBranch = null;
   if (useWorktree) {
-    const worktreeName = `ensemble-${teamInfo.teamName}-${args.name}`;
+    const resource = getTeamResourceParts(deps.db, teamInfo.teamId);
+    const worktreeName = teamWorktreeName(resource.projectName, resource.teamName, resource.teamId, args.name);
     try {
       log(`spawn:worktree:start name=${args.name}`);
       const result = await withTimeout(deps.client.worktree.create({ worktreeCreateInput: { name: worktreeName } }), getSpawnTimeout(), `worktree.create for "${args.name}"`);
@@ -17650,7 +18885,7 @@ async function executeTeamShutdown(deps, args, sessionId, isDirty = checkWorktre
     throw new Error(`Teammate "${args.member}" is already shut down`);
   const force = args.force ?? false;
   if (member.status === "shutdown_requested") {
-    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve);
+    await preserveAndAbort(deps, teamInfo.teamId, args.member, member.session_id, member.worktree_branch, preserve);
     const status = await getBranchStatus(deps, teamInfo.teamId, args.member, member.worktree_dir, isDirty, commitCount);
     return `Force shut down "${args.member}".${status}`;
   }
@@ -17661,12 +18896,13 @@ async function executeTeamShutdown(deps, args, sessionId, isDirty = checkWorktre
     isIdle = !sessionStatus || sessionStatus.type === "idle";
   } catch {}
   if (isIdle || force) {
-    await preserveAndAbort(deps, teamInfo.teamId, teamInfo.teamName, args.member, member.session_id, member.worktree_branch, preserve);
+    await preserveAndAbort(deps, teamInfo.teamId, args.member, member.session_id, member.worktree_branch, preserve);
     const status = await getBranchStatus(deps, teamInfo.teamId, args.member, member.worktree_dir, isDirty, commitCount);
     return `Teammate "${args.member}" has been shut down.${status}`;
   }
   if (member.worktree_branch) {
-    const safeBranch = preservedBranchName(teamInfo.teamName, args.member);
+    const resource = getTeamResourceParts(deps.db, teamInfo.teamId);
+    const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, args.member);
     const ok = await preserve(member.worktree_branch, safeBranch, deps.directory);
     if (ok) {
       deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, teamInfo.teamId, args.member]);
@@ -17685,9 +18921,10 @@ async function executeTeamShutdown(deps, args, sessionId, isDirty = checkWorktre
   deps.db.run("UPDATE team_member SET status = 'shutdown_requested', time_updated = ? WHERE team_id = ? AND name = ?", [Date.now(), teamInfo.teamId, args.member]);
   return `Shutdown requested for ${args.member}. They will finish current work and shut down. Call team_shutdown with force: true to abort immediately.`;
 }
-async function preserveAndAbort(deps, teamId, teamName, memberName, sessionId, worktreeBranch, preserve) {
+async function preserveAndAbort(deps, teamId, memberName, sessionId, worktreeBranch, preserve) {
   if (worktreeBranch && !worktreeBranch.startsWith("ensemble/preserved/")) {
-    const safeBranch = preservedBranchName(teamName, memberName);
+    const resource = getTeamResourceParts(deps.db, teamId);
+    const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, memberName);
     const ok = await preserve(worktreeBranch, safeBranch, deps.directory);
     if (ok) {
       deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, teamId, memberName]);
@@ -17771,20 +19008,20 @@ function resolvePurgeTargets(deps, purge) {
     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();
+    return deps.db.query("SELECT t.id, t.name, t.project_id, p.name as project_name, t.time_updated FROM team t JOIN project p ON t.project_id = p.id WHERE t.status = 'archived' AND t.project_id = ? ORDER BY t.time_updated DESC, t.name ASC").all(deps.directory);
   }
   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)
+    teams: deps.db.query("SELECT t.id, t.name, t.project_id, p.name as project_name, t.status, t.time_updated FROM team t JOIN project p ON t.project_id = p.id WHERE t.name = ? AND t.project_id = ? ORDER BY t.time_updated DESC").all(name, deps.directory)
   }));
-  const missing = rows.filter((row) => row.team === null).map((row) => row.name);
+  const missing = rows.filter((row) => row.teams.length === 0).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);
+  const active = rows.filter((row) => row.teams.some((team) => 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));
+  return rows.map((row) => row.teams[0]).sort((a, b) => b.time_updated - a.time_updated || a.name.localeCompare(b.name));
 }
 function deleteArchivedTeams(deps, targets) {
   const transaction = deps.db.transaction((teams) => {
@@ -17808,6 +19045,7 @@ function deleteArchivedTeams(deps, targets) {
 }
 function getPurgeMemberResources(deps, targets) {
   return targets.flatMap((target) => deps.db.query(`SELECT t.name as team_name,
+            p.name as project_name,
             tm.team_id,
             tm.name as member_name,
             tm.worktree_dir,
@@ -17815,19 +19053,24 @@ function getPurgeMemberResources(deps, targets) {
             tm.worktree_branch
      FROM team_member tm
      JOIN team t ON tm.team_id = t.id
+     JOIN project p ON t.project_id = p.id
      WHERE tm.team_id = ?`).all(target.id));
 }
 function preservedBranchPrefix(resource) {
+  return `ensemble/preserved/${resource.project_name}/${teamResourceSegment(resource.team_name, resource.team_id)}/`;
+}
+function legacyPreservedBranchPrefix(resource) {
   return `ensemble/preserved/${resource.team_name}/`;
 }
 function staleEnsembleBranchNames(resource) {
   return [
+    `ensemble-${resource.team_id}-${resource.member_name}`,
     `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));
+  return resource.worktree_branch !== null && (resource.worktree_branch.startsWith(preservedBranchPrefix(resource)) || resource.worktree_branch.startsWith(legacyPreservedBranchPrefix(resource)));
 }
 function isStaleEnsembleBranch(resource) {
   return resource.worktree_branch !== null && staleEnsembleBranchNames(resource).includes(resource.worktree_branch);
@@ -17955,18 +19198,18 @@ function validatePurgeTargetsStillArchived(deps, targets) {
 }
 async function collectPreservedBranches(targets, cwd, listBranches) {
   const entries = await Promise.all(targets.map(async (target) => {
-    const prefix = `ensemble/preserved/${target.name}/`;
+    const prefixes = [`ensemble/preserved/${target.project_name}/${teamResourceSegment(target.name, target.id)}/`, `ensemble/preserved/${target.name}/`];
     let listed;
     try {
-      listed = await listBranches(target.name, cwd);
+      listed = [...await listBranches(target.project_name, cwd), ...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}`);
+        throw new Error(`Failed to list preserved branches for ${target.id}: ${message}`);
     }
-    const branches = listed.map(normalizeBranchName).filter((branch) => branch.startsWith(prefix));
+    const branches = listed.map(normalizeBranchName).filter((branch) => prefixes.some((prefix) => branch.startsWith(prefix)));
     return [target.id, [...new Set(branches)]];
   }));
   return new Map(entries);
@@ -18090,7 +19333,8 @@ Commit or merge their work first, then call team_cleanup with acknowledge_uncomm
   if (args.force) {
     for (const member of active) {
       if (member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-        const safeBranch = preservedBranchName(teamInfo.teamName, member.name);
+        const resource = getTeamResourceParts(deps.db, teamInfo.teamId);
+        const safeBranch = preservedBranchName(resource.projectName, resource.teamName, resource.teamId, member.name);
         const ok = await preserveBranch(member.worktree_branch, safeBranch, deps.directory);
         if (ok) {
           deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, teamInfo.teamId, member.name]);
@@ -18601,15 +19845,16 @@ class Watchdog {
     if (this.ttlMs === 0)
       return;
     const cutoff = Date.now() - this.ttlMs;
-    const stale = this.db.query(`SELECT tm.team_id, tm.name, tm.session_id, tm.worktree_branch, t.name as team_name
+    const stale = this.db.query(`SELECT tm.team_id, tm.name, tm.session_id, tm.worktree_branch, t.name as team_name, p.name as project_name
        FROM team_member tm
        JOIN team t ON tm.team_id = t.id
+       JOIN project p ON t.project_id = p.id
        WHERE t.status = 'active'
          AND tm.status = 'busy'
          AND tm.time_updated < ?`).all(cutoff);
     for (const member of stale) {
       if (this.cwd && member.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-        const safeBranch = preservedBranchName(member.team_name, member.name);
+        const safeBranch = preservedBranchName(member.project_name, member.team_name, member.team_id, member.name);
         const ok = await preserveBranch(member.worktree_branch, safeBranch, this.cwd);
         if (ok) {
           this.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, member.team_id, member.name]);
@@ -18773,15 +20018,13 @@ var plugin = async (input) => {
           } else if (transition.to === "busy_while_shutdown") {
             const member = deps.db.query("SELECT worktree_branch, name, team_id FROM team_member WHERE session_id = ?").get(sessionID);
             if (member?.worktree_branch && !member.worktree_branch.startsWith("ensemble/preserved/")) {
-              const teamRow = deps.db.query("SELECT name FROM team WHERE id = ?").get(member.team_id);
-              if (teamRow) {
-                const { preserveBranch: preserve, preservedBranchName: branchName } = await Promise.resolve().then(() => (init_merge_helper(), exports_merge_helper));
-                const safeBranch = branchName(teamRow.name, member.name);
-                const ok = await preserve(member.worktree_branch, safeBranch, deps.directory);
-                if (ok) {
-                  deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, member.team_id, member.name]);
-                  log(`busy_while_shutdown:branch:preserved src=${member.worktree_branch} target=${safeBranch}`);
-                }
+              const { getTeamResourceParts: getTeamResourceParts2, preserveBranch: preserve, preservedBranchName: branchName } = await Promise.resolve().then(() => (init_merge_helper(), exports_merge_helper));
+              const resource = getTeamResourceParts2(deps.db, member.team_id);
+              const safeBranch = branchName(resource.projectName, resource.teamName, resource.teamId, member.name);
+              const ok = await preserve(member.worktree_branch, safeBranch, deps.directory);
+              if (ok) {
+                deps.db.run("UPDATE team_member SET worktree_branch = ? WHERE team_id = ? AND name = ?", [safeBranch, member.team_id, member.name]);
+                log(`busy_while_shutdown:branch:preserved src=${member.worktree_branch} target=${safeBranch}`);
               }
             }
             try {
@@ -18898,7 +20141,8 @@ var plugin = async (input) => {
       team_create: tool({
         description: "Create a new agent team. You become the team lead. Use this before spawning teammates.",
         args: {
-          name: tool.schema.string().describe("Team name (lowercase alphanumeric with hyphens, 1-64 chars)")
+          name: tool.schema.string().describe("Team name (lowercase alphanumeric with hyphens, 1-64 chars)"),
+          project_name: tool.schema.string().optional().describe("Project display name for first use of this working directory. If omitted, a short random name is generated.")
         },
         async execute(args, ctx) {
           const result = await executeTeamCreate(deps, args, ctx.sessionID);