@vibedeckx/darwin-arm64 0.3.11 → 0.3.12

package/dist/bin.js

@@ -13356,12 +13356,12 @@ var require_semver = __commonJS({
     }
     function replaceHyphen(comp, options) {
       const r = HYPHENRANGE_REGEXP;
-      return comp.replace(r, (_3, from, fM, fm, fp36, fpr, fb, to, tM, tm, tp, tpr) => {
+      return comp.replace(r, (_3, from, fM, fm, fp35, fpr, fb, to, tM, tm, tp, tpr) => {
         if (isX(fM)) {
           from = "";
         } else if (isX(fm)) {
           from = `>=${fM}.0.0${options?.includePrerelease ? "-0" : ""}`;
-        } else if (isX(fp36)) {
+        } else if (isX(fp35)) {
           from = `>=${fM}.${fm}.0${options?.includePrerelease ? "-0" : ""}`;
         } else if (fpr) {
           from = `>=${from}`;
@@ -87525,12 +87525,12 @@ var require_range = __commonJS({
       debug("replaceGTE0", comp, options);
       return comp.trim().replace(re2[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
     };
-    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp36, fpr, fb, to, tM, tm, tp, tpr) => {
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp35, fpr, fb, to, tM, tm, tp, tpr) => {
       if (isX(fM)) {
         from = "";
       } else if (isX(fm)) {
         from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
-      } else if (isX(fp36)) {
+      } else if (isX(fp35)) {
         from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
       } else if (fpr) {
         from = `>=${from}`;
@@ -90111,8 +90111,8 @@ var require_pretty_print = __commonJS({
       serializedRoute += serializeMetaData(route.metaData);
       return serializedRoute;
     }
-    function mergeSimilarRoutes(routes35) {
-      return routes35.reduce((mergedRoutes, route) => {
+    function mergeSimilarRoutes(routes34) {
+      return routes34.reduce((mergedRoutes, route) => {
         for (const nodeRoute of mergedRoutes) {
           if (deepEqual(route.opts.constraints, nodeRoute.opts.constraints) && deepEqual(route.metaData, nodeRoute.metaData)) {
             nodeRoute.method += ", " + route.method;
@@ -90124,18 +90124,18 @@ var require_pretty_print = __commonJS({
       }, []);
     }
     function serializeNode(node, prefix, options) {
-      let routes35 = node.routes;
+      let routes34 = node.routes;
       if (options.method === void 0) {
-        routes35 = routes35.map(normalizeRoute);
+        routes34 = routes34.map(normalizeRoute);
       }
-      routes35 = routes35.map((route) => {
+      routes34 = routes34.map((route) => {
         route.metaData = getRouteMetaData(route, options);
         return route;
       });
       if (options.method === void 0) {
-        routes35 = mergeSimilarRoutes(routes35);
+        routes34 = mergeSimilarRoutes(routes34);
       }
-      return routes35.map(serializeRoute).join(`
+      return routes34.map(serializeRoute).join(`
 ${prefix}`);
     }
     function buildObjectTree(node, tree, prefix, options) {
@@ -91402,9 +91402,9 @@ var require_find_my_way = __commonJS({
         pathIndex = paramEndIndex;
       }
     };
-    Router.prototype._rebuild = function(routes35) {
+    Router.prototype._rebuild = function(routes34) {
       this.reset();
-      for (const route of routes35) {
+      for (const route of routes34) {
         const { method, path: path22, opts, handler, store } = route;
         this._on(method, path22, opts, handler, store);
       }
@@ -93805,7 +93805,7 @@ var require_parse_url = __commonJS({
 var require_form_data = __commonJS({
   "../../node_modules/.pnpm/light-my-request@6.6.0/node_modules/light-my-request/lib/form-data.js"(exports, module) {
     "use strict";
-    var { randomUUID: randomUUID24 } = __require("node:crypto");
+    var { randomUUID: randomUUID23 } = __require("node:crypto");
     var { Readable: Readable4 } = __require("node:stream");
     var textEncoder;
     function isFormDataLike(payload) {
@@ -93813,7 +93813,7 @@ var require_form_data = __commonJS({
     }
     function formDataToStream(formdata) {
       textEncoder = textEncoder ?? new TextEncoder();
-      const boundary = `----formdata-${randomUUID24()}`;
+      const boundary = `----formdata-${randomUUID23()}`;
       const prefix = `--${boundary}\r
 Content-Disposition: form-data`;
       const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
@@ -100612,8 +100612,8 @@ var require_commonjs6 = __commonJS({
           return this.#fullpath = this.name;
         }
         const pv = p2.fullpath();
-        const fp36 = pv + (!p2.parent ? "" : this.sep) + name25;
-        return this.#fullpath = fp36;
+        const fp35 = pv + (!p2.parent ? "" : this.sep) + name25;
+        return this.#fullpath = fp35;
       }
       /**
        * On platforms other than windows, this is identical to fullpath.
@@ -105329,7 +105329,7 @@ var require_static = __commonJS({
     var { fileURLToPath: fileURLToPath4 } = __require("node:url");
     var { statSync: statSync2 } = __require("node:fs");
     var { glob } = require_commonjs7();
-    var fp36 = require_plugin2();
+    var fp35 = require_plugin2();
     var send = require_send2();
     var encodingNegotiator = require_accept_negotiator();
     var contentDisposition = require_content_disposition();
@@ -105433,7 +105433,7 @@ var require_static = __commonJS({
         } else {
           const indexes = new Set(opts.index === void 0 ? ["index.html"] : [].concat(opts.index));
           const indexDirs = /* @__PURE__ */ new Map();
-          const routes35 = /* @__PURE__ */ new Set();
+          const routes34 = /* @__PURE__ */ new Set();
           const roots = Array.isArray(sendOptions.root) ? sendOptions.root : [sendOptions.root];
           for (let rootPath of roots) {
             rootPath = rootPath.split(path22.win32.sep).join(path22.posix.sep);
@@ -105449,10 +105449,10 @@ var require_static = __commonJS({
             for (let file2 of files) {
               file2 = file2.split(path22.win32.sep).join(path22.posix.sep);
               const route = prefix + file2;
-              if (routes35.has(route)) {
+              if (routes34.has(route)) {
                 continue;
               }
-              routes35.add(route);
+              routes34.add(route);
               setUpHeadAndGet(routeOpts, route, `/${file2}`, rootPath);
               const key2 = path22.posix.basename(route);
               if (indexes.has(key2) && !indexDirs.has(key2)) {
@@ -105747,7 +105747,7 @@ var require_static = __commonJS({
         throw err;
       }
     }
-    module.exports = fp36(fastifyStatic2, {
+    module.exports = fp35(fastifyStatic2, {
       fastify: "5.x",
       name: "@fastify/static"
     });
@@ -112390,7 +112390,7 @@ var require_websocket2 = __commonJS({
     var { ServerResponse } = __require("node:http");
     var { PassThrough } = __require("node:stream");
     var { randomBytes: randomBytes3 } = __require("node:crypto");
-    var fp36 = require_plugin2();
+    var fp35 = require_plugin2();
     var WebSocket2 = require_ws();
     var Duplexify = require_duplexify();
     var kWs = /* @__PURE__ */ Symbol("ws-socket");
@@ -112576,7 +112576,7 @@ var require_websocket2 = __commonJS({
       }
       next();
     }
-    module.exports = fp36(fastifyWebsocket2, {
+    module.exports = fp35(fastifyWebsocket2, {
       fastify: "5.x",
       name: "@fastify/websocket"
     });
@@ -115020,7 +115020,7 @@ var require_multipart2 = __commonJS({
     "use strict";
     var Busboy = require_main();
     var os2 = __require("node:os");
-    var fp36 = require_plugin2();
+    var fp35 = require_plugin2();
     var { createWriteStream: createWriteStream2 } = __require("node:fs");
     var { unlink: unlink2 } = __require("node:fs/promises");
     var path22 = __require("node:path");
@@ -115469,7 +115469,7 @@ var require_multipart2 = __commonJS({
         }
       });
     }
-    module.exports = fp36(fastifyMultipart2, {
+    module.exports = fp35(fastifyMultipart2, {
       fastify: "5.x",
       name: "@fastify/multipart"
     });
@@ -169021,11 +169021,11 @@ function buildCommand(builderArgs) {
     }
   };
 }
-function* generateRouteMapHelpLines(routes35, docs, args) {
+function* generateRouteMapHelpLines(routes34, docs, args) {
   const { brief, fullDescription, hideRoute } = docs;
   const { headers } = args.text;
   yield args.ansiColor ? `\x1B[1m${headers.usage}\x1B[22m` : headers.usage;
-  for (const [name25, route] of Object.entries(routes35)) {
+  for (const [name25, route] of Object.entries(routes34)) {
     if (!hideRoute || !hideRoute[name25] || args.includeHidden) {
       const externalRouteName = args.config.caseStyle === "convert-camel-to-kebab" ? convertCamelCaseToKebabCase(name25) : name25;
       yield `  ${route.formatUsageLine({
@@ -169055,7 +169055,7 @@ function* generateRouteMapHelpLines(routes35, docs, args) {
   }
   yield "";
   yield args.ansiColor ? `\x1B[1m${headers.commands}\x1B[22m` : headers.commands;
-  const visibleRoutes = Object.entries(routes35).filter(
+  const visibleRoutes = Object.entries(routes34).filter(
     ([name25]) => !hideRoute || !hideRoute[name25] || args.includeHidden
   );
   const rows = visibleRoutes.map(([internalRouteName, route]) => {
@@ -169083,24 +169083,24 @@ function* generateRouteMapHelpLines(routes35, docs, args) {
   }
 }
 function buildRouteMap({
-  routes: routes35,
+  routes: routes34,
   defaultCommand: defaultCommandRoute,
   docs,
   aliases
 }) {
-  if (Object.entries(routes35).length === 0) {
+  if (Object.entries(routes34).length === 0) {
     throw new InternalError("Route map must contain at least one route");
   }
   const activeAliases = aliases ?? {};
   const aliasesByRoute = /* @__PURE__ */ new Map();
   for (const [alias, routeName] of Object.entries(activeAliases)) {
-    if (alias in routes35) {
+    if (alias in routes34) {
       throw new InternalError(`Cannot use "${alias}" as an alias when a route with that name already exists`);
     }
     const routeAliases = aliasesByRoute.get(routeName) ?? [];
     aliasesByRoute.set(routeName, [...routeAliases, alias]);
   }
-  const defaultCommand = defaultCommandRoute ? routes35[defaultCommandRoute] : void 0;
+  const defaultCommand = defaultCommandRoute ? routes34[defaultCommandRoute] : void 0;
   if (defaultCommand && defaultCommand.kind === RouteMapSymbol) {
     throw new InternalError(
       `Cannot use "${defaultCommandRoute}" as the default command because it is not a Command`
@@ -169109,7 +169109,7 @@ function buildRouteMap({
   const resolveRouteName = (input) => {
     if (input in activeAliases) {
       return activeAliases[input];
-    } else if (input in routes35) {
+    } else if (input in routes34) {
       return input;
     }
   };
@@ -169127,7 +169127,7 @@ function buildRouteMap({
       return `${args.prefix.join(" ")} ${routeNames.join("|")} ...`;
     },
     formatHelp: (config2) => {
-      const lines = [...generateRouteMapHelpLines(routes35, docs, config2)];
+      const lines = [...generateRouteMapHelpLines(routes34, docs, config2)];
       const text2 = lines.join("\n");
       return text2 + "\n";
     },
@@ -169170,11 +169170,11 @@ function buildRouteMap({
     },
     getRoutingTargetForInput: (input) => {
       const routeName = input in activeAliases ? activeAliases[input] : input;
-      return routes35[routeName];
+      return routes34[routeName];
     },
     getAllEntries() {
       const hiddenRoutes = docs.hideRoute;
-      return Object.entries(routes35).map(([originalRouteName, target]) => {
+      return Object.entries(routes34).map(([originalRouteName, target]) => {
         return {
           name: {
             original: originalRouteName,
@@ -186340,10 +186340,6 @@ var createRemoteServerRepos = (kdb, _h) => ({
 // src/storage/repositories/executors.ts
 var mapExecutor = (row) => ({
   ...row,
-  // The DB column is nullable (legacy DDL), but every real caller supplies a
-  // group_id (routes/executor-routes.ts requires it; scheduler.ts/
-  // process-routes.ts pass ""), so this never actually surfaces null.
-  group_id: row.group_id ?? "",
   executor_type: row.executor_type || "command",
   prompt_provider: row.prompt_provider ?? null,
   pty: fromDbBool(row.pty),
@@ -186367,49 +186363,19 @@ var mapRemoteExecutorProcess = (row) => ({
   machine_id: row.machine_id
 });
 var createExecutorRepos = (kdb, h) => ({
-  executorGroups: {
-    create: async ({ id, project_id, name: name25, branch }) => {
-      await kdb.insertInto("executor_groups").values({ id, project_id, name: name25, branch }).execute();
-      const row = await kdb.selectFrom("executor_groups").selectAll().where("id", "=", id).executeTakeFirstOrThrow();
-      return row;
-    },
-    getByProjectId: async (projectId) => {
-      return kdb.selectFrom("executor_groups").selectAll().where("project_id", "=", projectId).orderBy("created_at", "asc").execute();
-    },
-    getById: async (id) => {
-      return kdb.selectFrom("executor_groups").selectAll().where("id", "=", id).executeTakeFirst();
-    },
-    getByBranch: async (projectId, branch) => {
-      return kdb.selectFrom("executor_groups").selectAll().where("project_id", "=", projectId).where("branch", "=", branch).executeTakeFirst();
-    },
-    createIfBranchFree: async ({ id, project_id, name: name25, branch }) => {
-      const result = await kdb.insertInto("executor_groups").values({ id, project_id, name: name25, branch }).onConflict((oc) => oc.columns(["project_id", "branch"]).doNothing()).executeTakeFirst();
-      const group2 = await kdb.selectFrom("executor_groups").selectAll().where("project_id", "=", project_id).where("branch", "=", branch).executeTakeFirstOrThrow();
-      return { created: (result?.numInsertedOrUpdatedRows ?? 0n) > 0n, group: group2 };
-    },
-    update: async (id, opts) => {
-      if (opts.name !== void 0) {
-        await kdb.updateTable("executor_groups").set({ name: opts.name }).where("id", "=", id).execute();
-      }
-      return kdb.selectFrom("executor_groups").selectAll().where("id", "=", id).executeTakeFirst();
-    },
-    delete: async (id) => {
-      await kdb.deleteFrom("executor_groups").where("id", "=", id).execute();
-    }
-  },
   executors: {
-    create: async ({ id, project_id, group_id, name: name25, command, executor_type, prompt_provider, cwd, pty: pty2 }) => {
+    create: async ({ id, project_id, workspace_id, name: name25, command, executor_type, prompt_provider, cwd, pty: pty2 }) => {
       await kdb.insertInto("executors").values((eb) => ({
         id,
         project_id,
-        group_id,
+        workspace_id,
         name: name25,
         command,
         executor_type: executor_type ?? "command",
         prompt_provider: prompt_provider ?? null,
         cwd: cwd ?? null,
         pty: h.toDbBool(pty2 !== false),
-        position: eb.selectFrom("executors").select(sql`coalesce(max(position), -1) + 1`.as("next_position")).where("group_id", "=", group_id)
+        position: eb.selectFrom("executors").select(sql`coalesce(max(position), -1) + 1`.as("next_position")).where("workspace_id", "=", workspace_id)
       })).execute();
       const row = await kdb.selectFrom("executors").selectAll().where("id", "=", id).executeTakeFirstOrThrow();
       return mapExecutor(row);
@@ -186418,8 +186384,8 @@ var createExecutorRepos = (kdb, h) => ({
       const rows = await kdb.selectFrom("executors").selectAll().where("project_id", "=", projectId).orderBy("position", "asc").execute();
       return rows.map(mapExecutor);
     },
-    getByGroupId: async (groupId) => {
-      const rows = await kdb.selectFrom("executors").selectAll().where("group_id", "=", groupId).orderBy("position", "asc").execute();
+    getByWorkspaceId: async (workspaceId) => {
+      const rows = await kdb.selectFrom("executors").selectAll().where("workspace_id", "=", workspaceId).orderBy("position", "asc").execute();
       return rows.map(mapExecutor);
     },
     getById: async (id) => {
@@ -186456,10 +186422,10 @@ var createExecutorRepos = (kdb, h) => ({
     delete: async (id) => {
       await kdb.deleteFrom("executors").where("id", "=", id).execute();
     },
-    reorder: async (groupId, orderedIds) => {
+    reorder: async (workspaceId, orderedIds) => {
       await kdb.transaction().execute(async (trx) => {
         for (let i = 0; i < orderedIds.length; i++) {
-          await trx.updateTable("executors").set({ position: i }).where("id", "=", orderedIds[i]).where("group_id", "=", groupId).execute();
+          await trx.updateTable("executors").set({ position: i }).where("id", "=", orderedIds[i]).where("workspace_id", "=", workspaceId).execute();
         }
       });
     }
@@ -203469,6 +203435,14 @@ var createWorkspaceRegistryRepo = (kdb, h) => ({
         }
       };
     },
+    getWorkspaceById: async (workspaceId) => {
+      const row = await kdb.selectFrom("workspaces").selectAll().where("id", "=", workspaceId).executeTakeFirst();
+      return row ? mapWorkspace(row) : void 0;
+    },
+    getWorkspaceByProjectBranch: async (projectId, branch) => {
+      const row = await kdb.selectFrom("workspaces").selectAll().where("project_id", "=", projectId).where("branch", "=", branch).executeTakeFirst();
+      return row ? mapWorkspace(row) : void 0;
+    },
     markCheckoutDeleted: async (checkoutId) => {
       await kdb.transaction().execute(async (trx) => {
         const checkout = await trx.selectFrom("workspace_checkouts").select(["workspace_id", "deleted_at"]).where("id", "=", checkoutId).executeTakeFirst();
@@ -203730,20 +203704,10 @@ var createDatabase = (dbPath) => {
     CREATE INDEX IF NOT EXISTS idx_project_chat_operations_thread_status_created_id
       ON project_chat_operations(thread_id, status, created_at, id);
 
-    CREATE TABLE IF NOT EXISTS executor_groups (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      name TEXT NOT NULL,
-      branch TEXT NOT NULL DEFAULT '',
-      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE(project_id, branch),
-      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-    );
-
     CREATE TABLE IF NOT EXISTS executors (
       id TEXT PRIMARY KEY,
       project_id TEXT NOT NULL,
-      group_id TEXT,
+      workspace_id TEXT NOT NULL,
       name TEXT NOT NULL,
       command TEXT NOT NULL,
       executor_type TEXT DEFAULT 'command',
@@ -203754,7 +203718,7 @@ var createDatabase = (dbPath) => {
       disabled_targets TEXT DEFAULT '[]',
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
-      FOREIGN KEY (group_id) REFERENCES executor_groups(id) ON DELETE CASCADE
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
     );
 
     CREATE TABLE IF NOT EXISTS executor_processes (
@@ -204265,31 +204229,6 @@ var createDatabase = (dbPath) => {
     db.exec("CREATE INDEX IF NOT EXISTS idx_projects_user_id ON projects(user_id)");
   }
   db.exec("UPDATE projects SET user_id = 'local' WHERE user_id = ''");
-  const hasGroupIdColumn = tableInfo.some((col) => col.name === "group_id");
-  if (!hasGroupIdColumn) {
-    db.exec(`
-      CREATE TABLE IF NOT EXISTS executor_groups (
-        id TEXT PRIMARY KEY,
-        project_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        branch TEXT NOT NULL DEFAULT '',
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        UNIQUE(project_id, branch),
-        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
-      )
-    `);
-    db.exec("ALTER TABLE executors ADD COLUMN group_id TEXT REFERENCES executor_groups(id) ON DELETE CASCADE");
-    const projects = db.prepare("SELECT DISTINCT project_id FROM executors").all();
-    for (const { project_id } of projects) {
-      const groupId = `default-${project_id}`;
-      db.prepare(
-        "INSERT OR IGNORE INTO executor_groups (id, project_id, name, branch) VALUES (@id, @project_id, 'Default', '')"
-      ).run({ id: groupId, project_id });
-      db.prepare(
-        "UPDATE executors SET group_id = @group_id WHERE project_id = @project_id AND group_id IS NULL"
-      ).run({ group_id: groupId, project_id });
-    }
-  }
   const taskTableInfo = db.prepare("PRAGMA table_info(tasks)").all();
   const hasAssignedBranchColumn = taskTableInfo.some((col) => col.name === "assigned_branch");
   if (!hasAssignedBranchColumn) {
@@ -205115,6 +205054,79 @@ var createDatabase = (dbPath) => {
     db.prepare(`DELETE FROM global_settings WHERE key IN (${placeholders})`).run(...USER_LEVEL_KEYS);
   });
   migrateUserSettings();
+  const executorColsForWorkspace = db.prepare("PRAGMA table_info(executors)").all();
+  if (executorColsForWorkspace.some((col) => col.name === "group_id")) {
+    db.transaction(() => {
+      const ensureWorkspace = db.prepare(
+        `INSERT INTO workspaces (id, project_id, branch, status, error)
+         VALUES (@id, @project_id, @branch, 'archived', NULL)
+         ON CONFLICT(project_id, branch) DO NOTHING`
+      );
+      const groups = db.prepare(`
+        SELECT DISTINCT g.project_id AS project_id, g.branch AS branch
+          FROM executor_groups g
+          JOIN executors e ON e.group_id = g.id
+          JOIN projects p ON p.id = g.project_id
+      `).all();
+      for (const group2 of groups) {
+        ensureWorkspace.run({ id: crypto5.randomUUID(), project_id: group2.project_id, branch: group2.branch });
+      }
+      const orphanProjects = db.prepare(`
+        SELECT DISTINCT e.project_id AS project_id
+          FROM executors e
+          JOIN projects p ON p.id = e.project_id
+         WHERE e.group_id IS NULL
+            OR NOT EXISTS (SELECT 1 FROM executor_groups g WHERE g.id = e.group_id)
+      `).all();
+      for (const { project_id } of orphanProjects) {
+        ensureWorkspace.run({ id: crypto5.randomUUID(), project_id, branch: "" });
+      }
+      db.exec(`
+        CREATE TABLE executors_workspace_new (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL,
+          workspace_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          command TEXT NOT NULL,
+          executor_type TEXT DEFAULT 'command',
+          prompt_provider TEXT,
+          cwd TEXT,
+          pty INTEGER DEFAULT 1,
+          position INTEGER DEFAULT 0,
+          disabled_targets TEXT DEFAULT '[]',
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+          FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+        );
+
+        INSERT INTO executors_workspace_new
+          (id, project_id, workspace_id, name, command, executor_type,
+           prompt_provider, cwd, pty, position, disabled_targets, created_at)
+        SELECT e.id, e.project_id, w.id, e.name, e.command, e.executor_type,
+               e.prompt_provider, e.cwd, e.pty,
+               ROW_NUMBER() OVER (
+                 PARTITION BY w.id ORDER BY e.position, e.created_at, e.id
+               ) - 1,
+               e.disabled_targets, e.created_at
+          FROM executors e
+          LEFT JOIN executor_groups g ON g.id = e.group_id
+          JOIN workspaces w
+            ON w.project_id = e.project_id AND w.branch = COALESCE(g.branch, '');
+      `);
+      const dropped = db.prepare(
+        "SELECT COUNT(*) AS n FROM executors WHERE id NOT IN (SELECT id FROM executors_workspace_new)"
+      ).get().n;
+      if (dropped > 0) {
+        console.warn(`[storage] executor\u2192workspace migration skipped ${dropped} executor(s) with no surviving project`);
+      }
+      db.exec(`
+        DROP TABLE executors;
+        ALTER TABLE executors_workspace_new RENAME TO executors;
+        DROP TABLE IF EXISTS executor_groups;
+      `);
+    })();
+  }
+  db.exec("CREATE INDEX IF NOT EXISTS idx_executors_workspace ON executors(workspace_id, position)");
   db.pragma("foreign_keys = ON");
   return db;
 };
@@ -206342,6 +206354,92 @@ ${GREEN}Done${info}${RESET}
     }
     return terminals;
   }
+  /**
+   * Running processes — executor runs and interactive terminals alike — whose
+   * working directory is `root` or below it. Used to clear a worktree before
+   * it is deleted out from under them.
+   *
+   * Matching is by cwd rather than by branch on purpose: only terminals carry
+   * a `branch`, executor runs are always recorded with `branch: null`, and on
+   * a reverse-connect worker they are path-based with no executor row to join
+   * through. The cwd is the one identity every spawn path records.
+   */
+  getRunningProcessIdsUnderPath(root) {
+    const resolvedRoot = path5.resolve(root);
+    const ids = [];
+    for (const [id, proc] of this.processes) {
+      const relative = path5.relative(resolvedRoot, path5.resolve(proc.projectPath));
+      const outside = relative === ".." || relative.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative);
+      if (relative !== "" && outside) continue;
+      if (this.isRunning(id)) ids.push(id);
+    }
+    return ids;
+  }
+  /**
+   * True once the tracked process has genuinely exited (or is no longer
+   * tracked at all).
+   *
+   * Deliberately not `!isRunning()`: that helper treats `ChildProcess.killed`
+   * as exited, and Node sets `killed` the moment a signal is *delivered*, so
+   * it would report success while the process is still winding down. Real
+   * exit is only observable through `exitCode`/`signalCode` for a child, or
+   * the "finished" log the PTY exit handler appends.
+   */
+  hasExited(processId) {
+    const runningProcess = this.processes.get(processId);
+    if (!runningProcess) return true;
+    if (runningProcess.isPty) {
+      return runningProcess.logs[runningProcess.logs.length - 1]?.type === "finished";
+    }
+    const childProcess2 = runningProcess.process;
+    return childProcess2.exitCode !== null || childProcess2.signalCode !== null;
+  }
+  async waitForExit(processId, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (!this.hasExited(processId)) {
+      if (Date.now() >= deadline) return false;
+      await new Promise((resolve3) => setTimeout(resolve3, 25));
+    }
+    return true;
+  }
+  signalProcessGroup(processId, signal) {
+    const runningProcess = this.processes.get(processId);
+    if (!runningProcess) return;
+    const pid = runningProcess.isPty ? runningProcess.process.pid : runningProcess.process.pid;
+    if (!pid) return;
+    try {
+      process.kill(-pid, signal);
+    } catch {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Stop a process and confirm it actually exited, escalating to SIGKILL when
+   * SIGTERM is ignored. Returns false if it is still alive after that.
+   *
+   * `stop()` alone is not enough for a caller that needs the working directory
+   * to be free — deleting a worktree — because it reports only that a signal
+   * was delivered. SIGTERM is asynchronous and can be trapped or ignored, so
+   * the process may still be writing into the tree when `stop()` resolves.
+   *
+   * What this confirms is the exit of the tracked process, and with it
+   * whatever else shared its process group. A grandchild that detached into
+   * its own group or session is not observable here and is not covered.
+   */
+  async stopAndWait(processId, opts) {
+    await this.stop(processId);
+    if (await this.waitForExit(processId, opts?.termGraceMs ?? 3e3)) return true;
+    console.warn(`[ProcessManager] Process ${processId} ignored SIGTERM, escalating to SIGKILL`);
+    this.signalProcessGroup(processId, "SIGKILL");
+    const exited = await this.waitForExit(processId, opts?.killGraceMs ?? 2e3);
+    if (!exited) {
+      console.error(`[ProcessManager] Process ${processId} survived SIGKILL \u2014 cannot confirm exit`);
+    }
+    return exited;
+  }
   /**
    * Get all processes for a given executor ID with their status and logs
    */
@@ -207414,8 +207512,12 @@ function reconcileWorktreeBranches(projectPath, entries, sessionBranches = [], r
   }
   const rootEntry = entries[0];
   const rootAnchor = rootEntry ? registryByPath.get(path6.resolve(rootEntry.path)) : void 0;
-  const rootDrifted = Boolean(rootAnchor) && rootEntry?.branch != null && rootEntry.branch !== rootAnchor.expectedBranch;
-  const worktrees = [rootDrifted ? { branch: null, currentBranch: rootEntry?.branch ?? null } : { branch: null }];
+  const rootExpectedBranch = rootAnchor?.expectedBranch || void 0;
+  const rootDrifted = rootExpectedBranch !== void 0 && rootEntry?.branch != null && rootEntry.branch !== rootExpectedBranch;
+  const root = { branch: null };
+  if (rootExpectedBranch) root.expectedBranch = rootExpectedBranch;
+  if (rootDrifted) root.currentBranch = rootEntry?.branch ?? null;
+  const worktrees = [root];
   for (let i = 1; i < entries.length; i++) {
     const entry = entries[i];
     const anchor = registryByPath.get(path6.resolve(entry.path));
@@ -207462,6 +207564,15 @@ async function getRegisteredWorktreeBranches(storage, projectId, projectPath) {
       if (existing.checkout.status === "creating" || existing.checkout.status === "error") {
         await storage.workspaceRegistry.setCheckoutStatus(existing.checkout.id, "ready");
       }
+      if (index === 0 && existing.checkout.expected_branch === "" && entry.branch) {
+        await storage.workspaceRegistry.registerReadyCheckout({
+          projectId,
+          branch: existing.workspace.branch,
+          targetId: "local",
+          worktreePath: entry.path,
+          expectedBranch: entry.branch
+        });
+      }
       continue;
     }
     if (registeredPaths.has(resolvedPath) || entry.branch === null && index > 0) continue;
@@ -230148,6 +230259,16 @@ var AgentSessionManager = class {
     }
     return results;
   }
+  /**
+   * Ids of the sessions in one workspace that still own a live child process,
+   * whatever their turn status. Deliberately broader than
+   * `getRunningResidentProcesses`, which also demands `status === "running"`:
+   * a resident process idling between turns is exactly the one that would be
+   * orphaned when its worktree is deleted.
+   */
+  getLiveSessionIdsForBranch(projectId, branch) {
+    return [...this.sessions.values()].filter((session) => session.projectId === projectId && session.branch === branch && this.isProcessAlive(session)).map((session) => session.id);
+  }
   /**
    * Check if a session is running
    */
@@ -230160,8 +230281,11 @@ var AgentSessionManager = class {
    * (like pressing ESC in Claude Code). The session becomes dormant so the
    * next user message will spawn a fresh process with full context replay.
    * The WebSocket stays alive so the UI remains connected.
+   *
+   * `opts.note` overrides the system entry written into the conversation, for
+   * stops the user did not press Stop for (e.g. the worktree being deleted).
    */
-  async stopSession(sessionId) {
+  async stopSession(sessionId, opts) {
     const session = this.sessions.get(sessionId);
     if (!session) {
       return false;
@@ -230180,7 +230304,7 @@ var AgentSessionManager = class {
       session.store.currentAssistantIndex = null;
       await this.pushEntry(sessionId, {
         type: "system",
-        content: "Session stopped by user.",
+        content: opts?.note ?? "Session stopped by user.",
         timestamp: Date.now()
       });
       await this.endActiveTurn(session, "stopped");
@@ -230204,6 +230328,41 @@ var AgentSessionManager = class {
       return false;
     }
   }
+  /**
+   * Stop a session and confirm its agent process actually exited, escalating
+   * to SIGKILL when SIGTERM is ignored. Returns false if the process is still
+   * alive after that.
+   *
+   * `stopSession` returns as soon as the signal has been sent, which is fine
+   * for the Stop button but not for a caller that is about to delete the
+   * session's working directory: an agent that traps SIGTERM to flush state
+   * would keep writing into a tree that no longer exists.
+   *
+   * Confirms the tracked agent process, and with it whatever else shared its
+   * process group. A grandchild that detached into its own group or session
+   * (an MCP server started with `setsid`, say) is not observable here.
+   */
+  async stopSessionAndWait(sessionId, opts) {
+    const proc = this.sessions.get(sessionId)?.process ?? null;
+    const stopped = await this.stopSession(sessionId, { note: opts?.note });
+    if (!stopped || !proc) return stopped;
+    if (await this.waitForProcessExit(proc, opts?.termGraceMs ?? 3e3)) return true;
+    console.warn(`[AgentSession] Session ${sessionId} ignored SIGTERM, escalating to SIGKILL`);
+    this.killProcess(proc, "SIGKILL");
+    const exited = await this.waitForProcessExit(proc, opts?.killGraceMs ?? 2e3);
+    if (!exited) {
+      console.error(`[AgentSession] Session ${sessionId} survived SIGKILL \u2014 cannot confirm exit`);
+    }
+    return exited;
+  }
+  async waitForProcessExit(proc, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (proc.exitCode === null && proc.signalCode === null) {
+      if (Date.now() >= deadline) return false;
+      await new Promise((resolve3) => setTimeout(resolve3, 25));
+    }
+    return true;
+  }
   async hibernateSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) return false;
@@ -232739,12 +232898,12 @@ var ChatSessionManager = class {
         console.log(`[ChatSession] handleExecutorFinished: executor not found`);
         return;
       }
-      const group2 = await this.storage.executorGroups.getById(executor.group_id);
-      if (!group2) {
-        console.log(`[ChatSession] handleExecutorFinished: group not found for executor.group_id=${executor.group_id}`);
+      const workspace = await this.storage.workspaceRegistry.getWorkspaceById(executor.workspace_id);
+      if (!workspace) {
+        console.log(`[ChatSession] handleExecutorFinished: workspace not found for executor.workspace_id=${executor.workspace_id}`);
         return;
       }
-      const branch = group2.branch || null;
+      const branch = workspace.branch || null;
       const key2 = `${event.projectId}:${branch ?? ""}`;
       const sessionId = this.sessionIndex.get(key2);
       if (!sessionId) {
@@ -233771,11 +233930,11 @@ var ChatSessionManager = class {
           tailLines: external_exports.number().min(1).max(100).default(20).describe("Number of recent output lines to include per executor")
         }),
         execute: async ({ tailLines }) => {
-          const group2 = await storage.executorGroups.getByBranch(projectId, branch ?? "");
-          if (!group2) {
-            return { executors: [], message: "No executor group found for this workspace." };
+          const workspace = await storage.workspaceRegistry.getWorkspaceByProjectBranch(projectId, branch ?? "");
+          if (!workspace) {
+            return { executors: [], message: "No workspace found for this branch." };
           }
-          const executors = await storage.executors.getByGroupId(group2.id);
+          const executors = await storage.executors.getByWorkspaceId(workspace.id);
           const now3 = Date.now();
           const results = await Promise.all(executors.map(async (executor) => {
             const lastRow = await storage.executorProcesses.getLastByExecutorId(executor.id);
@@ -233817,11 +233976,11 @@ var ChatSessionManager = class {
           remote: external_exports.string().optional().describe("Remote server name or ID to run the executor on. If omitted, uses project executor_mode or runs locally.")
         }),
         execute: async ({ executorName, remote }) => {
-          const group2 = await storage.executorGroups.getByBranch(projectId, branch ?? "");
-          if (!group2) {
-            return { success: false, message: "No executor group found for this workspace." };
+          const workspace = await storage.workspaceRegistry.getWorkspaceByProjectBranch(projectId, branch ?? "");
+          if (!workspace) {
+            return { success: false, message: "No workspace found for this branch." };
           }
-          const executors = await storage.executors.getByGroupId(group2.id);
+          const executors = await storage.executors.getByWorkspaceId(workspace.id);
           const executor = executors.find(
             (e) => e.name.toLowerCase() === executorName.toLowerCase()
           );
@@ -233957,11 +234116,11 @@ var ChatSessionManager = class {
           remote: external_exports.string().optional().describe("Remote server name or ID where the executor is running. If omitted, auto-detects.")
         }),
         execute: async ({ executorName, remote }) => {
-          const group2 = await storage.executorGroups.getByBranch(projectId, branch ?? "");
-          if (!group2) {
-            return { success: false, message: "No executor group found for this workspace." };
+          const workspace = await storage.workspaceRegistry.getWorkspaceByProjectBranch(projectId, branch ?? "");
+          if (!workspace) {
+            return { success: false, message: "No workspace found for this branch." };
           }
-          const executors = await storage.executors.getByGroupId(group2.id);
+          const executors = await storage.executors.getByWorkspaceId(workspace.id);
           const executor = executors.find(
             (e) => e.name.toLowerCase() === executorName.toLowerCase()
           );
@@ -239679,7 +239838,7 @@ var SchedulerService = class {
     const executor = {
       id: `schedule-${task.id}`,
       project_id: task.project_id,
-      group_id: "",
+      workspace_id: "",
       name: task.name,
       command: buildRunContent(task),
       executor_type: task.run_type,
@@ -241459,91 +241618,15 @@ var routes5 = async (fastify2) => {
 };
 var project_remote_routes_default = (0, import_fastify_plugin6.default)(routes5, { name: "project-remote-routes" });
 
-// src/routes/executor-group-routes.ts
+// src/routes/executor-routes.ts
 var import_fastify_plugin7 = __toESM(require_plugin2(), 1);
 import { randomUUID as randomUUID11 } from "crypto";
-var routes6 = async (fastify2) => {
-  fastify2.get(
-    "/api/projects/:projectId/executor-groups",
-    async (req, reply) => {
-      const userId = requireUserFacingUserId(req, reply);
-      if (userId === null) return;
-      const project = await fastify2.storage.projects.getById(req.params.projectId, userId);
-      if (!project) {
-        return reply.code(404).send({ error: "Project not found" });
-      }
-      const groups = await fastify2.storage.executorGroups.getByProjectId(req.params.projectId);
-      return reply.code(200).send({ groups });
-    }
-  );
-  fastify2.get(
-    "/api/projects/:projectId/executor-groups/by-branch",
-    async (req, reply) => {
-      const userId = requireUserFacingUserId(req, reply);
-      if (userId === null) return;
-      const project = await fastify2.storage.projects.getById(req.params.projectId, userId);
-      if (!project) {
-        return reply.code(404).send({ error: "Project not found" });
-      }
-      const branch = req.query.branch ?? "";
-      const group2 = await fastify2.storage.executorGroups.getByBranch(req.params.projectId, branch);
-      if (!group2) {
-        return reply.code(404).send({ error: "Executor group not found for this branch" });
-      }
-      return reply.code(200).send({ group: group2 });
-    }
-  );
-  fastify2.post("/api/projects/:projectId/executor-groups", async (req, reply) => {
-    const userId = requireUserFacingUserId(req, reply);
-    if (userId === null) return;
-    const project = await fastify2.storage.projects.getById(req.params.projectId, userId);
-    if (!project) {
-      return reply.code(404).send({ error: "Project not found" });
-    }
-    const { name: name25, branch } = req.body;
-    const id = randomUUID11();
-    const result = await fastify2.storage.executorGroups.createIfBranchFree({
-      id,
-      project_id: req.params.projectId,
-      name: name25,
-      branch
-    });
-    if (!result.created) {
-      return reply.code(409).send({ error: "An executor group already exists for this branch" });
-    }
-    return reply.code(201).send({ group: result.group });
-  });
-  fastify2.put("/api/executor-groups/:id", async (req, reply) => {
-    const existing = await fastify2.storage.executorGroups.getById(req.params.id);
-    if (!existing) {
-      return reply.code(404).send({ error: "Executor group not found" });
-    }
-    const group2 = await fastify2.storage.executorGroups.update(req.params.id, req.body);
-    return reply.code(200).send({ group: group2 });
-  });
-  fastify2.delete(
-    "/api/executor-groups/:id",
-    async (req, reply) => {
-      const existing = await fastify2.storage.executorGroups.getById(req.params.id);
-      if (!existing) {
-        return reply.code(404).send({ error: "Executor group not found" });
-      }
-      await fastify2.storage.executorGroups.delete(req.params.id);
-      return reply.code(200).send({ success: true });
-    }
-  );
-};
-var executor_group_routes_default = (0, import_fastify_plugin7.default)(routes6, { name: "executor-group-routes" });
-
-// src/routes/executor-routes.ts
-var import_fastify_plugin8 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID12 } from "crypto";
 function normalizeSqlTimestamp(value) {
   if (!value) return null;
   if (value.includes("T") && /(Z|[+-]\d{2}:?\d{2})$/.test(value)) return value;
   return value.replace(" ", "T") + "Z";
 }
-var routes7 = async (fastify2) => {
+var routes6 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/executors",
     async (req, reply) => {
@@ -241553,7 +241636,16 @@ var routes7 = async (fastify2) => {
       if (!project) {
         return reply.code(404).send({ error: "Project not found" });
       }
-      const executors = req.query.groupId ? await fastify2.storage.executors.getByGroupId(req.query.groupId) : await fastify2.storage.executors.getByProjectId(req.params.projectId);
+      let executors;
+      if (req.query.branch === void 0) {
+        executors = await fastify2.storage.executors.getByProjectId(req.params.projectId);
+      } else {
+        const workspace = await fastify2.storage.workspaceRegistry.getWorkspaceByProjectBranch(
+          req.params.projectId,
+          req.query.branch
+        );
+        executors = workspace ? await fastify2.storage.executors.getByWorkspaceId(workspace.id) : [];
+      }
       const executorIds = executors.map((e) => e.id);
       const hasLocal = !!project.path;
       const hasRemotes = (await fastify2.storage.projectRemotes.getByProject(req.params.projectId)).length > 0;
@@ -241595,17 +241687,24 @@ var routes7 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const { name: name25, command, executor_type, prompt_provider, cwd, pty: pty2, group_id } = req.body;
-    if (!group_id) {
-      return reply.code(400).send({ error: "group_id is required" });
+    const { name: name25, command, executor_type, prompt_provider, cwd, pty: pty2, branch } = req.body;
+    if (branch === void 0) {
+      return reply.code(400).send({ error: "branch is required" });
+    }
+    const workspace = await fastify2.storage.workspaceRegistry.getWorkspaceByProjectBranch(
+      req.params.projectId,
+      branch
+    );
+    if (!workspace) {
+      return reply.code(400).send({ error: "No workspace for this branch" });
     }
     const parsedType2 = executor_type === "prompt" ? "prompt" : "command";
     const parsedProvider = prompt_provider === "codex" ? "codex" : "claude";
-    const id = randomUUID12();
+    const id = randomUUID11();
     const executor = await fastify2.storage.executors.create({
       id,
       project_id: req.params.projectId,
-      group_id,
+      workspace_id: workspace.id,
       name: name25,
       command,
       executor_type: parsedType2,
@@ -241664,31 +241763,38 @@ var routes7 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const { orderedIds, groupId } = req.body;
+    const { orderedIds, branch } = req.body;
     if (!Array.isArray(orderedIds)) {
       return reply.code(400).send({ error: "orderedIds must be an array" });
     }
-    if (!groupId) {
-      return reply.code(400).send({ error: "groupId is required" });
+    if (branch === void 0) {
+      return reply.code(400).send({ error: "branch is required" });
     }
-    const existingExecutors = await fastify2.storage.executors.getByGroupId(groupId);
+    const workspace = await fastify2.storage.workspaceRegistry.getWorkspaceByProjectBranch(
+      req.params.projectId,
+      branch
+    );
+    if (!workspace) {
+      return reply.code(400).send({ error: "No workspace for this branch" });
+    }
+    const existingExecutors = await fastify2.storage.executors.getByWorkspaceId(workspace.id);
     const existingIds = new Set(existingExecutors.map((e) => e.id));
     for (const id of orderedIds) {
       if (!existingIds.has(id)) {
-        return reply.code(400).send({ error: `Executor ${id} not found in group` });
+        return reply.code(400).send({ error: `Executor ${id} not found in workspace` });
       }
     }
-    await fastify2.storage.executors.reorder(groupId, orderedIds);
+    await fastify2.storage.executors.reorder(workspace.id, orderedIds);
     return reply.code(200).send({ success: true });
   });
 };
-var executor_routes_default = (0, import_fastify_plugin8.default)(routes7, { name: "executor-routes" });
+var executor_routes_default = (0, import_fastify_plugin7.default)(routes6, { name: "executor-routes" });
 
 // src/routes/process-routes.ts
-var import_fastify_plugin9 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin8 = __toESM(require_plugin2(), 1);
 import path9 from "path";
-import { randomUUID as randomUUID13 } from "crypto";
-var routes8 = async (fastify2) => {
+import { randomUUID as randomUUID12 } from "crypto";
+var routes7 = async (fastify2) => {
   fastify2.post("/api/path/execute", async (req, reply) => {
     const userId = requireAuth(req, reply);
     if (userId === null) return;
@@ -241705,9 +241811,9 @@ var routes8 = async (fastify2) => {
     const resolvedBase = resolveWorktreePath(projectPath, branch ?? null);
     const resolvedCwd = cwd ? path9.join(resolvedBase, cwd) : null;
     const tempExecutor = {
-      id: randomUUID13(),
+      id: randomUUID12(),
       project_id: project.id,
-      group_id: "",
+      workspace_id: "",
       name: "remote-command",
       command,
       executor_type: executor_type === "prompt" ? "prompt" : "command",
@@ -241737,7 +241843,11 @@ var routes8 = async (fastify2) => {
     if (!project) {
       return reply.code(404).send({ error: "Project not found" });
     }
-    const branch = req.body?.branch;
+    const workspace = await fastify2.storage.workspaceRegistry.getWorkspaceById(executor.workspace_id);
+    if (!workspace) {
+      return reply.code(400).send({ error: "Executor's workspace no longer exists" });
+    }
+    const branch = workspace.branch || null;
     let executorMode = req.body?.target || project.executor_mode;
     let useRemoteExecutor = executorMode !== "local";
     if (useRemoteExecutor && executorMode === "remote") {
@@ -241900,10 +242010,10 @@ var routes8 = async (fastify2) => {
     return reply.code(200).send({ processes });
   });
 };
-var process_routes_default = (0, import_fastify_plugin9.default)(routes8, { name: "process-routes" });
+var process_routes_default = (0, import_fastify_plugin8.default)(routes7, { name: "process-routes" });
 
 // src/routes/worktree-routes.ts
-var import_fastify_plugin10 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin9 = __toESM(require_plugin2(), 1);
 import { mkdir as mkdir3 } from "fs/promises";
 
 // src/utils/path-project.ts
@@ -241949,7 +242059,37 @@ async function syncRemoteWorktreeList(fastify2, projectId, remote, data) {
     worktrees
   });
 }
-var routes9 = async (fastify2) => {
+var WorktreeBusyError = class extends Error {
+};
+async function stopWorkspaceActivity(fastify2, opts) {
+  const sessionIds = [...new Set(
+    opts.projectIds.filter((id) => Boolean(id)).flatMap((id) => fastify2.agentSessionManager.getLiveSessionIdsForBranch(id, opts.branch))
+  )];
+  const processIds = fastify2.processManager.getRunningProcessIdsUnderPath(opts.worktreePath);
+  if (sessionIds.length === 0 && processIds.length === 0) return;
+  const survivors = [];
+  const confirm = async (label, stop) => {
+    try {
+      if (!await stop()) survivors.push(label);
+    } catch (error48) {
+      console.error(`[worktree] Failed to stop ${label} before delete:`, error48);
+      survivors.push(label);
+    }
+  };
+  await Promise.all(sessionIds.map((sessionId) => confirm(`session ${sessionId}`, () => fastify2.agentSessionManager.stopSessionAndWait(sessionId, {
+    note: "Session stopped: its worktree is being deleted."
+  }))));
+  await Promise.all(processIds.map((processId) => confirm(`process ${processId}`, () => fastify2.processManager.stopAndWait(processId))));
+  if (survivors.length > 0) {
+    throw new WorktreeBusyError(
+      `Worktree still has running work that could not be stopped (${survivors.join(", ")}). Nothing was deleted; retry in a moment.`
+    );
+  }
+  console.log(
+    `[worktree] Stopped ${sessionIds.length} session(s) and ${processIds.length} process(es) in ${opts.worktreePath}`
+  );
+}
+var routes8 = async (fastify2) => {
   fastify2.get("/api/path/branches", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -242083,6 +242223,11 @@ var routes9 = async (fastify2) => {
         }
       } catch {
       }
+      await stopWorkspaceActivity(fastify2, {
+        projectIds: [pathProject?.id, `path:${projectPath}`],
+        branch,
+        worktreePath: worktreeAbsPath
+      });
       let branchToDelete = null;
       try {
         const entries = parseGitWorktreeList(projectPath);
@@ -242113,9 +242258,11 @@ var routes9 = async (fastify2) => {
       return reply.code(200).send({ success: true });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
+      const busy = error48 instanceof WorktreeBusyError;
       if (registered && !worktreeRemoved) {
-        await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.checkout.id, "error", errorMessage).catch((registryError) => console.error("[worktree] Failed to record delete error:", registryError));
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.checkout.id, busy ? "ready" : "error", busy ? null : errorMessage).catch((registryError) => console.error("[worktree] Failed to record delete error:", registryError));
       }
+      if (busy) return reply.code(409).send({ error: errorMessage });
       return reply.code(500).send({ error: `Failed to delete worktree: ${errorMessage}` });
     }
   });
@@ -242325,6 +242472,11 @@ var routes9 = async (fastify2) => {
         } catch (err) {
           if (err instanceof Error && err.message.includes("uncommitted changes")) throw err;
         }
+        await stopWorkspaceActivity(fastify2, {
+          projectIds: [project.id],
+          branch,
+          worktreePath: worktreeAbsPath
+        });
         let branchToDelete = null;
         try {
           const entries = parseGitWorktreeList(project.path);
@@ -242355,7 +242507,7 @@ var routes9 = async (fastify2) => {
       } catch (error48) {
         if (registered && !worktreeRemoved) {
           const message = error48 instanceof Error ? error48.message : "Local deletion failed";
-          const status = message.includes("uncommitted changes") ? "ready" : "error";
+          const status = message.includes("uncommitted changes") || error48 instanceof WorktreeBusyError ? "ready" : "error";
           await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.checkout.id, status, status === "error" ? message : null).catch((registryError) => console.error("[worktree] Failed to record local delete error:", registryError));
         }
         throw error48;
@@ -242367,7 +242519,7 @@ var routes9 = async (fastify2) => {
         return reply.code(200).send({ success: true });
       } catch (error48) {
         const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
-        if (errorMessage.includes("uncommitted changes")) {
+        if (errorMessage.includes("uncommitted changes") || error48 instanceof WorktreeBusyError) {
           return reply.code(409).send({ error: errorMessage });
         }
         return reply.code(500).send({ error: `Failed to delete worktree: ${errorMessage}` });
@@ -242630,10 +242782,10 @@ var routes9 = async (fastify2) => {
     });
   });
 };
-var worktree_routes_default = (0, import_fastify_plugin10.default)(routes9, { name: "worktree-routes" });
+var worktree_routes_default = (0, import_fastify_plugin9.default)(routes8, { name: "worktree-routes" });
 
 // src/routes/diff-routes.ts
-var import_fastify_plugin11 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin10 = __toESM(require_plugin2(), 1);
 import path10 from "path";
 import { readFileSync as readFileSync4 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
@@ -242941,7 +243093,7 @@ async function getUntrackedFiles(cwd) {
   }
   return files;
 }
-var routes10 = async (fastify2) => {
+var routes9 = async (fastify2) => {
   fastify2.get("/api/path/diff", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -243132,10 +243284,10 @@ var routes10 = async (fastify2) => {
     }
   });
 };
-var diff_routes_default = (0, import_fastify_plugin11.default)(routes10, { name: "diff-routes" });
+var diff_routes_default = (0, import_fastify_plugin10.default)(routes9, { name: "diff-routes" });
 
 // src/routes/file-routes.ts
-var import_fastify_plugin12 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin11 = __toESM(require_plugin2(), 1);
 import path11 from "path";
 import fs2 from "fs/promises";
 import { createReadStream, constants as fsConstants } from "fs";
@@ -243358,7 +243510,7 @@ async function searchSymbol(basePath33, symbol26) {
   }
   return { hits, truncated };
 }
-var routes11 = async (fastify2) => {
+var routes10 = async (fastify2) => {
   fastify2.get("/api/path/browse", async (req, reply) => {
     const projectPath = req.query.path;
     if (!projectPath) {
@@ -243919,17 +244071,17 @@ var routes11 = async (fastify2) => {
     }
   });
 };
-var file_routes_default = (0, import_fastify_plugin12.default)(routes11, { name: "file-routes" });
+var file_routes_default = (0, import_fastify_plugin11.default)(routes10, { name: "file-routes" });
 
 // src/routes/agent-session-routes.ts
-var import_fastify_plugin13 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin12 = __toESM(require_plugin2(), 1);
 
 // src/utils/paste-file.ts
 import { chmod, mkdir as mkdir4, open } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path12 from "node:path";
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 var PASTE_DIR = path12.join(tmpdir2(), "vibedeckx-pastes");
 var DIR_MODE = 448;
 var FILE_MODE = 384;
@@ -243937,7 +244089,7 @@ var FILE_FLAGS = fsConstants2.O_WRONLY | fsConstants2.O_CREAT | fsConstants2.O_E
 async function writePasteToTempFile(content) {
   await mkdir4(PASTE_DIR, { recursive: true, mode: DIR_MODE });
   await chmod(PASTE_DIR, DIR_MODE);
-  const filePath = path12.join(PASTE_DIR, `${randomUUID14()}.txt`);
+  const filePath = path12.join(PASTE_DIR, `${randomUUID13()}.txt`);
   const handle = await open(filePath, FILE_FLAGS, FILE_MODE);
   try {
     await handle.writeFile(content, "utf8");
@@ -244295,7 +244447,7 @@ async function distillConversation(storage, userId, messages, conversation, main
 }
 
 // src/routes/agent-session-routes.ts
-import { createHash as createHash6, randomUUID as randomUUID15 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID14 } from "crypto";
 
 // src/protocol/model-suggestions.ts
 var MODEL_SUGGESTIONS = {
@@ -244320,8 +244472,8 @@ function messageTextLength(content) {
   }
   return n;
 }
-var routes12 = async (fastify2) => {
-  const instructionReceiverToken = randomUUID15();
+var routes11 = async (fastify2) => {
+  const instructionReceiverToken = randomUUID14();
   const instructionDeliveryLocks = /* @__PURE__ */ new Map();
   async function serializeInstructionDelivery(key2, effect) {
     const previous = instructionDeliveryLocks.get(key2) ?? Promise.resolve();
@@ -244976,7 +245128,7 @@ var routes12 = async (fastify2) => {
       return reply.code(400).send({ error: "Project has no local path" });
     }
     try {
-      const preSessionId = randomUUID15();
+      const preSessionId = randomUUID14();
       const crossRemoteMcp = await mintCrossRemoteMcpConfig(
         { storage: fastify2.storage },
         { userId, sessionId: preSessionId, sourceRemoteServerId: null }
@@ -245532,7 +245684,7 @@ var routes12 = async (fastify2) => {
           messages
         });
       }
-      const preSessionId = randomUUID15();
+      const preSessionId = randomUUID14();
       const crossRemoteMcp = await mintCrossRemoteMcpConfig(
         { storage: fastify2.storage },
         { userId, sessionId: preSessionId, sourceRemoteServerId: null }
@@ -245792,10 +245944,10 @@ var routes12 = async (fastify2) => {
     return reply.code(200).send({ success: true, favorited });
   });
 };
-var agent_session_routes_default = (0, import_fastify_plugin13.default)(routes12, { name: "agent-session-routes" });
+var agent_session_routes_default = (0, import_fastify_plugin12.default)(routes11, { name: "agent-session-routes" });
 
 // src/routes/branch-activity-routes.ts
-var import_fastify_plugin14 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin13 = __toESM(require_plugin2(), 1);
 function toResponse(map2) {
   return {
     branches: Array.from(map2.entries()).map(([branch, state]) => ({
@@ -245810,7 +245962,7 @@ function fromResponse(resp) {
     resp.branches.map((b2) => [b2.branch ?? "", { activity: b2.activity, since: b2.since }])
   );
 }
-var routes13 = async (fastify2) => {
+var routes12 = async (fastify2) => {
   function proxyAuto(remoteServerId, method, apiPath, body) {
     return proxyToRemoteAuto(remoteServerId, method, apiPath, body, {
       reverseConnectManager: fastify2.reverseConnectManager
@@ -245875,10 +246027,10 @@ var routes13 = async (fastify2) => {
     }
   );
 };
-var branch_activity_routes_default = (0, import_fastify_plugin14.default)(routes13, { name: "branch-activity-routes" });
+var branch_activity_routes_default = (0, import_fastify_plugin13.default)(routes12, { name: "branch-activity-routes" });
 
 // src/routes/merge-status-routes.ts
-var import_fastify_plugin15 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin14 = __toESM(require_plugin2(), 1);
 function resolveTargets(comparisons, storedTargets) {
   const sources = [];
   const effective = comparisons.map((comparison) => {
@@ -245992,7 +246144,7 @@ function sendComputed(reply, repoPath, comparisons, repository) {
     return reply.code(statusCode).send({ error: message });
   }
 }
-var routes14 = async (fastify2) => {
+var routes13 = async (fastify2) => {
   fastify2.post(
     "/api/path/branches/merge-status",
     async (req, reply) => {
@@ -246114,11 +246266,11 @@ var routes14 = async (fastify2) => {
     }
   );
 };
-var merge_status_routes_default = (0, import_fastify_plugin15.default)(routes14, { name: "merge-status-routes" });
+var merge_status_routes_default = (0, import_fastify_plugin14.default)(routes13, { name: "merge-status-routes" });
 
 // src/routes/chat-session-routes.ts
-var import_fastify_plugin16 = __toESM(require_plugin2(), 1);
-var routes15 = async (fastify2) => {
+var import_fastify_plugin15 = __toESM(require_plugin2(), 1);
+var routes14 = async (fastify2) => {
   const getAuthorizedSession = (req, reply, sessionId) => {
     const authResult = requireUserFacingUserId(req, reply);
     if (authResult === null) return null;
@@ -246223,11 +246375,11 @@ var routes15 = async (fastify2) => {
     return reply.send({ ok: true });
   });
 };
-var chat_session_routes_default = (0, import_fastify_plugin16.default)(routes15, { name: "chat-session-routes" });
+var chat_session_routes_default = (0, import_fastify_plugin15.default)(routes14, { name: "chat-session-routes" });
 
 // src/routes/project-chat-routes.ts
-var import_fastify_plugin17 = __toESM(require_plugin2(), 1);
-import { createHash as createHash7, randomUUID as randomUUID16 } from "crypto";
+var import_fastify_plugin16 = __toESM(require_plugin2(), 1);
+import { createHash as createHash7, randomUUID as randomUUID15 } from "crypto";
 var MAX_TITLE_LENGTH = 200;
 var MAX_MESSAGE_LENGTH = 1e5;
 var THREAD_PAGE_LIMIT = 50;
@@ -246339,7 +246491,7 @@ function parseWorkspaceSelectionBody(body) {
   if (!requestId || requestId.length > MAX_TOOL_SELECTOR_ID || !workspaceId || workspaceId.length > MAX_TOOL_SELECTOR_ID) return null;
   return { requestId, workspaceId };
 }
-var routes16 = async (fastify2) => {
+var routes15 = async (fastify2) => {
   const getOwnedThread = async (req, reply, threadId) => {
     const authResult = requireAuth(req, reply);
     if (authResult === null) return null;
@@ -246395,20 +246547,20 @@ var routes16 = async (fastify2) => {
     if (!project) return reply.code(404).send({ error: "Project not found" });
     const body = parseCreateBody(req.body);
     if (!body) return reply.code(400).send({ error: "Body must contain only an optional non-empty message" });
-    const createRequestId = body.createRequestId ?? randomUUID16();
+    const createRequestId = body.createRequestId ?? randomUUID15();
     const createPayloadHash = createHash7("sha256").update(JSON.stringify({ message: body.message ?? null })).digest("hex");
     let accepted;
     try {
       accepted = await fastify2.storage.projectChatThreads.createIdempotent({
-        id: randomUUID16(),
+        id: randomUUID15(),
         project_id: projectId,
         user_id: userId,
         title: null,
         create_request_id: createRequestId,
         create_payload_hash: createPayloadHash,
         ...body.message !== void 0 ? { initialTurn: {
-          messageId: randomUUID16(),
-          workItemId: randomUUID16(),
+          messageId: randomUUID15(),
+          workItemId: randomUUID15(),
           content: body.message
         } } : {}
       });
@@ -246558,10 +246710,10 @@ var routes16 = async (fastify2) => {
     }
   });
 };
-var project_chat_routes_default = (0, import_fastify_plugin17.default)(routes16, { name: "project-chat-routes" });
+var project_chat_routes_default = (0, import_fastify_plugin16.default)(routes15, { name: "project-chat-routes" });
 
 // src/routes/project-activity-routes.ts
-var import_fastify_plugin18 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin17 = __toESM(require_plugin2(), 1);
 
 // src/project-activity.ts
 var RECENT_THREAD_LIMIT = 5;
@@ -246653,7 +246805,7 @@ async function getProjectActivity(storage, projectId, userId) {
 }
 
 // src/routes/project-activity-routes.ts
-var routes17 = async (fastify2) => {
+var routes16 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/activity",
     async (req, reply) => {
@@ -246669,12 +246821,12 @@ var routes17 = async (fastify2) => {
     }
   );
 };
-var project_activity_routes_default = (0, import_fastify_plugin18.default)(routes17);
+var project_activity_routes_default = (0, import_fastify_plugin17.default)(routes16);
 
 // src/routes/task-routes.ts
-var import_fastify_plugin19 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID17 } from "crypto";
-var routes18 = async (fastify2) => {
+var import_fastify_plugin18 = __toESM(require_plugin2(), 1);
+import { randomUUID as randomUUID16 } from "crypto";
+var routes17 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/tasks",
     async (req, reply) => {
@@ -246737,7 +246889,7 @@ Description: ${description}`,
         title = description.length > 50 ? description.slice(0, 50) + "..." : description;
       }
     }
-    const id = randomUUID17();
+    const id = randomUUID16();
     const task = await fastify2.storage.tasks.create({
       id,
       project_id: req.params.projectId,
@@ -246834,12 +246986,12 @@ Description: ${description}`,
     return reply.code(200).send({ success: true });
   });
 };
-var task_routes_default = (0, import_fastify_plugin19.default)(routes18, { name: "task-routes" });
+var task_routes_default = (0, import_fastify_plugin18.default)(routes17, { name: "task-routes" });
 
 // src/routes/rule-routes.ts
-var import_fastify_plugin20 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID18 } from "crypto";
-var routes19 = async (fastify2) => {
+var import_fastify_plugin19 = __toESM(require_plugin2(), 1);
+import { randomUUID as randomUUID17 } from "crypto";
+var routes18 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/rules",
     async (req, reply) => {
@@ -246865,7 +247017,7 @@ var routes19 = async (fastify2) => {
     if (!name25 || !content) {
       return reply.code(400).send({ error: "name and content are required" });
     }
-    const id = randomUUID18();
+    const id = randomUUID17();
     const rule = await fastify2.storage.rules.create({
       id,
       project_id: req.params.projectId,
@@ -246925,12 +247077,12 @@ var routes19 = async (fastify2) => {
     return reply.code(200).send({ success: true });
   });
 };
-var rule_routes_default = (0, import_fastify_plugin20.default)(routes19, { name: "rule-routes" });
+var rule_routes_default = (0, import_fastify_plugin19.default)(routes18, { name: "rule-routes" });
 
 // src/routes/command-routes.ts
-var import_fastify_plugin21 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID19 } from "crypto";
-var routes20 = async (fastify2) => {
+var import_fastify_plugin20 = __toESM(require_plugin2(), 1);
+import { randomUUID as randomUUID18 } from "crypto";
+var routes19 = async (fastify2) => {
   fastify2.get(
     "/api/projects/:projectId/commands",
     async (req, reply) => {
@@ -246956,7 +247108,7 @@ var routes20 = async (fastify2) => {
     if (!name25 || !content) {
       return reply.code(400).send({ error: "name and content are required" });
     }
-    const id = randomUUID19();
+    const id = randomUUID18();
     const command = await fastify2.storage.commands.create({
       id,
       project_id: req.params.projectId,
@@ -246999,10 +247151,10 @@ var routes20 = async (fastify2) => {
     return reply.code(200).send({ success: true });
   });
 };
-var command_routes_default = (0, import_fastify_plugin21.default)(routes20, { name: "command-routes" });
+var command_routes_default = (0, import_fastify_plugin20.default)(routes19, { name: "command-routes" });
 
 // src/routes/workflow-run-routes.ts
-var import_fastify_plugin22 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin21 = __toESM(require_plugin2(), 1);
 function parseReviewerAgentType(raw) {
   if (raw === void 0) return void 0;
   return typeof raw === "string" && REVIEWER_AGENT_TYPES.has(raw) ? raw : null;
@@ -247036,7 +247188,7 @@ function errStatus(err) {
       return 500;
   }
 }
-async function routes21(fastify2) {
+async function routes20(fastify2) {
   const durableReviewFlights = /* @__PURE__ */ new Map();
   const projectLocalSession = async (session) => {
     const reader = fastify2.storage.agentSessions.getActivityById;
@@ -247603,10 +247755,10 @@ async function routes21(fastify2) {
     return reply.send({ runs });
   });
 }
-var workflow_run_routes_default = (0, import_fastify_plugin22.default)(routes21, { name: "workflow-run-routes" });
+var workflow_run_routes_default = (0, import_fastify_plugin21.default)(routes20, { name: "workflow-run-routes" });
 
 // src/routes/settings-routes.ts
-var import_fastify_plugin23 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin22 = __toESM(require_plugin2(), 1);
 var SettingsValidationError = class extends Error {
 };
 var DEFAULT_PROXY_CONFIG = { type: "none", host: "", port: 0 };
@@ -247670,7 +247822,7 @@ function requireSettingsUser(req, reply) {
   if (auth === null) return null;
   return resolveUserId(auth);
 }
-var routes22 = async (fastify2) => {
+var routes21 = async (fastify2) => {
   fastify2.get("/api/settings/agent-processes", async (req, reply) => {
     if (requireAuth(req, reply) === null) return;
     const saved = await fastify2.storage.settings.get("agentProcesses");
@@ -247944,11 +248096,11 @@ var routes22 = async (fastify2) => {
     return reply.code(200).send(updated);
   });
 };
-var settings_routes_default = (0, import_fastify_plugin23.default)(routes22, { name: "settings-routes" });
+var settings_routes_default = (0, import_fastify_plugin22.default)(routes21, { name: "settings-routes" });
 
 // src/routes/translate-routes.ts
-var import_fastify_plugin24 = __toESM(require_plugin2(), 1);
-var routes23 = async (fastify2) => {
+var import_fastify_plugin23 = __toESM(require_plugin2(), 1);
+var routes22 = async (fastify2) => {
   fastify2.post(
     "/api/translate",
     async (req, reply) => {
@@ -247989,13 +248141,13 @@ ${text2}`,
     }
   );
 };
-var translate_routes_default = (0, import_fastify_plugin24.default)(routes23, { name: "translate-routes" });
+var translate_routes_default = (0, import_fastify_plugin23.default)(routes22, { name: "translate-routes" });
 
 // src/routes/websocket-routes.ts
-var import_fastify_plugin25 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin24 = __toESM(require_plugin2(), 1);
 
 // src/routes/executor-stream-handlers.ts
-import { randomUUID as randomUUID20 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 function attachLocalProcessStream(fastify2, processId, send, onTerminal) {
   const noop4 = { cleanup: () => {
   }, handleInput: () => {
@@ -248071,7 +248223,7 @@ function attachRemoteProcessStream(fastify2, processId, send, onTerminal) {
       return;
     }
     console.log(`[diag:remote-stop] ${(/* @__PURE__ */ new Date()).toISOString()} attach processId=${processId} executorId=${info.executorId} server=${info.remoteServerId} transport=reverse-connect remoteProcessId=${info.remoteProcessId}`);
-    const channelId = randomUUID20();
+    const channelId = randomUUID19();
     const wsPath = `/api/executor-processes/${info.remoteProcessId}/logs`;
     const adapter = new VirtualWsAdapter(
       (data) => fastify2.reverseConnectManager.sendChannelData(info.remoteServerId, channelId, data),
@@ -248303,7 +248455,7 @@ function attachWsHeartbeat(socket, { label, intervalMs = DEFAULT_INTERVAL_MS, ke
 }
 
 // src/routes/websocket-routes.ts
-var routes24 = async (fastify2) => {
+var routes23 = async (fastify2) => {
   fastify2.reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
     if (status !== "online") return;
     const cache2 = fastify2.remotePatchCache;
@@ -248736,10 +248888,10 @@ var routes24 = async (fastify2) => {
     );
   });
 };
-var websocket_routes_default = (0, import_fastify_plugin25.default)(routes24, { name: "websocket-routes" });
+var websocket_routes_default = (0, import_fastify_plugin24.default)(routes23, { name: "websocket-routes" });
 
 // src/routes/reverse-connect-routes.ts
-var import_fastify_plugin26 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin25 = __toESM(require_plugin2(), 1);
 import { randomBytes as randomBytes2, createHash as createHash8, verify as cryptoVerify } from "crypto";
 
 // src/utils/rate-limited-warn.ts
@@ -248784,7 +248936,7 @@ function extractReportedVersion(frame) {
 var MACHINE_HANDSHAKE_TIMEOUT_MS = 5e3;
 var REJECT_LOG_WINDOW_MS = 3e4;
 var REJECT_LOG_MAX_KEYS = 500;
-var routes25 = async (fastify2) => {
+var routes24 = async (fastify2) => {
   const logRejectedUpgrade = createRateLimitedWarn(REJECT_LOG_WINDOW_MS, REJECT_LOG_MAX_KEYS);
   fastify2.get("/api/reverse-connect/identity", async (req, reply) => {
     const token = req.headers["x-vibedeckx-connect-token"];
@@ -248918,10 +249070,10 @@ var routes25 = async (fastify2) => {
     );
   });
 };
-var reverse_connect_routes_default = (0, import_fastify_plugin26.default)(routes25, { name: "reverse-connect-routes" });
+var reverse_connect_routes_default = (0, import_fastify_plugin25.default)(routes24, { name: "reverse-connect-routes" });
 
 // src/routes/event-routes.ts
-var import_fastify_plugin27 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin26 = __toESM(require_plugin2(), 1);
 function toWireEvent(event) {
   if (event.type === "executor:stopped" && (event.tailOutput !== void 0 || event.finalResult !== void 0)) {
     const { tailOutput: _tailOutput, finalResult: _finalResult, ...rest } = event;
@@ -248929,7 +249081,7 @@ function toWireEvent(event) {
   }
   return event;
 }
-var routes26 = async (fastify2) => {
+var routes25 = async (fastify2) => {
   fastify2.get("/api/events", async (req, reply) => {
     let userId = null;
     if (fastify2.authEnabled) {
@@ -248984,10 +249136,10 @@ var routes26 = async (fastify2) => {
     await reply;
   });
 };
-var event_routes_default = (0, import_fastify_plugin27.default)(routes26, { name: "event-routes" });
+var event_routes_default = (0, import_fastify_plugin26.default)(routes25, { name: "event-routes" });
 
 // src/routes/terminal-routes.ts
-var import_fastify_plugin28 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin27 = __toESM(require_plugin2(), 1);
 import path13 from "path";
 async function getRemoteConfig5(fastify2, project, remoteServerId) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
@@ -248998,7 +249150,7 @@ async function getRemoteConfig5(fastify2, project, remoteServerId) {
     remotePath: target.remote_path
   };
 }
-var routes27 = async (fastify2) => {
+var routes26 = async (fastify2) => {
   fastify2.post("/api/path/terminals", async (req, reply) => {
     const { path: projectPath, branch } = req.body;
     if (!projectPath) {
@@ -249174,11 +249326,11 @@ var routes27 = async (fastify2) => {
     }
   );
 };
-var terminal_routes_default = (0, import_fastify_plugin28.default)(routes27, { name: "terminal-routes" });
+var terminal_routes_default = (0, import_fastify_plugin27.default)(routes26, { name: "terminal-routes" });
 
 // src/routes/browser-routes.ts
-var import_fastify_plugin29 = __toESM(require_plugin2(), 1);
-var routes28 = async (fastify2) => {
+var import_fastify_plugin28 = __toESM(require_plugin2(), 1);
+var routes27 = async (fastify2) => {
   const ensureProjectAccess = async (req, reply) => {
     const userId = requireUserFacingUserId(req, reply);
     if (userId === null) return null;
@@ -249249,11 +249401,11 @@ var routes28 = async (fastify2) => {
     return reply.code(200).send({ ok: true });
   });
 };
-var browser_routes_default = (0, import_fastify_plugin29.default)(routes28, { name: "browser-routes" });
+var browser_routes_default = (0, import_fastify_plugin28.default)(routes27, { name: "browser-routes" });
 
 // src/routes/browser-proxy-routes.ts
-var import_fastify_plugin30 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID21 } from "crypto";
+var import_fastify_plugin29 = __toESM(require_plugin2(), 1);
+import { randomUUID as randomUUID20 } from "crypto";
 
 // src/utils/ssrf-guard.ts
 var import_undici2 = __toESM(require_undici(), 1);
@@ -249748,7 +249900,7 @@ function generateInjectedScript(projectId, targetOrigin, proxyWsPrefix) {
 })();
 </script>`;
 }
-var routes29 = async (fastify2) => {
+var routes28 = async (fastify2) => {
   fastify2.get("/api/projects/:id/browser/proxy/*", async (req, reply) => {
     const userId = requireUserFacingOrTrustedProxyUserId(req, reply);
     if (userId === null) return;
@@ -249843,7 +249995,7 @@ var routes29 = async (fastify2) => {
     const rcm = fastify2.reverseConnectManager;
     if (resolved.remoteServerId && rcm.isConnected(resolved.remoteServerId)) {
       const remoteServerId = resolved.remoteServerId;
-      const channelId = randomUUID21();
+      const channelId = randomUUID20();
       const parsed = new URL(resolved.fetchUrl);
       const wsPath = parsed.pathname;
       const wsQuery = parsed.search ? parsed.search.slice(1) : void 0;
@@ -249920,10 +250072,10 @@ var routes29 = async (fastify2) => {
     });
   });
 };
-var browser_proxy_routes_default = (0, import_fastify_plugin30.default)(routes29, { name: "browser-proxy-routes" });
+var browser_proxy_routes_default = (0, import_fastify_plugin29.default)(routes28, { name: "browser-proxy-routes" });
 
 // src/routes/cross-remote-target-routes.ts
-var import_fastify_plugin31 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin30 = __toESM(require_plugin2(), 1);
 import path14 from "path";
 import { promises as fs3 } from "fs";
 
@@ -250003,7 +250155,7 @@ var clampTimeoutMs = (timeoutSec) => {
   const requested = typeof timeoutSec === "number" && Number.isFinite(timeoutSec) && timeoutSec > 0 ? timeoutSec : DEFAULT_TIMEOUT_SEC;
   return Math.min(requested, MAX_TIMEOUT_SEC) * 1e3;
 };
-var routes30 = async (fastify2) => {
+var routes29 = async (fastify2) => {
   fastify2.post(
     "/api/path/cross-remote/exec",
     async (request, reply) => {
@@ -250111,10 +250263,10 @@ var routes30 = async (fastify2) => {
     return reply.send(result);
   });
 };
-var cross_remote_target_routes_default = (0, import_fastify_plugin31.default)(routes30, { name: "cross-remote-target-routes" });
+var cross_remote_target_routes_default = (0, import_fastify_plugin30.default)(routes29, { name: "cross-remote-target-routes" });
 
 // src/routes/cross-remote-mcp-routes.ts
-var import_fastify_plugin32 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin31 = __toESM(require_plugin2(), 1);
 var PROTOCOL_VERSION = "2024-11-05";
 var AUDIT_ARGS_MAX = 1024;
 var NOT_ACCESSIBLE = "remote not found or not accessible";
@@ -250217,7 +250369,7 @@ var textResult = (text2, isError = false) => ({
   content: [{ type: "text", text: text2 }],
   ...isError ? { isError: true } : {}
 });
-var routes31 = async (fastify2) => {
+var routes30 = async (fastify2) => {
   const guard = new SessionConcurrencyGuard();
   let cachedSecret;
   const getSecret = () => {
@@ -250338,11 +250490,11 @@ var routes31 = async (fastify2) => {
     }
   });
 };
-var cross_remote_mcp_routes_default = (0, import_fastify_plugin32.default)(routes31, { name: "cross-remote-mcp-routes" });
+var cross_remote_mcp_routes_default = (0, import_fastify_plugin31.default)(routes30, { name: "cross-remote-mcp-routes" });
 
 // src/routes/schedule-routes.ts
-var import_fastify_plugin33 = __toESM(require_plugin2(), 1);
-import { randomUUID as randomUUID22 } from "crypto";
+var import_fastify_plugin32 = __toESM(require_plugin2(), 1);
+import { randomUUID as randomUUID21 } from "crypto";
 import path15 from "path";
 var RUN_TYPES = ["command", "prompt"];
 var CWD_MODES = ["branch", "directory"];
@@ -250360,7 +250512,7 @@ function validateResolved(b2) {
   if (cronError) return `Invalid cron expression: ${cronError}`;
   return null;
 }
-var routes32 = async (fastify2) => {
+var routes31 = async (fastify2) => {
   const sendTerminalManualOutcome = (reply, request, replay) => {
     if (!request.terminalStatus || request.terminalResponseStatus === null) return null;
     const common = { runId: request.runId, status: request.terminalStatus, durable: true, replay };
@@ -250431,7 +250583,7 @@ var routes32 = async (fastify2) => {
         return reply.code(400).send({ error: "Unknown remote target" });
       }
       const schedule = await fastify2.storage.scheduledTasks.create({
-        id: randomUUID22(),
+        id: randomUUID21(),
         project_id: req.params.projectId,
         name: b2.name.trim(),
         cron_expr: resolved.cron_expr,
@@ -250591,7 +250743,7 @@ var routes32 = async (fastify2) => {
     }
   );
 };
-var schedule_routes_default = (0, import_fastify_plugin33.default)(routes32, { name: "schedule-routes" });
+var schedule_routes_default = (0, import_fastify_plugin32.default)(routes31, { name: "schedule-routes" });
 
 // src/search/catalog.ts
 var parseDbTimestamp5 = (ts) => {
@@ -250891,10 +251043,10 @@ var searchRoutes = async (fastify2) => {
 var search_routes_default = searchRoutes;
 
 // src/routes/notification-routes.ts
-var import_fastify_plugin34 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin33 = __toESM(require_plugin2(), 1);
 var MAX_LIMIT = 500;
 var DEFAULT_LIMIT = 100;
-var routes33 = async (fastify2) => {
+var routes32 = async (fastify2) => {
   fastify2.get(
     "/api/notifications",
     async (req, reply) => {
@@ -250926,7 +251078,7 @@ var routes33 = async (fastify2) => {
     return reply.code(200).send({ ok: true });
   });
 };
-var notification_routes_default = (0, import_fastify_plugin34.default)(routes33, { name: "notification-routes" });
+var notification_routes_default = (0, import_fastify_plugin33.default)(routes32, { name: "notification-routes" });
 
 // ../../node_modules/.pnpm/@clerk+fastify@3.1.2_fastify@5.7.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/fastify/dist/chunk-RY4T2JMQ.mjs
 import { Readable as Readable2 } from "stream";
@@ -250978,7 +251130,7 @@ var requestToProxyRequest = (req) => {
 
 // ../../node_modules/.pnpm/@clerk+fastify@3.1.2_fastify@5.7.2_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/fastify/dist/index.mjs
 init_dist();
-var import_fastify_plugin35 = __toESM(require_plugin2(), 1);
+var import_fastify_plugin34 = __toESM(require_plugin2(), 1);
 
 // ../../node_modules/.pnpm/@clerk+backend@3.2.0_react-dom@19.2.3_react@19.2.3__react@19.2.3/node_modules/@clerk/backend/dist/internal.mjs
 init_chunk_JW73PKED();
@@ -251266,7 +251418,7 @@ var plugin = (instance, opts, done) => {
   instance.addHook(hookName, withClerkMiddleware(opts));
   done();
 };
-var clerkPlugin = (0, import_fastify_plugin35.default)(plugin, {
+var clerkPlugin = (0, import_fastify_plugin34.default)(plugin, {
   name: "@clerk/fastify",
   fastify: "5.x"
 });
@@ -252188,7 +252340,6 @@ var createServer = async (opts) => {
   server.register(worker_stats_routes_default);
   server.register(project_remote_routes_default);
   server.register(search_routes_default);
-  server.register(executor_group_routes_default);
   server.register(executor_routes_default);
   server.register(schedule_routes_default);
   server.register(process_routes_default);
@@ -252822,7 +252973,7 @@ var ReverseConnectClient = class {
 
 // src/connect-daemon.ts
 import { spawn as spawn5 } from "node:child_process";
-import { randomUUID as randomUUID23 } from "node:crypto";
+import { randomUUID as randomUUID22 } from "node:crypto";
 import fs8 from "node:fs";
 import path19 from "node:path";
 var CONNECT_DAEMON_CHILD_ENV = "VIBEDECKX_INTERNAL_CONNECT_DAEMON";
@@ -253216,7 +253367,7 @@ function createDaemonStateLockCandidate(lockPath) {
     schemaVersion: 1,
     pid: process.pid,
     processStartTicks,
-    nonce: randomUUID23()
+    nonce: randomUUID22()
   };
   const candidatePath = `${lockPath}.candidate-${process.pid}-${owner.nonce}`;
   fs8.mkdirSync(candidatePath, { mode: 448 });
@@ -254584,7 +254735,7 @@ var connectRoutes = buildRouteMap({
   defaultCommand: "run",
   docs: { brief: "Connect to a Vibedeckx server as an inbound node" }
 });
-var routes34 = buildRouteMap({
+var routes33 = buildRouteMap({
   routes: {
     start: startCommand,
     connect: connectRoutes
@@ -254594,7 +254745,7 @@ var routes34 = buildRouteMap({
     brief: "Vibedeckx - AI-powered app generator"
   }
 });
-var program = buildApplication(routes34, {
+var program = buildApplication(routes33, {
   name: "vibedeckx",
   versionInfo: {
     currentVersion: readPackageVersion()