openmausbot 0.1.76 → 0.1.77

package/dist-server/index.js

@@ -5,8 +5,8 @@ var __export = (target, all2) => {
 };
 
 // server/index.ts
-import { createHash as createHash29, randomBytes as randomBytes9, randomUUID as randomUUID25, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
-import { existsSync as existsSync30, readFileSync as readFileSync42, rmSync as rmSync8, unlinkSync as unlinkSync12 } from "node:fs";
+import { createHash as createHash29, randomBytes as randomBytes9, randomUUID as randomUUID27, timingSafeEqual as timingSafeEqual5 } from "node:crypto";
+import { existsSync as existsSync31, readFileSync as readFileSync43, rmSync as rmSync8, unlinkSync as unlinkSync13 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
 import { extname as extname5, join as join61 } from "node:path";
 
@@ -14524,12 +14524,173 @@ function date4(params) {
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// server/shared-computers.ts
+import { randomUUID, timingSafeEqual } from "node:crypto";
+var folder = external_exports.object({ id: external_exports.string().uuid(), name: external_exports.string().min(1).max(120), write: external_exports.boolean() }).strict();
+var sharedComputerRegistration = external_exports.object({
+  id: external_exports.string().uuid(),
+  name: external_exports.string().min(1).max(120),
+  environmentId: external_exports.string().uuid(),
+  folders: external_exports.array(folder).max(20),
+  terminal: external_exports.boolean(),
+  computer: external_exports.boolean()
+}).strict();
+var sharedComputerOperation = external_exports.object({
+  computer_id: external_exports.string().uuid(),
+  action: external_exports.enum(["list_files", "read_file", "write_file", "run_command", "computer_tools", "computer_call"]),
+  folder_id: external_exports.string().uuid().optional(),
+  path: external_exports.string().max(2048).optional(),
+  content: external_exports.string().max(35e4).optional(),
+  encoding: external_exports.enum(["utf8", "base64"]).optional(),
+  expected_sha256: external_exports.string().regex(/^[a-f0-9]{64}$/).optional(),
+  command: external_exports.string().max(8e3).optional(),
+  tool_name: external_exports.string().max(100).optional(),
+  arguments: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
+}).strict();
+var failure = (message3, status = 409) => Object.assign(new Error(message3), { status });
+var SharedComputers = class {
+  computers = /* @__PURE__ */ new Map();
+  sessionLive;
+  constructor(sessionLive) {
+    this.sessionLive = sessionLive;
+  }
+  register(registration, owner2, secret) {
+    if (!/^[a-f0-9]{64}$/.test(secret)) throw failure("Invalid computer credential", 400);
+    const old = this.computers.get(registration.id);
+    if (old) {
+      this.authorize(registration.id, owner2, secret);
+      old.registration = registration;
+      old.seen = Date.now();
+    } else {
+      for (const [id, entry] of this.computers) if (!this.online(entry) && entry.jobs.size === 0) this.computers.delete(id);
+      if (this.computers.size >= 20) throw failure("Too many shared computers");
+      this.computers.set(registration.id, { registration, owner: owner2, secret, seen: Date.now(), jobs: /* @__PURE__ */ new Map() });
+    }
+  }
+  online(entry) {
+    return this.sessionLive(entry.owner) && Date.now() - entry.seen < 4e4;
+  }
+  authorize(id, owner2, secret) {
+    const entry = this.computers.get(id);
+    if (!entry || entry.owner !== owner2 || !this.sessionLive(owner2) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret))) throw failure("Shared computer is disconnected or not authorized", 403);
+    return entry;
+  }
+  list() {
+    return [...this.computers.values()].filter((entry) => this.online(entry)).map((entry) => entry.registration);
+  }
+  async poll(id, owner2, secret) {
+    const entry = this.authorize(id, owner2, secret);
+    if (entry.wake) throw failure("A computer poll is already running");
+    entry.seen = Date.now();
+    const next = () => {
+      for (const job of entry.jobs.values()) {
+        if (!job.active()) {
+          this.finish(entry, job, failure("The requesting turn ended"));
+          continue;
+        }
+        if (!job.sent) {
+          job.sent = true;
+          return { id: job.id, operation: job.operation };
+        }
+      }
+      return null;
+    };
+    const queued = next();
+    if (queued) return queued;
+    await new Promise((resolve16) => {
+      const timer = setTimeout(() => {
+        entry.wake = void 0;
+        resolve16();
+      }, 2e4);
+      entry.wake = () => {
+        clearTimeout(timer);
+        entry.wake = void 0;
+        resolve16();
+      };
+    });
+    this.authorize(id, owner2, secret);
+    entry.seen = Date.now();
+    return next();
+  }
+  liveJob(id, owner2, secret, jobId) {
+    const entry = this.authorize(id, owner2, secret);
+    entry.seen = Date.now();
+    const job = entry.jobs.get(jobId);
+    return job?.sent === true && job.active();
+  }
+  complete(id, owner2, secret, jobId, result) {
+    const entry = this.authorize(id, owner2, secret);
+    const job = entry.jobs.get(jobId);
+    if (!job || !job.sent) throw failure("This computer operation expired; it will not be replayed");
+    this.finish(entry, job, job.active() ? null : failure("The requesting turn ended"), result);
+  }
+  disconnect(id, owner2, secret) {
+    const entry = this.authorize(id, owner2, secret);
+    this.computers.delete(id);
+    entry.wake?.();
+    for (const job of entry.jobs.values()) this.finish(entry, job, failure("Computer disconnected. An in-flight action may have completed; inspect before retrying."));
+  }
+  request(operation, active) {
+    const entry = this.computers.get(operation.computer_id);
+    if (!entry || !this.online(entry)) return Promise.reject(failure("This shared computer is offline. Keep its desktop app open; do not substitute files on the server."));
+    if (entry.jobs.size >= 1) return Promise.reject(failure("This shared computer is busy. Wait for its current action to finish."));
+    if (!active()) return Promise.reject(failure("The requesting turn ended", 401));
+    return new Promise((resolve16, reject) => {
+      const id = randomUUID();
+      const job = { id, operation, active, sent: false, resolve: resolve16, reject, timer: setTimeout(() => this.finish(entry, job, failure("Computer action timed out. Its outcome is unknown; inspect before retrying.")), 45e3) };
+      entry.jobs.set(id, job);
+      entry.wake?.();
+    });
+  }
+  close() {
+    for (const entry of this.computers.values()) {
+      entry.wake?.();
+      for (const job of entry.jobs.values()) this.finish(entry, job, failure("Workspace stopped. Inspect any in-flight action before retrying."));
+    }
+    this.computers.clear();
+  }
+  finish(entry, job, error51, result) {
+    clearTimeout(job.timer);
+    entry.jobs.delete(job.id);
+    if (error51) job.reject(error51);
+    else job.resolve(result);
+  }
+};
+
+// server/shared-computer-control.ts
+var SharedComputerControl = class {
+  leases = /* @__PURE__ */ new Map();
+  resources;
+  held;
+  constructor(resources, held) {
+    this.resources = resources;
+    this.held = held;
+  }
+  acquire(id) {
+    const owner2 = { threadId: `shared:${id}`, generation: id };
+    if (this.held() || !this.resources.claim("computer:host", owner2)) {
+      this.release(id);
+      throw Object.assign(new Error("This computer is in use locally or held by a person. Wait, then observe it again before acting."), { status: 409 });
+    }
+    clearTimeout(this.leases.get(id));
+    this.leases.set(id, setTimeout(() => this.release(id), 4e4));
+  }
+  release(id) {
+    clearTimeout(this.leases.get(id));
+    this.leases.delete(id);
+    this.resources.release({ threadId: `shared:${id}`, generation: id });
+  }
+  close() {
+    for (const id of this.leases.keys()) this.release(id);
+  }
+};
+
 // server/room-handoffs.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { readFileSync } from "node:fs";
 
 // server/atomic.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 var RENAME_RETRY_DELAYS_MS = [5, 10, 20, 40, 80];
 var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
@@ -14549,7 +14710,7 @@ function renameWithRetry(tmp, path, rename3 = renameSync) {
   }
 }
 function writeFileAtomic(path, data, options = {}) {
-  const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const tmp = `${path}.${process.pid}.${randomUUID2()}.tmp`;
   let fd = null;
   try {
     fd = openSync(tmp, "w", options.mode);
@@ -14681,7 +14842,7 @@ var RoomHandoffs = class {
     }
     const node2 = {
       ...target,
-      id: randomUUID2(),
+      id: randomUUID3(),
       rootId: parent.rootId,
       parentId: parent.id,
       key: key3,
@@ -14840,7 +15001,9 @@ function isApprovalMode(value) {
   return typeof value === "string" && APPROVAL_MODES.includes(value);
 }
 function approvalModeFor(bot) {
-  if (bot.approvalGrant) return "ask";
+  const grant = bot.approvalGrant;
+  const otherThread = grant && typeof grant === "object" && "threadOnly" in grant && grant.threadOnly === true && "threadId" in grant && typeof grant.threadId === "string" && typeof bot.threadId === "string" && grant.threadId !== bot.threadId;
+  if (grant && !otherThread) return "ask";
   if (isApprovalMode(bot.approvalMode)) return bot.approvalMode;
   return bot.autoApprove === true ? "auto" : "ask";
 }
@@ -15644,7 +15807,7 @@ async function updateClaudeCli(cli, env, execute2 = execCli) {
 }
 
 // server/claude-accounts.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { join as join11 } from "node:path";
 
@@ -16019,7 +16182,11 @@ var featureConfigSchema = external_exports.object({
   showToolCalls: external_exports.boolean().optional(),
   /** Experimental built-in browser. Off until explicitly enabled; each bot
    * also has its own switch. */
-  browser: external_exports.boolean().optional()
+  browser: external_exports.boolean().optional(),
+  /** Opt-in computer sharing (a desktop lending folders, a terminal or
+   * computer control to a workspace). Off until explicitly enabled; there is
+   * no Settings toggle — see sharedComputersEnabled. */
+  sharedComputers: external_exports.boolean().optional()
 });
 var onboardingConfigSchema = external_exports.object({
   /** ISO timestamp of finishing (or skipping to the end of) the welcome flow. */
@@ -16219,6 +16386,9 @@ function showToolCallsEnabled(cfg2) {
 function builtInBrowserEnabled(cfg2) {
   return cfg2.features?.browser === true;
 }
+function sharedComputersEnabled(cfg2) {
+  return cfg2.features?.sharedComputers === true;
+}
 var FLEET_NEUTRAL_KEYS = /* @__PURE__ */ new Set([
   "profile",
   "language",
@@ -16571,8 +16741,8 @@ function classifyResumeFailure(state) {
   if (state.attempted && state.rejected) return "before-accept";
   return "unknown";
 }
-function mayReplay(failure3) {
-  return failure3 === "before-accept";
+function mayReplay(failure5) {
+  return failure5 === "before-accept";
 }
 function recoveryPromptFor(input) {
   if (!mayReplay(input.failure)) return { text: input.currentText, replayed: false };
@@ -16582,7 +16752,7 @@ function recoveryPromptFor(input) {
 }
 
 // server/drivers/claude-login-auth.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { basename as basename2, dirname as dirname2, isAbsolute, join as join4, resolve } from "node:path";
@@ -16653,7 +16823,7 @@ var ClaudeLoginController = class {
       const flow3 = {
         status: {
           phase: "waiting",
-          flowId: randomUUID3(),
+          flowId: randomUUID4(),
           authorizationUrl: null,
           expiresAt: new Date(Date.now() + (this.options.lifetimeMs ?? 15 * 6e4)).toISOString()
         },
@@ -17823,6 +17993,41 @@ function redactSecrets(input, depth = 0) {
 }
 
 // server/tool-summary.ts
+function toolDetailPreview(value) {
+  if (value === void 0) return void 0;
+  let budget = 200;
+  let textBudget = 256e3;
+  const bounded2 = (item, depth = 0) => {
+    if (--budget < 0 || depth > 6) return "[additional data omitted]";
+    if (typeof item === "string") {
+      if (item.length > textBudget) return "[large content omitted]";
+      if (/^data:[^,\s]+;base64,/i.test(item)) return "[binary content omitted]";
+      if (/^\s*[[{]/.test(item)) {
+        try {
+          return bounded2(JSON.parse(item), depth + 1);
+        } catch {
+        }
+      }
+      textBudget -= item.length;
+      return item;
+    }
+    if (typeof item === "bigint") return String(item);
+    if (item === null || typeof item !== "object") return item;
+    if (Array.isArray(item)) return item.slice(0, 40).map((child) => bounded2(child, depth + 1)).concat(item.length > 40 ? ["[additional items omitted]"] : []);
+    const entries = Object.entries(item);
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [key3, child] of entries.slice(0, 40)) {
+      result[key3] = /token|secret|password|passwd|cookie|authorization|api.?key|(^|[_.-])keys?$/i.test(key3) ? "[redacted]" : /^(data|base64|blob)$/i.test(key3) && typeof child === "string" ? "[binary content omitted]" : bounded2(child, depth + 1);
+    }
+    if (entries.length > 40) result["\u2026"] = "[additional fields omitted]";
+    return result;
+  };
+  const safe = redactSecrets(bounded2(value));
+  const text8 = typeof safe === "string" ? safe : JSON.stringify(safe, null, 2);
+  if (!text8?.trim() || text8 === "{}" || text8 === "[]") return void 0;
+  return text8.length > 6e3 ? `${text8.slice(0, 6e3)}
+[\u2026 preview shortened]` : text8;
+}
 var QUESTION_LIMIT = 300;
 var LIMIT = 200;
 function fieldsOf(input) {
@@ -19246,7 +19451,8 @@ var ClaudeDriver = {
                   itemType: "tool",
                   itemId: b2.id,
                   title: b2.name,
-                  summary: commandSummary(b2.input)
+                  summary: commandSummary(b2.input),
+                  input: toolDetailPreview(b2.input)
                 });
               }
             }
@@ -19264,7 +19470,7 @@ var ClaudeDriver = {
           case "user":
             for (const b2 of Array.isArray(o.message?.content) ? o.message.content : []) {
               if (b2.type === "tool_result") {
-                emit({ ...base2(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b2.tool_use_id, ok: !b2.is_error });
+                emit({ ...base2(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b2.tool_use_id, ok: !b2.is_error, output: toolDetailPreview(b2.content) });
               }
             }
             break;
@@ -19662,7 +19868,7 @@ function assertSeparateClaudeAccount(map3, id, entry) {
 }
 function newClaudeAccount(cfg2, body) {
   const instances = persistableInstanceConfigs(cfg2);
-  const instanceId = `claude-${randomUUID4()}`;
+  const instanceId = `claude-${randomUUID5()}`;
   const existing = Object.values(instances).find((entry2) => entry2.driver === "claudeAgent");
   const cli = existing ? rawConfig(existing).cli : void 0;
   const entry = {
@@ -19699,7 +19905,7 @@ function claudeAccountInfo(instanceId, entry, cli) {
 }
 
 // server/browser-lifecycle-cleanup.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { readFileSync as readFileSync6 } from "node:fs";
 var BOT_ID = /^[A-Za-z0-9_-]{1,120}$/;
 var PROFILE_ID = /^[a-z0-9_-]{1,40}$/;
@@ -19829,7 +20035,7 @@ var BrowserCleanupCoordinator = class {
     const existing = [...this.#pending.values()].find((request3) => request3.kind === kind && request3.id === id);
     if (existing) return existing;
     if (this.#pending.size >= MAX_PENDING) throw new Error("too many pending browser data cleanups");
-    const request2 = kind === "bot" ? { requestId: randomUUID5(), kind, id, phase: "prepared" } : { requestId: randomUUID5(), kind, id, partitionId, phase: "prepared" };
+    const request2 = kind === "bot" ? { requestId: randomUUID6(), kind, id, phase: "prepared" } : { requestId: randomUUID6(), kind, id, partitionId, phase: "prepared" };
     this.#pending.set(request2.requestId, request2);
     try {
       this.#save();
@@ -20366,7 +20572,7 @@ function validateBotCwd(input) {
 }
 
 // server/attachments.ts
-import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
 import {
   createReadStream,
   linkSync,
@@ -20665,9 +20871,9 @@ async function saveFile(chunks, originalName, mime, options = {}) {
       }
       return { path: existing, name: name2, mime: normalized, bytes: bytes2 };
     }
-    const id = uploadId ?? randomUUID6();
+    const id = uploadId ?? randomUUID7();
     const path = join14(ATTACHMENTS_DIR, `${id}${extension2}`);
-    const partialPath = join14(ATTACHMENTS_DIR, `.openmaus-upload-${id}-${randomUUID6()}.partial`);
+    const partialPath = join14(ATTACHMENTS_DIR, `.openmaus-upload-${id}-${randomUUID7()}.partial`);
     const reservation = new AttachmentReservation();
     if (expectedBytes) reservation.reserve(expectedBytes);
     activePartials.add(partialPath);
@@ -20740,10 +20946,10 @@ function saveImage(bytes, mime, requestedUploadId) {
   }
   const reservation = new AttachmentReservation();
   reservation.reserve(bytes.byteLength);
-  const id = uploadId ?? randomUUID6();
+  const id = uploadId ?? randomUUID7();
   const name2 = `${id}${ext}`;
   const path = join14(ATTACHMENTS_DIR, name2);
-  const partialPath = join14(ATTACHMENTS_DIR, `.openmaus-upload-${id}-${randomUUID6()}.partial`);
+  const partialPath = join14(ATTACHMENTS_DIR, `.openmaus-upload-${id}-${randomUUID7()}.partial`);
   activePartials.add(partialPath);
   let partialCleanupFailed = false;
   try {
@@ -27993,6 +28199,14 @@ function mimeFor(path) {
       return "image/gif";
     case ".webp":
       return "image/webp";
+    case ".mp4":
+      return "video/mp4";
+    case ".m4v":
+      return "video/x-m4v";
+    case ".webm":
+      return "video/webm";
+    case ".mov":
+      return "video/quicktime";
     case ".doc":
       return "application/msword";
     case ".docx":
@@ -28440,7 +28654,7 @@ function roomTurnTimeoutMessage(botName, minutes) {
 import { createHash as createHash6 } from "node:crypto";
 
 // server/environment.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import {
   closeSync as closeSync3,
   fsyncSync as fsyncSync2,
@@ -28479,8 +28693,8 @@ function loadEnvironmentId(dataDir) {
   if (existing) return existing;
   const directory = dirname5(file2);
   mkdirSync4(directory, { recursive: true, mode: 448 });
-  const id = randomUUID7();
-  const temporaryFile = join15(directory, `.environment-id.${process.pid}.${randomUUID7()}.tmp`);
+  const id = randomUUID8();
+  const temporaryFile = join15(directory, `.environment-id.${process.pid}.${randomUUID8()}.tmp`);
   let descriptor;
   try {
     descriptor = openSync3(temporaryFile, "wx", 384);
@@ -28524,6 +28738,9 @@ function environmentDescriptor(input) {
     version: serverVersion(),
     capabilities: {
       remoteSessions: true,
+      // Never advertise a protocol this server would refuse: the routes are
+      // gone unless features.sharedComputers is on, so the capability is too.
+      ...input.sharedComputers === true ? { sharedComputers: true } : {},
       selfUpdate: input.desktopManaged ? "desktop-managed" : "operator",
       emailSignIn: input.emailSignIn === true
     }
@@ -28531,7 +28748,7 @@ function environmentDescriptor(input) {
 }
 
 // server/box-create-idempotency.ts
-import { createHash as createHash5, randomUUID as randomUUID8 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID9 } from "node:crypto";
 import { linkSync as linkSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync10, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join16 } from "node:path";
 var FILE = join16(DATA_DIR, "box-create-requests.json");
@@ -28687,7 +28904,7 @@ function claimReaperAuthority(expected) {
     const candidate = {
       version: 1,
       pid: process.pid,
-      token: randomUUID8(),
+      token: randomUUID9(),
       createdAt: Date.now(),
       targetToken: expected.token
     };
@@ -28723,7 +28940,7 @@ function acquireJournalLock() {
   const owner2 = {
     version: 1,
     pid: process.pid,
-    token: randomUUID8(),
+    token: randomUUID9(),
     createdAt: Date.now()
   };
   const candidate = `${LOCK_FILE}.candidate-${owner2.pid}-${owner2.token}`;
@@ -28795,7 +29012,7 @@ function beginBoxCreate(botId, requestBody) {
     const request2 = {
       botId,
       requestBody,
-      idempotencyKey: randomUUID8(),
+      idempotencyKey: randomUUID9(),
       createdAt: now
     };
     if (requests.length >= MAX_REQUESTS) throw recoveryStateError("full");
@@ -28842,7 +29059,7 @@ function adoptResolvedBox(botId, boxId) {
     const adopted = sameBox ? { ...sameBox, resolved: true } : {
       botId,
       requestBody: JSON.stringify({ adopted: "legacy-name", boxId }),
-      idempotencyKey: randomUUID8(),
+      idempotencyKey: randomUUID9(),
       createdAt: Date.now(),
       boxId,
       resolved: true
@@ -29761,6 +29978,101 @@ async function screenshotBox(cfg2, botId, knownBoxId) {
   return { png: data, format: "jpeg" };
 }
 
+// server/team-computers.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
+import { existsSync as existsSync5, lstatSync, readFileSync as readFileSync11 } from "node:fs";
+var teamComputerCreate = external_exports.object({
+  name: external_exports.string().trim().min(1).max(60).refine((value) => [...value].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127)),
+  acknowledgeCost: external_exports.literal(true),
+  // Clients may keep this id across a lost create response. It is not a Box id.
+  requestId: external_exports.string().uuid()
+}).strict();
+var teamComputerAssignment = external_exports.object({
+  section: external_exports.string().trim().max(60).nullable(),
+  acknowledgeSharedAccess: external_exports.literal(true)
+}).strict();
+var entrySchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  name: teamComputerCreate.shape.name,
+  section: external_exports.string().trim().max(60).nullable(),
+  createdAt: external_exports.number().finite().nonnegative(),
+  problem: external_exports.string().max(500).optional()
+}).strict();
+var fileSchema = external_exports.object({ version: external_exports.literal(1), environmentId: external_exports.string().uuid(), computers: external_exports.array(entrySchema).max(100) }).strict();
+var teamComputerOwner = (id) => `computer_${id}`;
+var failure2 = (message3, status = 409) => Object.assign(new Error(message3), { status });
+var TeamComputers = class {
+  entries = [];
+  problem;
+  file;
+  environmentId;
+  constructor(file2, environmentId) {
+    this.file = file2;
+    this.environmentId = environmentId;
+    try {
+      if (!existsSync5(file2)) return;
+      const stat6 = lstatSync(file2);
+      if (!stat6.isFile() || stat6.isSymbolicLink() || stat6.size > 1e5) throw new Error("unsafe registry file");
+      const saved = fileSchema.parse(JSON.parse(readFileSync11(file2, "utf8")));
+      if (saved.environmentId !== environmentId) throw new Error("registry belongs to another workspace; its computers were not transferred");
+      if (new Set(saved.computers.map((entry) => entry.id)).size !== saved.computers.length) throw new Error("duplicate computer identity");
+      const sections = saved.computers.flatMap((entry) => entry.section === null ? [] : [entry.section]);
+      if (new Set(sections).size !== sections.length) throw new Error("a team has more than one computer");
+      this.entries = saved.computers;
+    } catch (error51) {
+      this.problem = `Team computer registry could not be loaded: ${error51 instanceof Error ? error51.message : String(error51)}`;
+    }
+  }
+  list() {
+    if (this.problem) throw failure2(this.problem, 503);
+    return this.entries.map((entry) => ({ ...entry }));
+  }
+  get(id) {
+    return this.list().find((entry) => entry.id === id);
+  }
+  forSection(section2) {
+    return this.list().find((entry) => entry.section !== null && entry.section === (section2?.trim() || ""));
+  }
+  forBot(bot) {
+    return bot.computer === void 0 && bot.cloudBackend !== "vps" ? this.forSection(bot.section) : void 0;
+  }
+  create(name2, id = randomUUID10()) {
+    const entries = this.list();
+    const existing = entries.find((entry2) => entry2.id === id);
+    if (existing) {
+      if (existing.name !== name2) throw failure2("This creation id already names a different computer");
+      return existing;
+    }
+    if (entries.length >= 100) throw failure2("This workspace has reached its team computer limit");
+    const entry = entrySchema.parse({ id, name: name2, section: null, createdAt: Date.now() });
+    this.save([...entries, entry]);
+    return { ...entry };
+  }
+  assign(id, section2) {
+    section2 = entrySchema.shape.section.parse(section2);
+    const entry = this.get(id);
+    if (!entry) throw failure2("No such team computer", 404);
+    if (entry.section !== null && section2 !== null && section2 !== entry.section) throw failure2("Unassign this computer before moving it to another team");
+    if (section2 !== null && this.list().some((other) => other.id !== id && other.section === section2)) throw failure2("This team already has a computer; unassign it first");
+    return this.patch(id, { section: section2 });
+  }
+  setProblem(id, problem) {
+    return this.patch(id, { problem: problem?.slice(0, 500) });
+  }
+  patch(id, patch) {
+    const entries = this.list();
+    const entry = entries.find((candidate) => candidate.id === id);
+    if (!entry) throw failure2("No such team computer", 404);
+    const next = entrySchema.parse({ ...entry, ...patch });
+    this.save(entries.map((candidate) => candidate.id === id ? next : candidate));
+    return { ...next };
+  }
+  save(entries) {
+    writeFileAtomic(this.file, JSON.stringify({ version: 1, environmentId: this.environmentId, computers: entries }), { mode: 384 });
+    this.entries = entries;
+  }
+};
+
 // server/cloud-backend.ts
 var CLOUD_BACKEND_CHANGE_ERROR = "stop the active turn before changing the cloud backend";
 var BOX_ACCOUNT_RESOURCES_ERROR = "remove this installation's cloud computers before changing or clearing the Box account";
@@ -29781,7 +30093,7 @@ function vpsAliasResourceChangeError(instanceCount) {
 }
 
 // server/composio.ts
-import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID11 } from "node:crypto";
 
 // shared/connector-availability.ts
 var MANAGED_CUSTOM_AUTH_TOOLKITS = /* @__PURE__ */ new Set(["twitter", "x"]);
@@ -30076,13 +30388,13 @@ async function prepareProjectSession(apiKey, current2, knownAuthConfigs) {
     if (existing && supportsMultiAccount(existing) && (sessionCoversAuthConfigs(existing, authConfigs) || authConfigUpgradeAttempted.has(authConfigsKey(existing.session_id, authConfigs)))) {
       return {
         apiKey: trimmed,
-        userId: existing.config?.user_id ?? current2.userId ?? `openmausbot_${randomUUID9()}`,
+        userId: existing.config?.user_id ?? current2.userId ?? `openmausbot_${randomUUID11()}`,
         sessionId: existing.session_id
       };
     }
     priorUserId = existing?.config?.user_id ?? priorUserId;
   }
-  const userId = priorUserId ?? `openmausbot_${randomUUID9()}`;
+  const userId = priorUserId ?? `openmausbot_${randomUUID11()}`;
   const sessionRequest = {
     user_id: userId,
     manage_connections: {
@@ -30741,9 +31053,9 @@ import {
   closeSync as closeSync4,
   constants as constants2,
   fstatSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   openSync as openSync4,
-  readFileSync as readFileSync11
+  readFileSync as readFileSync12
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname6, join as join17 } from "node:path";
@@ -30894,14 +31206,14 @@ function privateCache(path) {
   if (uid === void 0) return null;
   let descriptor = null;
   try {
-    const parentStatus = lstatSync(dirname6(path));
-    const fileStatus = lstatSync(path);
+    const parentStatus = lstatSync2(dirname6(path));
+    const fileStatus = lstatSync2(path);
     if (parentStatus.isSymbolicLink() || !parentStatus.isDirectory() || parentStatus.uid !== uid || (parentStatus.mode & 511) !== 448) return null;
     if (fileStatus.isSymbolicLink() || !fileStatus.isFile() || fileStatus.uid !== uid || (fileStatus.mode & 511) !== 384 || fileStatus.size > MAX_CACHE_BYTES) return null;
     descriptor = openSync4(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
     const openedStatus = fstatSync(descriptor);
     if (!openedStatus.isFile() || openedStatus.uid !== uid || (openedStatus.mode & 511) !== 384 || openedStatus.dev !== fileStatus.dev || openedStatus.ino !== fileStatus.ino || openedStatus.size > MAX_CACHE_BYTES) return null;
-    const contents = readFileSync11(descriptor);
+    const contents = readFileSync12(descriptor);
     return contents.length <= MAX_CACHE_BYTES ? contents : null;
   } catch {
     return null;
@@ -31128,7 +31440,7 @@ var ComputerControl = class {
 };
 
 // server/engine-install.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6 } from "node:fs";
 import { join as join18 } from "node:path";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
 var MAX_OUTPUT2 = 64 * 1024;
@@ -31235,7 +31547,7 @@ function runNpm(args, env, cwd, timeoutMs) {
 }
 
 // server/usage-ledger.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir2 } from "node:fs/promises";
 import { join as join19 } from "node:path";
 
@@ -31310,7 +31622,7 @@ function readUsage(dataDir, range) {
   for (const key3 of monthsBetween(range.from, range.to)) {
     let text8;
     try {
-      text8 = readFileSync12(join19(dataDir, DIR, `${key3}.jsonl`), "utf8");
+      text8 = readFileSync13(join19(dataDir, DIR, `${key3}.jsonl`), "utf8");
     } catch {
       continue;
     }
@@ -31474,6 +31786,7 @@ function modelIds(body) {
   return ids;
 }
 async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 1e4) {
+  if (!input.key.trim()) return { ok: false, reason: "rejected" };
   let url2;
   try {
     url2 = new URL(providerModelsUrl(input.provider, input.url));
@@ -31483,6 +31796,8 @@ async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 1e4) {
   if (url2.protocol !== "https:" && !(url2.protocol === "http:" && isLoopback(url2.hostname))) {
     return { ok: false, reason: "unexpected" };
   }
+  const authenticate = input.provider === "openaiCompat" && url2.origin === "https://openrouter.ai" && url2.pathname === "/api/v1/models";
+  if (authenticate) url2.pathname = "/api/v1/key";
   const headers = input.provider === "anthropic" ? { "x-api-key": input.key, "anthropic-version": "2023-06-01" } : { authorization: `Bearer ${input.key}` };
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -31491,7 +31806,15 @@ async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 1e4) {
     if (response.status === 401 || response.status === 403) return { ok: false, reason: "rejected", status: response.status };
     if (!response.ok) return { ok: false, reason: "unexpected", status: response.status };
     const body = await response.json().catch(() => null);
-    return { ok: true, models: modelIds(body) };
+    if (!body || typeof body !== "object") return { ok: false, reason: "unexpected", status: response.status };
+    if (authenticate) {
+      const data = body.data;
+      if (!data || typeof data !== "object" || Array.isArray(data) || typeof data.is_free_tier !== "boolean") {
+        return { ok: false, reason: "unexpected", status: response.status };
+      }
+      return { ok: true, check: "authentication", models: [] };
+    }
+    return { ok: true, check: "models", models: modelIds(body) };
   } catch {
     return { ok: false, reason: "unreachable" };
   } finally {
@@ -31500,7 +31823,7 @@ async function checkProviderKey(input, fetchImpl = fetch, timeoutMs = 1e4) {
 }
 
 // server/enterprise.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync7 } from "node:fs";
 import { join as join20 } from "node:path";
 import { pathToFileURL } from "node:url";
 var layerSchema = external_exports.object({
@@ -31510,14 +31833,38 @@ var layerSchema = external_exports.object({
 });
 var DEFAULT_DIR = join20(SERVER_ROOT, "..", "enterprise");
 var current = { edition: "oss", features: [] };
+var workspaceAccessFactory;
+function hostedWorkspaceConfigured(env = process.env) {
+  return env.OMB_ADMIN_URL !== void 0 || env.OMB_ADMIN_WORKSPACE !== void 0 || env.OMB_ADMIN_MEMBERSHIP !== void 0;
+}
+function hostedWorkspaceConfiguration(env = process.env) {
+  try {
+    const origin = (raw) => {
+      if (!raw || raw !== raw.trim()) throw new Error("missing origin");
+      const url2 = new URL(raw);
+      if (url2.protocol !== "https:" || raw !== url2.origin && raw !== `${url2.origin}/`) throw new Error("invalid origin");
+      return url2;
+    };
+    if (!/^[a-z][a-z0-9-]{1,30}$/.test(env.OMB_ADMIN_WORKSPACE ?? "")) return null;
+    if (env.OMB_ADMIN_MEMBERSHIP !== void 0 && !["local", "portal"].includes(env.OMB_ADMIN_MEMBERSHIP)) return null;
+    return { admin: origin(env.OMB_ADMIN_URL), tenant: origin(env.OMB_PUBLIC_URL), workspace: env.OMB_ADMIN_WORKSPACE, portalMembership: env.OMB_ADMIN_MEMBERSHIP === "portal" };
+  } catch {
+    return null;
+  }
+}
+function createWorkspaceAccess(options) {
+  if (!hostedWorkspaceConfigured(options.env)) return null;
+  return workspaceAccessFactory?.({ ...options, entitled: () => entitled("admin") }) ?? null;
+}
 function oss(notice) {
   current = notice ? { edition: "oss", features: [], notice } : { edition: "oss", features: [] };
   return current;
 }
 async function loadEnterpriseLayer(options = {}) {
+  workspaceAccessFactory = void 0;
   const dir = options.dir ?? process.env.OMB_ENTERPRISE_DIR ?? DEFAULT_DIR;
   const licenseKey = options.licenseKey ?? process.env.OMB_LICENSE_KEY;
-  const entry = [join20(dir, "server", "index.ts"), join20(dir, "server", "index.js")].find((candidate) => existsSync6(candidate));
+  const entry = [join20(dir, "server", "index.ts"), join20(dir, "server", "index.js")].find((candidate) => existsSync7(candidate));
   if (!entry) {
     return oss(
       licenseKey ? `OMB_LICENSE_KEY is set but no enterprise layer exists at ${dir}` : void 0
@@ -31525,6 +31872,8 @@ async function loadEnterpriseLayer(options = {}) {
   }
   try {
     const loaded = await import(pathToFileURL(entry).href);
+    const access2 = Reflect.get(Object(loaded), "createWorkspaceAccess");
+    if (typeof access2 === "function") workspaceAccessFactory = access2;
     const register = Reflect.get(Object(loaded), "register");
     if (typeof register !== "function") throw new Error(`${entry} does not export register()`);
     if (!licenseKey) return oss("enterprise layer present but OMB_LICENSE_KEY is not set");
@@ -31618,13 +31967,13 @@ function assertWithinBudget(cfg2, dataDir, now = /* @__PURE__ */ new Date(), isE
 }
 
 // server/fleet-client.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { request } from "node:http";
 function fleetSocketPath(env = process.env) {
   return env.OMB_FLEET_SOCKET?.trim() || "/run/openmausbot/fleet.sock";
 }
 function fleetAvailable(socketPath = fleetSocketPath()) {
-  return existsSync7(socketPath);
+  return existsSync8(socketPath);
 }
 function fleetRequest(socketPath, method, path, body, timeoutMs = 15 * 6e4) {
   return new Promise((resolve16, reject) => {
@@ -31659,6 +32008,15 @@ function fleetRequest(socketPath, method, path, body, timeoutMs = 15 * 6e4) {
   });
 }
 
+// server/hosted-contract.ts
+var HOSTED_CONTRACT_VERSION = 1;
+var HOSTED_CONTRACT_HEADER = "x-omb-hosted-contract-version";
+var HOSTED_CONTRACT_METADATA = Object.freeze({
+  contractVersion: HOSTED_CONTRACT_VERSION,
+  supportedContractVersions: Object.freeze([HOSTED_CONTRACT_VERSION]),
+  legacyPolicy: "legacy-v1"
+});
+
 // server/notify.ts
 function summarize(text8, max = 140) {
   const line = text8.replace(/```[\s\S]*?```/g, " ").replace(/\s+/g, " ").trim();
@@ -32414,7 +32772,8 @@ function createAcpDriver(support11) {
                 itemType: "tool",
                 itemId: u2.toolCallId,
                 title: String(u2.rawInput?.command ?? u2.title ?? "tool").slice(0, 80),
-                summary: commandSummary(u2.rawInput)
+                summary: commandSummary(u2.rawInput),
+                input: toolDetailPreview(u2.rawInput)
               });
               break;
             }
@@ -32425,7 +32784,8 @@ function createAcpDriver(support11) {
                   type: "item.completed",
                   itemType: "tool",
                   itemId: u2.toolCallId,
-                  ok: u2.status !== "failed"
+                  ok: u2.status !== "failed",
+                  output: toolDetailPreview(u2.rawOutput ?? u2.content)
                 });
               }
               break;
@@ -32715,7 +33075,7 @@ ${turn.text}` : turn.text;
 }
 
 // server/drivers/antigravity-acp.ts
-import { createHash as createHash9, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID12 } from "node:crypto";
 import { mkdir as mkdir4, mkdtemp as mkdtemp2, readFile as readFile2, rm as rm2, stat as stat4 } from "node:fs/promises";
 import { request as httpRequest } from "node:http";
 import { tmpdir as tmpdir3 } from "node:os";
@@ -33100,10 +33460,10 @@ async function validateAntigravityRuntime(runtime, expectedVersion) {
   const profileDirectory = await mkdtemp2(join21(tmpdir3(), "openmaus-antigravity-verify-"));
   let client;
   let failed = false;
-  let failure3;
+  let failure5;
   try {
     const profile = await prepareAntigravityProfile({
-      instanceId: `verify-${randomUUID10()}`,
+      instanceId: `verify-${randomUUID12()}`,
       runtime,
       profileDirectory,
       // Google's Windows one-file executable expands a large Python runtime
@@ -33118,7 +33478,7 @@ async function validateAntigravityRuntime(runtime, expectedVersion) {
     }
   } catch (error51) {
     failed = true;
-    failure3 = error51;
+    failure5 = error51;
   }
   let stopped = !client;
   try {
@@ -33129,7 +33489,7 @@ async function validateAntigravityRuntime(runtime, expectedVersion) {
   } catch (error51) {
     if (!failed) {
       failed = true;
-      failure3 = error51;
+      failure5 = error51;
     }
   }
   if (stopped) {
@@ -33137,7 +33497,7 @@ async function validateAntigravityRuntime(runtime, expectedVersion) {
       console.warn(`antigravity: could not remove verification profile ${profileDirectory}: ${error51 instanceof Error ? error51.message : String(error51)}`);
     });
   }
-  if (failed) throw failure3;
+  if (failed) throw failure5;
 }
 var AntigravityAuthController = class {
   flow = null;
@@ -33176,7 +33536,7 @@ var AntigravityAuthController = class {
         return { phase: "succeeded", flowId: null, authorizationUrl: null, expiresAt: null };
       }
       const flow3 = {
-        id: randomUUID10(),
+        id: randomUUID12(),
         client,
         completed: authenticated,
         pending: { redirectUri: outcome.request.redirectUri, state: outcome.request.state },
@@ -33214,7 +33574,7 @@ var AntigravityAuthController = class {
 };
 
 // server/drivers/antigravity-runtime.ts
-import { createHash as createHash10, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID13 } from "node:crypto";
 import { createReadStream as createReadStream2, createWriteStream } from "node:fs";
 import {
   access,
@@ -33539,7 +33899,7 @@ async function installOnce2(options) {
   } catch (error51) {
     if (error51 instanceof Error && error51.message.includes("Antigravity needs")) throw error51;
   }
-  const staging = await mkdtemp3(join22(versions, `${STAGING_PREFIX}${randomUUID11()}-`));
+  const staging = await mkdtemp3(join22(versions, `${STAGING_PREFIX}${randomUUID13()}-`));
   let failed = false;
   try {
     const archivePath = join22(staging, "download.zip");
@@ -33843,7 +34203,7 @@ var BoxAgentDriver = {
       const model = turn.model || MODELS.default;
       const prompt = [
         turn.system,
-        "You are working on your own cloud computer \u2014 its desktop, Chrome, and shell are yours.",
+        "You are working on the assigned cloud computer \u2014 use its desktop, Chrome, and shell within the access described above.",
         "",
         turn.text
       ].filter((s3) => s3 !== void 0).join("\n");
@@ -33998,11 +34358,11 @@ var BoxAgentDriver = {
 };
 
 // server/drivers/codex.ts
-import { existsSync as existsSync8 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 
 // server/drivers/codex-catalog.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync13 } from "node:fs";
+import { readdirSync as readdirSync3, readFileSync as readFileSync14 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { basename as basename5, join as join23 } from "node:path";
 var STATIC_CODEX_MODELS = {
@@ -34199,7 +34559,7 @@ function parseCodexToml(text8) {
 }
 function readText(path) {
   try {
-    return readFileSync13(path, "utf8");
+    return readFileSync14(path, "utf8");
   } catch {
     return null;
   }
@@ -34335,7 +34695,7 @@ async function readCodexModelCatalog(env = process.env, fetchImpl = fetch, cli)
 
 // server/drivers/codex-instructions.ts
 import { createHash as createHash11 } from "node:crypto";
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync14 } from "node:fs";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync15 } from "node:fs";
 import { join as join24 } from "node:path";
 var digest = (value) => createHash11("sha256").update(value).digest("hex");
 function codexDeveloperInstructions(config2, botInstructions) {
@@ -34356,7 +34716,7 @@ async function syncCodexInstructions(key3, nativeThreadId, instructions, resumed
   const fingerprint = digest(instructions);
   let previous2;
   try {
-    previous2 = readFileSync14(path, "utf8");
+    previous2 = readFileSync15(path, "utf8");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
@@ -34387,7 +34747,7 @@ async function syncCodexInstructions(key3, nativeThreadId, instructions, resumed
 }
 
 // server/drivers/codex-device-auth.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import { realpathSync as realpathSync4 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute8, join as join25, resolve as resolve9 } from "node:path";
@@ -34452,7 +34812,7 @@ var CodexDeviceAuthController = class {
       const flow3 = {
         status: {
           phase: "waiting",
-          flowId: randomUUID12(),
+          flowId: randomUUID14(),
           authorizationUrl: null,
           expiresAt: new Date(Date.now() + (this.options.lifetimeMs ?? 15 * 6e4)).toISOString()
         },
@@ -34802,7 +35162,7 @@ function codexPredatesAstra(version2) {
 function codexUpdateCommand(cli, platform = process.platform) {
   if (cli === "codex") return "codex update";
   const trimmed = cli.trim();
-  const tokens = trimmed.includes(" ") && existsSync8(trimmed) ? [trimmed] : splitCliString(trimmed);
+  const tokens = trimmed.includes(" ") && existsSync9(trimmed) ? [trimmed] : splitCliString(trimmed);
   const quote = platform === "win32" ? (token) => `'${token.replaceAll("'", "''")}'` : (token) => `'${token.replaceAll("'", `'\\''`)}'`;
   const command = (tokens.length > 0 ? tokens : [trimmed]).map(quote).join(" ");
   return platform === "win32" ? `& ${command} update` : `${command} update`;
@@ -35378,7 +35738,8 @@ var CodexDriver = {
                   itemType: "tool",
                   itemId: item.id,
                   title,
-                  summary: item.type === "commandExecution" ? commandSummary({ command: item.command }) : void 0
+                  summary: item.type === "commandExecution" ? commandSummary({ command: item.command }) : void 0,
+                  input: toolDetailPreview(item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "mcpToolCall" ? item.arguments : item.type === "fileChange" ? item.changes : item.query)
                 });
               }
               break;
@@ -35411,7 +35772,8 @@ var CodexDriver = {
                   type: "item.completed",
                   itemType: "tool",
                   itemId: item.id,
-                  ok: item.status !== "failed" && item.status !== "declined"
+                  ok: item.status !== "failed" && item.status !== "declined",
+                  output: toolDetailPreview(item.type === "commandExecution" ? { output: item.aggregatedOutput, exitCode: item.exitCode } : item.type === "mcpToolCall" ? item.error ?? item.result : item.type === "fileChange" ? item.changes : item.action)
                 });
               } else if (item.type === "reasoning") {
                 emit({ ...base2(threadId, turnId), type: "item.updated", itemType: "reasoning", tokens: null });
@@ -35630,10 +35992,10 @@ var CodexDriver = {
             await startTurn2();
           }
         } catch (e) {
-          const failure3 = e instanceof Error ? e : { text: String(e) };
+          const failure5 = e instanceof Error ? e : { text: String(e) };
           const message3 = e instanceof Error ? e.message : String(e);
           const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message3);
-          const verdict = classifyError(failure3);
+          const verdict = classifyError(failure5);
           if (!state.settled && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
             const delayMs = computeBackoff(attempt);
             attempt++;
@@ -36041,7 +36403,7 @@ var GrokDriver = {
 };
 
 // server/drivers/acp/grok.ts
-import { existsSync as existsSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import { join as join27 } from "node:path";
 var STATIC_GROK_MODELS = {
@@ -36067,7 +36429,7 @@ function readGrokModelCatalog(env = process.env) {
   const path = join27(grokHome(env), "config.toml");
   let text8 = "";
   try {
-    text8 = readFileSync15(path, "utf8");
+    text8 = readFileSync16(path, "utf8");
   } catch {
     return STATIC_GROK_MODELS;
   }
@@ -36140,7 +36502,7 @@ function ensureGrokInjectSlug(modelId, env = process.env) {
   const path = join27(grokHome(env), "config.toml");
   let text8 = "";
   try {
-    text8 = readFileSync15(path, "utf8");
+    text8 = readFileSync16(path, "utf8");
   } catch {
     text8 = "";
   }
@@ -36269,7 +36631,7 @@ var support2 = {
   // an unauthenticated CLI is a user action, not something to paper over.
   pickAuthMethod: (methods) => methods.some((m2) => m2.id === "cached_token") ? "cached_token" : null,
   authFailure: "fail",
-  isAuthenticated: () => existsSync9(join27(homedir14(), ".grok", "auth.json")),
+  isAuthenticated: () => existsSync10(join27(homedir14(), ".grok", "auth.json")),
   // `--append-system-prompt`/`--rules` are accepted by the CLI but do NOT
   // reach the agent-stdio system prompt (verified against 1.0.0), so the
   // persona is prepended codex-style.
@@ -36280,13 +36642,13 @@ ${turn.text}` : turn.text
 var GrokAgentDriver = createAcpDriver(support2);
 
 // server/drivers/acp/gemini.ts
-import { existsSync as existsSync10, readFileSync as readFileSync16 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync17 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
 import { join as join28 } from "node:path";
 var AUTH_PREFERENCE = ["gemini-api-key", "oauth-personal", "vertex-ai"];
 function liveOauthCredential() {
   try {
-    const creds = JSON.parse(readFileSync16(join28(homedir15(), ".gemini", "oauth_creds.json"), "utf8"));
+    const creds = JSON.parse(readFileSync17(join28(homedir15(), ".gemini", "oauth_creds.json"), "utf8"));
     if (typeof creds.access_token !== "string" || creds.access_token.trim().length === 0) return false;
     const hasRefresh = typeof creds.refresh_token === "string" && creds.refresh_token.trim().length > 0;
     if (creds.expiry_date !== void 0) {
@@ -36300,7 +36662,7 @@ function liveOauthCredential() {
 }
 var nonBlank = (value) => Boolean(value?.trim());
 function geminiIsAuthenticated(env) {
-  return nonBlank(env.GEMINI_API_KEY) || nonBlank(env.GOOGLE_API_KEY) || existsSync10(join28(homedir15(), ".gemini", "oauth_creds.json")) && liveOauthCredential();
+  return nonBlank(env.GEMINI_API_KEY) || nonBlank(env.GOOGLE_API_KEY) || existsSync11(join28(homedir15(), ".gemini", "oauth_creds.json")) && liveOauthCredential();
 }
 var support3 = {
   driverKind: "geminiAgent",
@@ -36333,7 +36695,7 @@ ${turn.text}` : turn.text
 var GeminiAgentDriver = createAcpDriver(support3);
 
 // server/drivers/acp/kimi.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
 import { join as join29 } from "node:path";
 var STATIC_KIMI_MODELS = {
@@ -36645,7 +37007,7 @@ function ensureKimiInjectAlias(modelId, env = process.env) {
   const path = join29(dataRoot, "config.toml");
   let text8 = "";
   try {
-    text8 = readFileSync17(path, "utf8");
+    text8 = readFileSync18(path, "utf8");
   } catch {
     text8 = "";
   }
@@ -36714,7 +37076,7 @@ function readKimiModelCatalog(env) {
   const dataRoot = kimiDataRoot(env);
   let text8 = "";
   try {
-    text8 = readFileSync17(join29(dataRoot, "config.toml"), "utf8");
+    text8 = readFileSync18(join29(dataRoot, "config.toml"), "utf8");
   } catch {
     return STATIC_KIMI_MODELS;
   }
@@ -36799,7 +37161,7 @@ var support4 = {
   authFailure: "continue",
   // Match the child CLI's own data-root precedence. A custom instance HOME or
   // KIMI_CODE_HOME must not be checked against the server user's home instead.
-  isAuthenticated: (env) => existsSync11(credentialsPath(env)),
+  isAuthenticated: (env) => existsSync12(credentialsPath(env)),
   buildPromptText: (turn) => turn.system ? `${turn.system}
 
 ${turn.text}` : turn.text
@@ -36807,7 +37169,7 @@ ${turn.text}` : turn.text
 var KimiAgentDriver = createAcpDriver(support4);
 
 // server/drivers/acp/droid.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync19, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
 import { join as join30 } from "node:path";
 var AUTH_FILES = ["auth.v2.file", "auth.v2.loginkeychain", "auth.v2.keyring"];
@@ -36834,9 +37196,9 @@ function ensureDroidInjectModel(modelId, env = process.env) {
   const path = join30(dir, "settings.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync18(path, "utf8"));
+    settings = JSON.parse(readFileSync19(path, "utf8"));
   } catch (error51) {
-    if (existsSync12(path)) throw error51;
+    if (existsSync13(path)) throw error51;
   }
   const custom2 = Array.isArray(settings.customModels) ? [...settings.customModels] : [];
   const match = custom2.find(
@@ -36867,11 +37229,11 @@ function ensureDroidInjectModel(modelId, env = process.env) {
 function applyDroidLocalAuthEnv(env, modelId) {
   if (!decodeInjectId(modelId)) return;
   if (env.FACTORY_API_KEY?.trim()) return;
-  if (authFilePaths(env).some(existsSync12)) return;
+  if (authFilePaths(env).some(existsSync13)) return;
   env.FACTORY_API_KEY = "openmausbot-local";
 }
 function readSettings(env) {
-  return JSON.parse(readFileSync18(join30(factoryHome(env), ".factory", "settings.json"), "utf8"));
+  return JSON.parse(readFileSync19(join30(factoryHome(env), ".factory", "settings.json"), "utf8"));
 }
 async function resolveModels(env) {
   let catalog = MODELS3;
@@ -36950,7 +37312,7 @@ var support5 = {
   // The signed-in CLI is the primary source; FACTORY_API_KEY is the fallback
   // droid itself advertises, and it is checked last so an ambient key can
   // never be what makes an otherwise logged-out instance look ready.
-  isAuthenticated: (env) => authFilePaths(env).some(existsSync12) || Boolean(env.FACTORY_API_KEY),
+  isAuthenticated: (env) => authFilePaths(env).some(existsSync13) || Boolean(env.FACTORY_API_KEY),
   resolveModels,
   resolveTurnModel: (model, env) => model ? ensureDroidInjectModel(model, env) : model,
   applyTurnEnv: (env, { requestedModel }) => {
@@ -37243,7 +37605,7 @@ function createCursorAgentDriver(run3 = execCli) {
 var CursorAgentDriver = createCursorAgentDriver();
 
 // server/drivers/acp/opencode-go.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync20, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir18 } from "node:os";
 import { join as join31 } from "node:path";
 var STATIC_MODELS = {
@@ -37382,9 +37744,9 @@ function ensureOpenCodeInjectModel(modelId, env = process.env) {
   mkdirSync10(dir, { recursive: true });
   const path = join31(dir, "opencode.json");
   let config2 = { $schema: "https://opencode.ai/config.json" };
-  if (existsSync13(path)) {
+  if (existsSync14(path)) {
     try {
-      config2 = JSON.parse(readFileSync19(path, "utf8"));
+      config2 = JSON.parse(readFileSync20(path, "utf8"));
     } catch {
     }
   }
@@ -37435,7 +37797,7 @@ function hasStoredOpenCodeAuth(env) {
   if (env.OPENCODE_AUTH_CONTENT) candidates.push(env.OPENCODE_AUTH_CONTENT);
   for (const path of storedAuthPaths(env)) {
     try {
-      candidates.push(readFileSync19(path, "utf8"));
+      candidates.push(readFileSync20(path, "utf8"));
     } catch {
     }
   }
@@ -37518,7 +37880,7 @@ function createOpenCodeDriver(loadCatalog = discoverOpenCodeModels) {
 var OpenCodeDriver = createOpenCodeDriver();
 
 // server/drivers/acp/qwen.ts
-import { chmodSync as chmodSync2, existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync15, mkdirSync as mkdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync11 } from "node:fs";
 import { createHash as createHash12 } from "node:crypto";
 import { homedir as homedir19 } from "node:os";
 import { join as join32 } from "node:path";
@@ -37538,7 +37900,7 @@ var PROTOCOLS = /* @__PURE__ */ new Set(["openai", "anthropic", "gemini", "verte
 function readQwenRoutes(env) {
   let settings;
   try {
-    settings = JSON.parse(readFileSync20(join32(qwenHome(env), "settings.json"), "utf8"));
+    settings = JSON.parse(readFileSync21(join32(qwenHome(env), "settings.json"), "utf8"));
   } catch {
     return [];
   }
@@ -37624,9 +37986,9 @@ function ensureQwenInjectModel(modelId, env = process.env) {
   mkdirSync11(dir, { recursive: true });
   const path = join32(dir, "settings.json");
   let settings = {};
-  if (existsSync14(path)) {
+  if (existsSync15(path)) {
     try {
-      settings = JSON.parse(readFileSync20(path, "utf8"));
+      settings = JSON.parse(readFileSync21(path, "utf8"));
     } catch {
     }
   }
@@ -37761,7 +38123,7 @@ var CustomAcpDriver = {
 
 // server/drivers/acp/hermes.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync22, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
 import { join as join33 } from "node:path";
 
@@ -44112,7 +44474,7 @@ function ensureHermesInjectProvider(modelId, env = process.env) {
   const path = join33(dir, "config.yaml");
   let text8 = "";
   try {
-    text8 = readFileSync21(path, "utf8");
+    text8 = readFileSync22(path, "utf8");
   } catch {
     text8 = "";
   }
@@ -44188,13 +44550,13 @@ function hermesConfiguredModel(env = process.env) {
   const dir = hermesHome(env);
   let secrets = "";
   try {
-    secrets = readFileSync21(join33(dir, ".env"), "utf8");
+    secrets = readFileSync22(join33(dir, ".env"), "utf8");
   } catch {
   }
   const hasHostedProviderKey = HERMES_HOSTED_PROVIDER_KEYS.some((name2) => nonEmptyDotenvValue(secrets, name2));
   let configuredDefault = null;
   try {
-    configuredDefault = hermesConfigDefault(readFileSync21(join33(dir, "config.yaml"), "utf8"));
+    configuredDefault = hermesConfigDefault(readFileSync22(join33(dir, "config.yaml"), "utf8"));
   } catch {
   }
   const configuredProvider = configuredDefault?.provider.toLowerCase() ?? "";
@@ -44503,7 +44865,7 @@ var OpenAICompatDriver = {
 };
 
 // server/drivers/pi.ts
-import { chmodSync as chmodSync3, existsSync as existsSync15, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, readFileSync as readFileSync22, rmSync as rmSync2, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync16, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync2, readFileSync as readFileSync23, rmSync as rmSync2, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir21, tmpdir as tmpdir4 } from "node:os";
 import { join as join34 } from "node:path";
 var DRIVER_KIND6 = "piAgent";
@@ -44513,7 +44875,7 @@ var NODE_ENV_FLAG2 = { ELECTRON_RUN_AS_NODE: "1" };
 function readPiPromptImages(turn) {
   return (turn.images ?? []).map((image) => ({
     type: "image",
-    data: readFileSync22(image.path).toString("base64"),
+    data: readFileSync23(image.path).toString("base64"),
     mimeType: image.mime
   }));
 }
@@ -44629,9 +44991,9 @@ function ensurePiInjectModel(modelId, env = process.env) {
   mkdirSync13(dir, { recursive: true });
   const path = join34(dir, "models.json");
   let root = { providers: {} };
-  if (existsSync15(path)) {
+  if (existsSync16(path)) {
     try {
-      const parsed = JSON.parse(readFileSync22(path, "utf8"));
+      const parsed = JSON.parse(readFileSync23(path, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         root = parsed;
       } else {
@@ -44683,7 +45045,7 @@ function ensurePiInjectModel(modelId, env = process.env) {
 function readPiDefaultModel(env) {
   const home = env.HOME || env.USERPROFILE || homedir21();
   try {
-    const s3 = JSON.parse(readFileSync22(`${home}/.pi/agent/settings.json`, "utf8"));
+    const s3 = JSON.parse(readFileSync23(`${home}/.pi/agent/settings.json`, "utf8"));
     return s3.defaultProvider && s3.defaultModel ? `${s3.defaultProvider}/${s3.defaultModel}` : "";
   } catch {
     return "";
@@ -44960,7 +45322,9 @@ var PiDriver = {
               type: "item.started",
               itemType: "tool",
               itemId: evt.toolCallId,
-              title: String(evt.toolName ?? "tool").slice(0, 80)
+              title: String(evt.toolName ?? "tool").slice(0, 80),
+              summary: commandSummary(evt.args),
+              input: toolDetailPreview(evt.args)
             });
             return;
           }
@@ -44970,7 +45334,8 @@ var PiDriver = {
               type: "item.completed",
               itemType: "tool",
               itemId: evt.toolCallId,
-              ok: !evt.isError
+              ok: !evt.isError,
+              output: toolDetailPreview(evt.result)
             });
             return;
           }
@@ -45183,7 +45548,7 @@ ${turn.text}` : turn.text;
 };
 
 // server/drivers/minimax.ts
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 import { homedir as homedir22 } from "node:os";
 import { join as join35 } from "node:path";
 var DRIVER_KIND7 = "minimax";
@@ -45211,7 +45576,7 @@ function normalizedApiUrl(value) {
 }
 function loadLocalMiniMaxConfig(home = homedir22()) {
   try {
-    const raw = localConfigSchema.parse(JSON.parse(readFileSync23(join35(home, ".mmx", "config.json"), "utf8")));
+    const raw = localConfigSchema.parse(JSON.parse(readFileSync24(join35(home, ".mmx", "config.json"), "utf8")));
     const configuredUrl = raw.base_url?.trim() ? raw.base_url : raw.region === "cn" ? CN_URL : DEFAULT_URL2;
     return {
       apiKey: raw.api_key?.trim() ?? "",
@@ -45302,11 +45667,11 @@ var BUILT_IN_DRIVERS = [
 
 // server/store.ts
 import { createHash as createHash14 } from "node:crypto";
-import { existsSync as existsSync19, readFileSync as readFileSync27, mkdirSync as mkdirSync18, rmSync as rmSync4, unlinkSync as unlinkSync6 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync28, mkdirSync as mkdirSync18, rmSync as rmSync4, unlinkSync as unlinkSync6 } from "node:fs";
 import { join as join40 } from "node:path";
 
 // server/section-context.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync14, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync14, readFileSync as readFileSync25 } from "node:fs";
 import { join as join36 } from "node:path";
 var SECTION_CONTEXT_MAX_BYTES = 24e3;
 var SECTION_CONTEXTS_FILE = join36(DATA_DIR, "section-contexts.json");
@@ -45327,9 +45692,9 @@ function sectionContextLabel(section2) {
   return sectionContextKey(section2) || "General";
 }
 function loadFile(forWrite = false) {
-  if (!existsSync16(SECTION_CONTEXTS_FILE)) return emptyFile();
+  if (!existsSync17(SECTION_CONTEXTS_FILE)) return emptyFile();
   try {
-    const input = JSON.parse(readFileSync24(SECTION_CONTEXTS_FILE, "utf8"));
+    const input = JSON.parse(readFileSync25(SECTION_CONTEXTS_FILE, "utf8"));
     const candidate = sectionContextFileSchema.safeParse(input);
     if (!candidate.success) throw new Error("Invalid team instructions file");
     const contexts = /* @__PURE__ */ Object.create(null);
@@ -45487,7 +45852,7 @@ function peerAllowKey(action, targetId) {
 }
 
 // server/message-db.ts
-import { chmodSync as chmodSync4, closeSync as closeSync6, existsSync as existsSync17, mkdirSync as mkdirSync16, openSync as openSync6, readFileSync as readFileSync25, renameSync as renameSync3 } from "node:fs";
+import { chmodSync as chmodSync4, closeSync as closeSync6, existsSync as existsSync18, mkdirSync as mkdirSync16, openSync as openSync6, readFileSync as readFileSync26, renameSync as renameSync3 } from "node:fs";
 import { join as join38 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
@@ -45615,7 +45980,7 @@ function ensureRecallIndex(db2) {
 }
 var UPSERT_MESSAGE = "INSERT INTO messages (thread_id, id, at, role, kind, text, json) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(thread_id, id) DO UPDATE SET at = excluded.at, role = excluded.role, kind = excluded.kind, text = excluded.text, json = excluded.json";
 function db() {
-  if (handle && handlePath === DB_FILE() && existsSync17(DB_FILE())) return handle;
+  if (handle && handlePath === DB_FILE() && existsSync18(DB_FILE())) return handle;
   try {
     handle?.close();
   } catch {
@@ -45696,7 +46061,7 @@ function importLegacy(threadId, legacyFile) {
   let activeLeafId = null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync25(legacyFile, "utf8"));
+    raw = JSON.parse(readFileSync26(legacyFile, "utf8"));
   } catch {
     return { messages, activeLeafId };
   }
@@ -45891,7 +46256,7 @@ function closeMessageDb() {
 }
 
 // server/workspace.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync17, readdirSync as readdirSync4, readFileSync as readFileSync26, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync17, readdirSync as readdirSync4, readFileSync as readFileSync27, statSync as statSync5 } from "node:fs";
 import { join as join39 } from "node:path";
 var WORKSPACES_DIR = join39(DATA_DIR, "workspaces");
 var TASK_WORKSPACES_DIR = join39(DATA_DIR, "task-workspaces");
@@ -45915,7 +46280,7 @@ function ensureWorkspace(botId) {
   const dir = join39(WORKSPACES_DIR, botId);
   mkdirSync17(join39(dir, "memory"), { recursive: true, mode: 448 });
   const memoryFile = join39(dir, "MEMORY.md");
-  if (!existsSync18(memoryFile)) writeFileAtomic(memoryFile, MEMORY_SEED, { mode: 384 });
+  if (!existsSync19(memoryFile)) writeFileAtomic(memoryFile, MEMORY_SEED, { mode: 384 });
   return dir;
 }
 function workspaceDir(botId) {
@@ -45938,7 +46303,7 @@ function memoryOverBudget(text8) {
 function loadMemory(botId) {
   let raw;
   try {
-    raw = readFileSync26(join39(workspaceDir(botId), "MEMORY.md"), "utf8");
+    raw = readFileSync27(join39(workspaceDir(botId), "MEMORY.md"), "utf8");
   } catch {
     return null;
   }
@@ -45961,7 +46326,7 @@ var MEMORY_FILE_MAX_BYTES = 256 * 1024;
 function readMemoryFile(botId) {
   let raw;
   try {
-    raw = readFileSync26(join39(workspaceDir(botId), "MEMORY.md"), "utf8");
+    raw = readFileSync27(join39(workspaceDir(botId), "MEMORY.md"), "utf8");
   } catch {
     return { text: "", truncated: false };
   }
@@ -45977,7 +46342,7 @@ function indexWrittenMemoryFile(botId, relativePath) {
   try {
     const path = join39(workspaceDir(botId), relativePath);
     const stat6 = statSync5(path);
-    indexMemoryFile(botId, relativePath, readFileSync26(path, "utf8"), { mtimeMs: stat6.mtimeMs, bytes: stat6.size });
+    indexMemoryFile(botId, relativePath, readFileSync27(path, "utf8"), { mtimeMs: stat6.mtimeMs, bytes: stat6.size });
   } catch {
   }
 }
@@ -46005,7 +46370,7 @@ function syncMemoryIndex(botId) {
     indexed.delete(file2.path);
     if (known && known.bytes === file2.bytes && known.mtimeMs === Math.trunc(file2.mtimeMs)) continue;
     try {
-      const text8 = readFileSync26(join39(workspaceDir(botId), file2.path), "utf8");
+      const text8 = readFileSync27(join39(workspaceDir(botId), file2.path), "utf8");
       indexMemoryFile(botId, file2.path, file2.path === "MEMORY.md" && text8 === MEMORY_SEED ? "" : text8, file2);
     } catch {
     }
@@ -46066,7 +46431,7 @@ function updateMemory(botId, update, opts = {}) {
   }
   const text8 = update.text === void 0 ? void 0 : redactSecretsInText(update.text);
   const dir = ensureWorkspace(botId);
-  const raw = readFileSync26(join39(dir, "MEMORY.md"), "utf8");
+  const raw = readFileSync27(join39(dir, "MEMORY.md"), "utf8");
   const current2 = raw === MEMORY_SEED ? "" : raw;
   const today = memoryDate(opts.now);
   const appendEntry = (base2, entry2) => `${base2}${base2 && !base2.endsWith("\n") ? "\n" : ""}${entry2}
@@ -46144,7 +46509,7 @@ function appendMemoryLog(botId, text8, opts = {}) {
   const path = join39(dir, file2);
   let current2 = "";
   try {
-    current2 = readFileSync26(path, "utf8");
+    current2 = readFileSync27(path, "utf8");
   } catch {
   }
   writeFileAtomic(path, `${current2}${current2 && !current2.endsWith("\n") ? "\n" : ""}${line}
@@ -46170,7 +46535,7 @@ function listMemoryLogs(botId) {
 function readMemoryLog(botId, name2) {
   if (!LOG_FILE_NAME.test(name2)) return null;
   try {
-    return readFileSync26(join39(workspaceDir(botId), "memory", MEMORY_LOG_DIR, name2), "utf8");
+    return readFileSync27(join39(workspaceDir(botId), "memory", MEMORY_LOG_DIR, name2), "utf8");
   } catch {
     return null;
   }
@@ -46204,7 +46569,7 @@ function writeMemoryTopic(botId, name2, text8) {
 function readMemoryTopic(botId, name2) {
   if (!isMemoryTopicName(name2)) return null;
   try {
-    return readFileSync26(join39(workspaceDir(botId), "memory", name2), "utf8");
+    return readFileSync27(join39(workspaceDir(botId), "memory", name2), "utf8");
   } catch {
     return null;
   }
@@ -46519,12 +46884,12 @@ var Store = class {
     this.defaultSelection = defaultSelection2;
     mkdirSync18(DATA_DIR, { recursive: true });
     try {
-      this.bots = JSON.parse(readFileSync27(BOTS_FILE, "utf8"));
+      this.bots = JSON.parse(readFileSync28(BOTS_FILE, "utf8"));
     } catch {
       this.bots = [];
     }
     try {
-      this.groups = JSON.parse(readFileSync27(GROUPS_FILE, "utf8"));
+      this.groups = JSON.parse(readFileSync28(GROUPS_FILE, "utf8"));
     } catch {
       this.groups = [];
     }
@@ -46545,7 +46910,7 @@ var Store = class {
         b2.soulHash = soulHash(b2.soul);
         botsMigrated = true;
       }
-      if (!existsSync19(soulFile(b2.id))) {
+      if (!existsSync20(soulFile(b2.id))) {
         try {
           writeSoulMirror(b2.id, b2.soul);
         } catch (e) {
@@ -46576,15 +46941,25 @@ var Store = class {
         botsMigrated = true;
       }
       if (b2.approvalGrant !== void 0) {
-        b2.approvalMode = "ask";
-        b2.autoApprove = false;
-        delete b2.approvalGrant;
-        for (const task2 of b2.tasks ?? []) {
-          if (task2.approvalMode === "full" || task2.approvalMode === "custom") {
-            task2.approvalMode = "ask";
-            task2.autoApprove = false;
+        const threadOnly = b2.approvalGrant.threadOnly === true;
+        if (threadOnly) {
+          const target = b2.tasks?.find((task2) => task2.threadId === b2.approvalGrant?.threadId);
+          if (target) {
+            target.approvalMode = "ask";
+            target.autoApprove = false;
           }
         }
+        if (!threadOnly) {
+          b2.approvalMode = "ask";
+          b2.autoApprove = false;
+          for (const task2 of b2.tasks ?? []) {
+            if (task2.approvalMode === "full" || task2.approvalMode === "custom") {
+              task2.approvalMode = "ask";
+              task2.autoApprove = false;
+            }
+          }
+        }
+        delete b2.approvalGrant;
         botsMigrated = true;
       }
       const avatar = botAvatarProfile(b2);
@@ -46727,7 +47102,7 @@ var Store = class {
     ]);
     for (const threadId of knownThreads) {
       const legacyFile = messagesFile(threadId);
-      if (existsSync19(legacyFile)) readThread(threadId, legacyFile);
+      if (existsSync20(legacyFile)) readThread(threadId, legacyFile);
     }
     this.registeringInitialSections = false;
   }
@@ -47683,6 +48058,7 @@ var Store = class {
     return {
       ...bot,
       threadId: task2.threadId,
+      approvalGrant: bot.approvalGrant?.threadOnly && bot.approvalGrant.threadId !== threadId ? void 0 : bot.approvalGrant,
       modelSelection: structuredClone(task2.modelSelection ?? bot.modelSelection),
       resumeCursors: structuredClone(task2.resumeCursors),
       approvalMode: task2.approvalMode ?? (task2.autoApprove === void 0 ? bot.approvalMode : void 0),
@@ -47976,7 +48352,7 @@ ${message3.text}`;
 }
 
 // server/delegations.ts
-import { readFileSync as readFileSync28 } from "node:fs";
+import { readFileSync as readFileSync29 } from "node:fs";
 import { join as join41 } from "node:path";
 
 // server/peer-approval.ts
@@ -48187,7 +48563,7 @@ function _loadPending() {
   pendingDelegations.clear();
   let backfilled = false;
   try {
-    const raw = JSON.parse(readFileSync28(DELEGATIONS_FILE, "utf8"));
+    const raw = JSON.parse(readFileSync29(DELEGATIONS_FILE, "utf8"));
     const now = Date.now();
     for (const [threadId, list3] of Object.entries(raw)) {
       if (!Array.isArray(list3)) continue;
@@ -48226,7 +48602,7 @@ function _loadPending() {
   if (backfilled) savePending();
   receipts = [];
   try {
-    const rawReceipts = JSON.parse(readFileSync28(RECEIPTS_FILE, "utf8"));
+    const rawReceipts = JSON.parse(readFileSync29(RECEIPTS_FILE, "utf8"));
     if (Array.isArray(rawReceipts)) {
       const now = Date.now();
       const loaded = [];
@@ -48731,7 +49107,8 @@ function queueSteeredMessage(botId, threadId, text8, options = {}) {
     replyToId: options.replyToId,
     sendId: options.sendId,
     reason: options.reason,
-    unattended: options.unattended
+    unattended: options.unattended,
+    peerAsk: options.peerAsk
   };
   saveChatFollowup({ id, kind: "bot", ownerId: botId, threadId, payload: item });
   entry.items.push(item);
@@ -48771,7 +49148,8 @@ function drainSteeredMessages(store2, run3, isBlocked) {
           text: item.text,
           replyToId: item.replyToId,
           sendId: item.sendId,
-          queueId: item.messageId
+          queueId: item.messageId,
+          peerAsk: item.peerAsk
         })
       );
     }
@@ -49657,7 +50035,7 @@ function buildTurnContext(input) {
 }
 
 // server/turn-images.ts
-import { lstatSync as lstatSync2, realpathSync as realpathSync5, statSync as statSync6 } from "node:fs";
+import { lstatSync as lstatSync3, realpathSync as realpathSync5, statSync as statSync6 } from "node:fs";
 import { dirname as dirname10, extname as extname4, resolve as resolve11 } from "node:path";
 var TURN_IMAGE_MAX_COUNT = 4;
 var TURN_IMAGE_MAX_BYTES = TURN_IMAGE_MAX_COUNT * IMAGE_MAX_BYTES2;
@@ -49720,7 +50098,7 @@ function ownedImage(path, attachmentsDir) {
   const expected = resolve11(attachmentsDir, name2);
   if (resolve11(path) !== expected) return null;
   try {
-    const entry = lstatSync2(expected);
+    const entry = lstatSync3(expected);
     if (!entry.isFile() || entry.isSymbolicLink() || entry.size <= 0 || entry.size > IMAGE_MAX_BYTES2) return null;
     const canonicalRoot = realpathSync5(attachmentsDir);
     const canonicalFile = realpathSync5(expected);
@@ -49857,7 +50235,7 @@ function overlaps(a, b2) {
 // server/memory-store.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash15 } from "node:crypto";
-import { existsSync as existsSync20, lstatSync as lstatSync3, mkdirSync as mkdirSync19, readdirSync as readdirSync5, readFileSync as readFileSync29, realpathSync as realpathSync7, unlinkSync as unlinkSync7 } from "node:fs";
+import { existsSync as existsSync21, lstatSync as lstatSync4, mkdirSync as mkdirSync19, readdirSync as readdirSync5, readFileSync as readFileSync30, realpathSync as realpathSync7, unlinkSync as unlinkSync7 } from "node:fs";
 import { dirname as dirname11, join as join44, sep as sep3 } from "node:path";
 var MEMORY_INDEX = "MEMORY.md";
 var MemoryStoreError = class extends Error {
@@ -49912,13 +50290,13 @@ function resolveMemoryPath(botId, path) {
     return absolute;
   }
   let ancestor = dirname11(absolute);
-  while (!existsSync20(ancestor) && ancestor !== root) ancestor = dirname11(ancestor);
+  while (!existsSync21(ancestor) && ancestor !== root) ancestor = dirname11(ancestor);
   const realAncestor = realpathSync7(ancestor);
   if (realAncestor !== realRoot && !realAncestor.startsWith(realRoot + sep3)) {
     throw new MemoryStoreError("path", 400, `memory path escapes the workspace: ${JSON.stringify(path)}`);
   }
   try {
-    if (lstatSync3(absolute).isSymbolicLink()) {
+    if (lstatSync4(absolute).isSymbolicLink()) {
       throw new MemoryStoreError("path", 400, `memory file is a link, not a file: ${JSON.stringify(path)}`);
     }
   } catch (error51) {
@@ -49963,7 +50341,7 @@ function listMarkdown(dir, prefix) {
   for (const name2 of names) {
     if (!isMemoryTopicName(name2)) continue;
     try {
-      const info = lstatSync3(join44(dir, name2));
+      const info = lstatSync4(join44(dir, name2));
       if (!info.isFile()) continue;
       files.push({ path: `${prefix}/${name2}`, name: name2, bytes: info.size, modifiedAt: Math.round(info.mtimeMs) });
     } catch {
@@ -49976,7 +50354,7 @@ function memoryOverview(botId) {
   const root = workspaceDir(botId);
   let raw = "";
   try {
-    raw = readFileSync29(resolveMemoryPath(botId, MEMORY_INDEX), "utf8");
+    raw = readFileSync30(resolveMemoryPath(botId, MEMORY_INDEX), "utf8");
   } catch (error51) {
     if (error51 instanceof MemoryStoreError) throw error51;
     raw = "";
@@ -49992,7 +50370,7 @@ function memoryOverview(botId) {
 function readMemoryDoc(botId, path) {
   const absolute = resolveMemoryPath(botId, path);
   try {
-    const text8 = readFileSync29(absolute, "utf8");
+    const text8 = readFileSync30(absolute, "utf8");
     return { path, text: text8, hash: hashMemoryText(text8), exists: true };
   } catch {
     return { path, text: "", hash: hashMemoryText(""), exists: false };
@@ -50082,7 +50460,7 @@ async function openMemoryLocation(botId, target, platform = process.platform, ru
 }
 
 // server/memory-journal.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import { closeSync as closeSync7, fstatSync as fstatSync2, mkdirSync as mkdirSync20, openSync as openSync7, readSync as readSync3 } from "node:fs";
 import { appendFile as appendFile3 } from "node:fs/promises";
 import { join as join45 } from "node:path";
@@ -50280,7 +50658,7 @@ function recordMemoryChange(botId, change) {
     }
   }
   const entry = {
-    id: randomUUID13(),
+    id: randomUUID15(),
     at: Date.now(),
     botId,
     path: change.path,
@@ -50396,17 +50774,17 @@ function endMemoryTurn(threadId) {
 }
 
 // server/skills.ts
-import { createHash as createHash16, randomUUID as randomUUID14 } from "node:crypto";
+import { createHash as createHash16, randomUUID as randomUUID16 } from "node:crypto";
 import {
   closeSync as closeSync8,
   constants as constants4,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   fstatSync as fstatSync3,
-  lstatSync as lstatSync4,
+  lstatSync as lstatSync5,
   mkdirSync as mkdirSync21,
   openSync as openSync8,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync30,
+  readFileSync as readFileSync31,
   readlinkSync,
   realpathSync as realpathSync8,
   renameSync as renameSync4,
@@ -50550,7 +50928,7 @@ function skillsDir(botId) {
 }
 function directoryEntryState(path) {
   try {
-    const stat6 = lstatSync4(path);
+    const stat6 = lstatSync5(path);
     return stat6.isDirectory() && !stat6.isSymbolicLink() ? "directory" : "unsafe";
   } catch {
     return "missing";
@@ -50593,7 +50971,7 @@ function skillTarget(root, name2, entry) {
 }
 function entryExistsWithoutFollowing(path) {
   try {
-    lstatSync4(path);
+    lstatSync5(path);
     return true;
   } catch {
     return false;
@@ -50636,7 +51014,7 @@ function managedLinksPath(botId) {
 }
 function readManagedLinks(botId) {
   try {
-    const parsed = JSON.parse(readFileSync30(managedLinksPath(botId), "utf8"));
+    const parsed = JSON.parse(readFileSync31(managedLinksPath(botId), "utf8"));
     const result = managedLinksSchema.safeParse(parsed);
     return result.success ? result.data.filter(isSkillName) : [];
   } catch {
@@ -50650,7 +51028,7 @@ function writeManagedLinks(botId, names) {
 }
 function manifestFromFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync30(path, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path, "utf8"));
     const result = skillManifestSchema.safeParse(parsed);
     if (!result.success) return null;
     const manifest = {};
@@ -50664,11 +51042,11 @@ function manifestFromFile(path) {
 }
 function readManifest(botId) {
   const securePath = manifestPath(botId);
-  if (existsSync21(securePath)) return manifestFromFile(securePath) ?? {};
+  if (existsSync22(securePath)) return manifestFromFile(securePath) ?? {};
   const legacyRoot = existingSkillsRoot(botId);
   if (!legacyRoot) return {};
   const legacyPath = join46(legacyRoot, "skills.json");
-  if (!existsSync21(legacyPath)) return {};
+  if (!existsSync22(legacyPath)) return {};
   const legacy = manifestFromFile(legacyPath) ?? {};
   const migrated = {};
   for (const [name2, entry] of Object.entries(legacy)) {
@@ -50692,7 +51070,7 @@ function comparablePath(path) {
 }
 function nativeLinkPointsToSkill(link2, target) {
   try {
-    if (!lstatSync4(link2).isSymbolicLink()) return false;
+    if (!lstatSync5(link2).isSymbolicLink()) return false;
     try {
       return comparablePath(realpathSync8(link2)) === comparablePath(realpathSync8(target));
     } catch {
@@ -50706,7 +51084,7 @@ function nativeLinkPointsToSkill(link2, target) {
 }
 function nativeLinkDirectlyTargetsOwnedSkill(link2, root, name2, revisionWasManaged, targetBaseDirectory = dirname12(link2)) {
   try {
-    if (!lstatSync4(link2).isSymbolicLink()) return false;
+    if (!lstatSync5(link2).isSymbolicLink()) return false;
     const rawTarget = readlinkSync(link2);
     const resolvedTarget = resolve13(targetBaseDirectory, rawTarget.replace(/^\\\\\?\\/, ""));
     const insideSkills = relative4(join46(root, "skills"), resolvedTarget).replaceAll("\\", "/");
@@ -50722,7 +51100,7 @@ function removeOwnedNativeLink(botId, link2, root, name2, revisionWasManaged, be
   } catch {
     return "retry";
   }
-  const quarantined = join46(quarantineDir, randomUUID14());
+  const quarantined = join46(quarantineDir, randomUUID16());
   beforeRemove?.(link2);
   try {
     renameSync4(link2, quarantined);
@@ -50860,8 +51238,8 @@ function skillContentMatches(botId, name2, entry) {
     const directory = skillDirectory(botId, name2, entry);
     if (!directory) return false;
     const file2 = join46(directory, "SKILL.md");
-    if (!lstatSync4(file2).isFile()) return false;
-    return createHash16("sha256").update(readFileSync30(file2)).digest("hex") === entry.sha256;
+    if (!lstatSync5(file2).isFile()) return false;
+    return createHash16("sha256").update(readFileSync31(file2)).digest("hex") === entry.sha256;
   } catch {
     return false;
   }
@@ -50890,12 +51268,12 @@ function readSkillFile(botId, name2) {
   let descriptor = null;
   try {
     const path = join46(directory, "SKILL.md");
-    const before = lstatSync4(path);
+    const before = lstatSync5(path);
     if (!before.isFile() || before.size > SKILL_FILE_MAX_BYTES) return null;
     descriptor = openSync8(path, constants4.O_RDONLY | (process.platform === "win32" ? 0 : constants4.O_NOFOLLOW ?? 0));
     const opened = fstatSync3(descriptor);
     if (!opened.isFile() || opened.size > SKILL_FILE_MAX_BYTES || opened.dev !== before.dev || opened.ino !== before.ino) return null;
-    const text8 = readFileSync30(descriptor, "utf8");
+    const text8 = readFileSync31(descriptor, "utf8");
     return createHash16("sha256").update(text8).digest("hex") === entry.sha256 ? text8 : null;
   } catch {
     return null;
@@ -50966,9 +51344,9 @@ function removeReviewedRevisionsNamed(botId, name2) {
     if (directoryEntryState(directory) !== "directory") continue;
     try {
       const file2 = join46(directory, "SKILL.md");
-      const stat6 = lstatSync4(file2);
+      const stat6 = lstatSync5(file2);
       if (!stat6.isFile() || stat6.size > SKILL_FILE_MAX_BYTES) continue;
-      const parsed = parseSkillMd(readFileSync30(file2, "utf8"));
+      const parsed = parseSkillMd(readFileSync31(file2, "utf8"));
       if ("error" in parsed || parsed.name !== name2) continue;
       rmSync5(directory, { recursive: true, force: true });
     } catch {
@@ -51021,9 +51399,9 @@ function stagedPath(botId) {
 }
 function readStaged(botId) {
   const securePath = stagedPath(botId);
-  if (existsSync21(securePath)) {
+  if (existsSync22(securePath)) {
     try {
-      const parsed = JSON.parse(readFileSync30(securePath, "utf8"));
+      const parsed = JSON.parse(readFileSync31(securePath, "utf8"));
       const result = stagedStoreSchema.safeParse(parsed);
       if (result.success) return result.data;
     } catch {
@@ -51033,7 +51411,7 @@ function readStaged(botId) {
   const legacyRoot = existingSkillsRoot(botId);
   if (!legacyRoot) return { writes: {} };
   const legacyPath = join46(legacyRoot, "staged.json");
-  if (!existsSync21(legacyPath)) return { writes: {} };
+  if (!existsSync22(legacyPath)) return { writes: {} };
   const empty = { writes: {} };
   writeStaged(botId, empty);
   try {
@@ -51082,8 +51460,8 @@ function learnedSkillDirectoryMatches(directory, sha2564) {
     const entries = readdirSync6(directory);
     if (entries.length !== 1 || entries[0] !== "SKILL.md") return false;
     const file2 = join46(directory, "SKILL.md");
-    if (!lstatSync4(file2).isFile()) return false;
-    return createHash16("sha256").update(readFileSync30(file2)).digest("hex") === sha2564;
+    if (!lstatSync5(file2).isFile()) return false;
+    return createHash16("sha256").update(readFileSync31(file2)).digest("hex") === sha2564;
   } catch {
     return false;
   }
@@ -51094,7 +51472,7 @@ function installedLearnedSkillMatches(botId, name2, entry) {
 }
 function directoryIdentity2(path) {
   try {
-    const stat6 = lstatSync4(path);
+    const stat6 = lstatSync5(path);
     return stat6.isDirectory() && !stat6.isSymbolicLink() ? { dev: stat6.dev, ino: stat6.ino } : null;
   } catch {
     return null;
@@ -51125,7 +51503,7 @@ function publishReviewedRevision(botId, stageId, skillMd, sha2564) {
       }
       rmSync5(prepared, { recursive: true, force: true });
     }
-    const temporary = join46(preparedRoot, `.prepare-${revision}-${randomUUID14()}`);
+    const temporary = join46(preparedRoot, `.prepare-${revision}-${randomUUID16()}`);
     try {
       mkdirSync21(temporary, { mode: 448 });
       writeFileAtomic(join46(temporary, "SKILL.md"), skillMd, { mode: 384 });
@@ -51172,7 +51550,7 @@ function commitNewSkillFiles(botId, name2, files, commitManifest) {
   const root = ensureSkillsRoot(botId);
   if (!root) throw new Error("the workspace skills path must be a real directory, not a symlink or file");
   const target = join46(root, name2);
-  const staged = join46(root, `.install-${name2}-${randomUUID14()}`);
+  const staged = join46(root, `.install-${name2}-${randomUUID16()}`);
   if (entryExistsWithoutFollowing(target)) throw new Error(`skill path already exists: ${name2}`);
   let published = false;
   try {
@@ -51355,7 +51733,7 @@ function stageSkillWrite(botId, input) {
     return { error: `skill "${parsed.name}" already matches the proposed SKILL.md` };
   }
   const entry = {
-    id: randomUUID14(),
+    id: randomUUID16(),
     action: input.action,
     name: parsed.name,
     gist: gist || parsed.description.slice(0, STAGED_GIST_MAX),
@@ -51697,7 +52075,7 @@ function mentionPrompt(tagged) {
 }
 
 // server/local-computer.ts
-import { lstatSync as lstatSync5, readFileSync as readFileSync31, realpathSync as realpathSync9, statSync as statSync7 } from "node:fs";
+import { lstatSync as lstatSync6, readFileSync as readFileSync32, realpathSync as realpathSync9, statSync as statSync7 } from "node:fs";
 import { homedir as homedir23 } from "node:os";
 import { dirname as dirname13, isAbsolute as isAbsolute10, join as join47 } from "node:path";
 var REQUIRED_LINUX_TOOLS = ["click", "get_window_state", "list_apps", "type_text"];
@@ -51857,8 +52235,8 @@ function validateLinuxDescriptorRuntime(descriptorFile, raw, {
   isProcessAlive = processAlive
 } = {}) {
   try {
-    const descriptorStat = lstatSync5(descriptorFile);
-    const descriptorDirectoryStat = lstatSync5(dirname13(descriptorFile));
+    const descriptorStat = lstatSync6(descriptorFile);
+    const descriptorDirectoryStat = lstatSync6(dirname13(descriptorFile));
     if (!descriptorStat.isFile() || descriptorStat.isSymbolicLink() || !ownedPrivate(descriptorStat, uid) || !descriptorDirectoryStat.isDirectory() || descriptorDirectoryStat.isSymbolicLink() || !ownedPrivate(descriptorDirectoryStat, uid)) {
       return false;
     }
@@ -51868,8 +52246,8 @@ function validateLinuxDescriptorRuntime(descriptorFile, raw, {
     const socketPath = daemon.socketPath;
     const binaryStat = statSync7(binaryPath);
     const currentFileIdentity = currentDriverFileIdentity(binaryPath);
-    const socketStat = lstatSync5(socketPath);
-    const socketDirectoryStat = lstatSync5(dirname13(socketPath));
+    const socketStat = lstatSync6(socketPath);
+    const socketDirectoryStat = lstatSync6(dirname13(socketPath));
     if (realpathSync9(binaryPath) !== binaryPath || !sameDriverFileIdentity(driver.fileIdentity, currentFileIdentity) || !binaryStat.isFile() || binaryStat.uid !== uid && binaryStat.uid !== 0 || (binaryStat.mode & 73) === 0 || (binaryStat.mode & 18) !== 0 || !socketStat.isSocket() || socketStat.isSymbolicLink() || !ownedPrivate(socketStat, uid) || !socketDirectoryStat.isDirectory() || socketDirectoryStat.isSymbolicLink() || !ownedPrivate(socketDirectoryStat, uid) || !isProcessAlive(raw.ownerPid) || !isProcessAlive(daemon.pid)) {
       return false;
     }
@@ -51892,7 +52270,7 @@ function readCuaConnection({
   }
   for (const file2 of new Set(candidates)) {
     try {
-      const raw = JSON.parse(readFileSync31(file2, "utf8"));
+      const raw = JSON.parse(readFileSync32(file2, "utf8"));
       if (platform === "linux") {
         const decoded = decodeLinuxDescriptor(raw);
         if (decoded && validateLinuxRuntime(file2, raw)) return decoded;
@@ -52819,14 +53197,14 @@ async function vpsComputerJoin(cfg2, botId, runner = defaultRunner) {
     stdio: ["ignore", "ignore", "pipe"],
     windowsHide: true
   });
-  let failure3 = null;
+  let failure5 = null;
   let stderr = "";
   child.stderr?.setEncoding("utf8");
   child.stderr?.on("data", (chunk) => {
     stderr = `${stderr}${chunk}`.slice(-1e3);
   });
   child.once("error", (error51) => {
-    failure3 = error51.message;
+    failure5 = error51.message;
   });
   child.once("close", (code) => {
     const active = desktopTunnels.get(botId);
@@ -52834,16 +53212,16 @@ async function vpsComputerJoin(cfg2, botId, runner = defaultRunner) {
       clearTimeout(active.expiry);
       desktopTunnels.delete(botId);
     }
-    if (!failure3) failure3 = stderr.trim() || `SSH viewer tunnel exited ${code ?? "without a status"}`;
+    if (!failure5) failure5 = stderr.trim() || `SSH viewer tunnel exited ${code ?? "without a status"}`;
   });
   const deadline = Date.now() + 1e4;
-  while (Date.now() < deadline && !failure3) {
+  while (Date.now() < deadline && !failure5) {
     if (await loopbackAnswers(localPort)) break;
     await new Promise((resolve16) => setTimeout(resolve16, 100));
   }
-  if (failure3 || !await loopbackAnswers(localPort)) {
+  if (failure5 || !await loopbackAnswers(localPort)) {
     if (child.exitCode === null && !child.killed) child.kill("SIGTERM");
-    const detail = failure3 || stderr.trim() || "the SSH port forward did not become ready";
+    const detail = failure5 || stderr.trim() || "the SSH port forward did not become ready";
     throw Object.assign(new Error(`Could not open the VPS live desktop: ${detail}`), { status: 502 });
   }
   const joinUrl = `http://127.0.0.1:${localPort}/vnc.html#autoconnect=true&resize=scale&password=${encodeURIComponent(connection.password)}`;
@@ -52965,8 +53343,8 @@ async function vpsComputerScreenshot(cfg2, botId, runner = defaultRunner) {
 }
 
 // server/routines.ts
-import { randomUUID as randomUUID15 } from "node:crypto";
-import { mkdirSync as mkdirSync22, readFileSync as readFileSync32 } from "node:fs";
+import { randomUUID as randomUUID17 } from "node:crypto";
+import { mkdirSync as mkdirSync22, readFileSync as readFileSync33 } from "node:fs";
 import { dirname as dirname14, join as join48 } from "node:path";
 var persistedSourceThreadId = external_exports.string().trim().min(1).optional().catch(void 0);
 var webhookRunReceiptSchema = external_exports.object({
@@ -53352,7 +53730,7 @@ var RoutineManager = class {
     this.file = options.file ?? join48(DATA_DIR, "routines.json");
     this.now = options.now ?? Date.now;
     try {
-      const disk = JSON.parse(readFileSync32(this.file, "utf8"));
+      const disk = JSON.parse(readFileSync33(this.file, "utf8"));
       this.routines = Array.isArray(disk.routines) ? disk.routines.flatMap((routine) => {
         const schedule2 = loadSchedule(routine.schedule);
         if (!schedule2) return [];
@@ -53522,7 +53900,7 @@ var RoutineManager = class {
       throw new Error("This interval has no future runs. Choose a later end date or turn it off.");
     }
     const routine = {
-      id: randomUUID15(),
+      id: randomUUID17(),
       ...clean4,
       // Only a confirmed chat card supplies `request`; the public calendar
       // API cannot choose an arbitrary transcript as a reporting target.
@@ -53723,7 +54101,7 @@ var RoutineManager = class {
       throw Object.assign(new Error("The assigned MAUS no longer exists"), { status: 410 });
     }
     const run3 = {
-      id: randomUUID15(),
+      id: randomUUID17(),
       routineId: input.webhookId,
       routineName: input.webhookName,
       prompt: input.prompt,
@@ -54107,7 +54485,7 @@ var RoutineManager = class {
       }
     }
     const run3 = {
-      id: randomUUID15(),
+      id: randomUUID17(),
       routineId: routine.id,
       routineName: routine.name,
       prompt: routine.prompt,
@@ -54235,8 +54613,8 @@ var RoutineManager = class {
 };
 
 // server/calendar-calls.ts
-import { randomUUID as randomUUID16 } from "node:crypto";
-import { mkdirSync as mkdirSync23, readFileSync as readFileSync33 } from "node:fs";
+import { randomUUID as randomUUID18 } from "node:crypto";
+import { mkdirSync as mkdirSync23, readFileSync as readFileSync34 } from "node:fs";
 import { dirname as dirname15, join as join49 } from "node:path";
 var MAX_BOTS = 100;
 var MAX_ATTACHMENTS2 = 50;
@@ -54268,7 +54646,7 @@ var callSchema = external_exports.object({
   createdAt: external_exports.number().finite().nonnegative(),
   updatedAt: external_exports.number().finite().nonnegative()
 });
-var fileSchema = external_exports.object({
+var fileSchema2 = external_exports.object({
   version: external_exports.literal(1),
   calls: external_exports.array(external_exports.unknown())
 });
@@ -54349,7 +54727,7 @@ var CalendarCallManager = class {
     this.onDue = options.onDue;
     let migrated = false;
     try {
-      const parsed = fileSchema.safeParse(JSON.parse(readFileSync33(this.file, "utf8")));
+      const parsed = fileSchema2.safeParse(JSON.parse(readFileSync34(this.file, "utf8")));
       this.calls = parsed.success ? parsed.data.calls.flatMap((candidate) => {
         const call = callSchema.safeParse(candidate);
         if (!call.success) return [];
@@ -54379,7 +54757,7 @@ var CalendarCallManager = class {
     const clean4 = cleanInput(input, this.botExists);
     const timestamp4 = this.now();
     const call = {
-      id: randomUUID16(),
+      id: randomUUID18(),
       ...clean4,
       nextRunAt: this.initialOccurrence(clean4.schedule, timestamp4),
       createdAt: timestamp4,
@@ -54512,8 +54890,8 @@ var CalendarCallManager = class {
 
 // server/browser-engine.ts
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash18, randomBytes as randomBytes4, randomUUID as randomUUID17 } from "node:crypto";
-import { chmodSync as chmodSync5, constants as constants5, copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync24, readFileSync as readFileSync34, readdirSync as readdirSync7, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync8, unlinkSync as unlinkSync9, writeFileSync as writeFileSync15 } from "node:fs";
+import { createHash as createHash18, randomBytes as randomBytes4, randomUUID as randomUUID19 } from "node:crypto";
+import { chmodSync as chmodSync5, constants as constants5, copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync24, readFileSync as readFileSync35, readdirSync as readdirSync7, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync8, unlinkSync as unlinkSync9, writeFileSync as writeFileSync15 } from "node:fs";
 import { homedir as homedir24, tmpdir as tmpdir6 } from "node:os";
 import { delimiter as delimiter4, dirname as dirname16, join as join51, resolve as resolve14 } from "node:path";
 
@@ -54972,7 +55350,7 @@ function ensureManagedBrowserConfig(env) {
     writeFileSync15(path, "{}\n", { flag: "wx", mode: 384 });
   } catch (error51) {
     if (error51.code !== "EEXIST") throw error51;
-    if (readFileSync34(path, "utf8").trim() !== "{}") throw new Error("The managed browser configuration was changed. Restore it to an empty JSON object before connecting.");
+    if (readFileSync35(path, "utf8").trim() !== "{}") throw new Error("The managed browser configuration was changed. Restore it to an empty JSON object before connecting.");
   }
   return path;
 }
@@ -55056,7 +55434,7 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
   if (!pending) {
     pending = (async () => {
       const targetBase = join51(directory, `${restoreKey}-${session}`);
-      const hasTarget = () => existsSync22(`${targetBase}.json.enc`) || existsSync22(`${targetBase}.json`);
+      const hasTarget = () => existsSync23(`${targetBase}.json.enc`) || existsSync23(`${targetBase}.json`);
       if (hasTarget()) return;
       check2();
       if (!await closeBrowserSession(binaryPath, { ...env, AGENT_BROWSER_RESTORE: session }, options.timeoutMs)) {
@@ -55095,7 +55473,7 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
 function executableName(platform = process.platform) {
   return platform === "win32" ? "agent-browser.exe" : "agent-browser";
 }
-function isMusl(platform = process.platform, exists = existsSync22) {
+function isMusl(platform = process.platform, exists = existsSync23) {
   return platform === "linux" && (exists("/lib/ld-musl-x86_64.so.1") || exists("/lib/ld-musl-aarch64.so.1"));
 }
 function pinnedBinaryPath(dataDir = DATA_DIR, platform = process.platform, arch = process.arch) {
@@ -55127,7 +55505,7 @@ function completePackage(bundle, exists) {
 function resolveAgentBrowserBinary(options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
-  const exists = options.exists ?? existsSync22;
+  const exists = options.exists ?? existsSync23;
   const override = env.OMB_AGENT_BROWSER_PATH?.trim();
   if (override) return resolve14(override) && exists(resolve14(override)) ? resolve14(override) : null;
   const bundle = packagedBrowser(options);
@@ -55167,7 +55545,7 @@ async function installAgentBrowserBinary(options = {}) {
 }
 function ensureChrome(binaryPath, options = {}) {
   const bundle = packagedBrowser(options);
-  if (!options.withDeps && bundle && resolve14(binaryPath) === bundle.engine && completePackage(bundle, existsSync22)) {
+  if (!options.withDeps && bundle && resolve14(binaryPath) === bundle.engine && completePackage(bundle, existsSync23)) {
     options.log?.("agent-browser: the bundled browser is ready; no download needed");
     return Promise.resolve();
   }
@@ -55195,7 +55573,7 @@ function ensureChrome(binaryPath, options = {}) {
 function browserEngineEncryptionKey(dataDir = DATA_DIR) {
   const file2 = join51(dataDir, KEY_FILE);
   try {
-    const existing = readFileSync34(file2, "utf8").trim();
+    const existing = readFileSync35(file2, "utf8").trim();
     if (/^[0-9a-f]{64}$/u.test(existing)) return existing;
   } catch {
   }
@@ -55214,7 +55592,7 @@ function browserEngineStatus(options = {}) {
     const version2 = managed ? agentBrowserReleaseVersion(resolveAgentBrowserReleaseAsset(platform2, options.arch)) : AGENT_BROWSER_VERSION;
     return { kind: "ready", binaryPath, version: version2 };
   }
-  if (bundle && (options.exists ?? existsSync22)(bundle.directory)) {
+  if (bundle && (options.exists ?? existsSync23)(bundle.directory)) {
     return { kind: "unavailable", reason: "The desktop browser bundle is incomplete. Reinstall or update OpenMausBot to repair it.", installable: false };
   }
   const platform = options.platform ?? process.platform;
@@ -55247,14 +55625,14 @@ function agentBrowserIntegration(input) {
     if (sourceEnv[name2]) env[name2] = sourceEnv[name2];
   }
   const bundle = packagedBrowser({ env: sourceEnv });
-  if (!env.AGENT_BROWSER_EXECUTABLE_PATH && bundle && resolve14(input.binaryPath) === bundle.engine && completePackage(bundle, existsSync22)) {
+  if (!env.AGENT_BROWSER_EXECUTABLE_PATH && bundle && resolve14(input.binaryPath) === bundle.engine && completePackage(bundle, existsSync23)) {
     env.AGENT_BROWSER_EXECUTABLE_PATH = bundle.chrome;
   }
   return { command: input.binaryPath, args: ["mcp", "--tools", "core", "--no-webmcp"], env };
 }
 var FRAME_TIMEOUT_MS = 1e4;
 function agentBrowserFrame(input) {
-  const file2 = join51(tmpdir6(), `openmausbot-browser-${randomUUID17()}.png`);
+  const file2 = join51(tmpdir6(), `openmausbot-browser-${randomUUID19()}.png`);
   return new Promise((settle, fail2) => {
     const child = spawn5(input.binaryPath, ["screenshot", file2], {
       env: browserRuntimeEnv(input.env),
@@ -55276,7 +55654,7 @@ function agentBrowserFrame(input) {
           fail2(error51);
           return;
         }
-        settle({ png: readFileSync34(file2).toString("base64"), format: "png" });
+        settle({ png: readFileSync35(file2).toString("base64"), format: "png" });
       } catch {
         fail2(new Error("the browser reported a picture it did not write"));
       } finally {
@@ -55290,7 +55668,7 @@ function agentBrowserFrame(input) {
   });
 }
 function browserSessionId(botId, partitionId) {
-  if (partitionId === "guest") return `guest-${randomUUID17()}`;
+  if (partitionId === "guest") return `guest-${randomUUID19()}`;
   const raw = partitionId || `bot-${botId}`;
   return raw.replace(/[^A-Za-z0-9_.-]/gu, "_").slice(0, 96);
 }
@@ -55337,7 +55715,7 @@ async function clearBrowserSessionState(binaryPath, session, options = {}) {
 
 // server/browser-live.ts
 import { execFile as execFile6 } from "node:child_process";
-import { randomUUID as randomUUID18 } from "node:crypto";
+import { randomUUID as randomUUID20 } from "node:crypto";
 import { promisify as promisify3 } from "node:util";
 var execute = promisify3(execFile6);
 var MAX_FRAME = 3 * 1024 * 1024;
@@ -55678,7 +56056,7 @@ data: ${JSON.stringify(data)}
     if (this.viewers.size >= 8 || [...this.viewers.values()].filter((v2) => v2.session === options.session).length >= 2) {
       throw new BrowserLiveError("Too many browser views are open. Close another browser panel first.", 429);
     }
-    const viewer = { ...options, id: randomUUID18(), closed: false, blocked: false, pendingActions: 0, restarting: false, pressedKeys: /* @__PURE__ */ new Set(), pressedButtons: /* @__PURE__ */ new Set() };
+    const viewer = { ...options, id: randomUUID20(), closed: false, blocked: false, pendingActions: 0, restarting: false, pressedKeys: /* @__PURE__ */ new Set(), pressedButtons: /* @__PURE__ */ new Set() };
     if (!this.current(viewer)) throw new BrowserLiveError("This browser view is no longer available.", 409);
     this.viewers.set(viewer.id, viewer);
     options.res.once("close", () => this.close(viewer));
@@ -55853,6 +56231,9 @@ data: ${JSON.stringify(data)}
   closeForSession(session) {
     for (const viewer of this.viewers.values()) if (viewer.session === session) this.close(viewer);
   }
+  closeForOwner(owner2) {
+    for (const viewer of this.viewers.values()) if (viewer.owner === owner2) this.close(viewer);
+  }
   closeForBot(botId) {
     for (const viewer of this.viewers.values()) if (viewer.botId === botId) this.close(viewer);
   }
@@ -57228,8 +57609,8 @@ function profileRevision(bot) {
 
 // server/profile-versions.ts
 import { appendFile as appendFile4 } from "node:fs/promises";
-import { createHash as createHash22, randomUUID as randomUUID19 } from "node:crypto";
-import { closeSync as closeSync9, existsSync as existsSync23, fstatSync as fstatSync4, mkdirSync as mkdirSync25, openSync as openSync9, readSync as readSync4 } from "node:fs";
+import { createHash as createHash22, randomUUID as randomUUID21 } from "node:crypto";
+import { closeSync as closeSync9, existsSync as existsSync24, fstatSync as fstatSync4, mkdirSync as mkdirSync25, openSync as openSync9, readSync as readSync4 } from "node:fs";
 import { join as join52 } from "node:path";
 var FILE_NAME2 = "history.ndjson";
 var ONE_LINER = 200;
@@ -57245,11 +57626,11 @@ function rowFor(field, at2, actor, via, before, after) {
   if (field === "soul") {
     const b3 = Buffer.byteLength(before, "utf8");
     const a2 = Buffer.byteLength(after, "utf8");
-    return { id: randomUUID19(), at: at2, actor, via, field, summary: `soul: ${b3} \u2192 ${a2} bytes`, before, after };
+    return { id: randomUUID21(), at: at2, actor, via, field, summary: `soul: ${b3} \u2192 ${a2} bytes`, before, after };
   }
   const b2 = oneLiner(before);
   const a = oneLiner(after);
-  return { id: randomUUID19(), at: at2, actor, via, field, summary: `${field}: ${JSON.stringify(b2)} \u2192 ${JSON.stringify(a)}`, before: b2, after: a };
+  return { id: randomUUID21(), at: at2, actor, via, field, summary: `${field}: ${JSON.stringify(b2)} \u2192 ${JSON.stringify(a)}`, before: b2, after: a };
 }
 function withRestoreEligibility(row) {
   const redacted = redactSecrets(row);
@@ -57261,7 +57642,7 @@ function withRestoreEligibility(row) {
   };
 }
 async function writeRows(botId, rows) {
-  if (!existsSync23(botFolder(botId))) return;
+  if (!existsSync24(botFolder(botId))) return;
   const file2 = historyFile(botId);
   mkdirSync25(botFolder(botId), { recursive: true, mode: 448 });
   const text8 = rows.map((row) => JSON.stringify(withRestoreEligibility(row))).join("\n") + "\n";
@@ -57971,7 +58352,7 @@ function matchDirectoryBots(profile, bots, limit = 5) {
 }
 
 // server/project-scout.ts
-import { readFileSync as readFileSync35, readdirSync as readdirSync8, statSync as statSync9 } from "node:fs";
+import { readFileSync as readFileSync36, readdirSync as readdirSync8, statSync as statSync9 } from "node:fs";
 import { basename as basename7, join as join53 } from "node:path";
 
 // shared/import-name.ts
@@ -58156,7 +58537,7 @@ var MAX_DIR_ENTRIES = 400;
 function readText2(path) {
   try {
     if (statSync9(path).size > MAX_FILE_BYTES2) return null;
-    return readFileSync35(path, "utf8");
+    return readFileSync36(path, "utf8");
   } catch {
     return null;
   }
@@ -59288,8 +59669,8 @@ function memberTurnSelection(selection) {
 }
 
 // server/webhooks.ts
-import { createHash as createHash24, randomBytes as randomBytes5, randomUUID as randomUUID20, timingSafeEqual } from "node:crypto";
-import { mkdirSync as mkdirSync26, readFileSync as readFileSync36 } from "node:fs";
+import { createHash as createHash24, randomBytes as randomBytes5, randomUUID as randomUUID22, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { mkdirSync as mkdirSync26, readFileSync as readFileSync37 } from "node:fs";
 import { dirname as dirname17, join as join55 } from "node:path";
 var MAX_DELIVERIES = 2e3;
 var MAX_ATTEMPTS = 2e3;
@@ -59372,7 +59753,7 @@ function secretMatches(secret, expectedHex) {
   if (!secret) return false;
   const actual = Buffer.from(hashSecret(secret), "hex");
   const expected = Buffer.from(expectedHex, "hex");
-  return actual.length === expected.length && timingSafeEqual(actual, expected);
+  return actual.length === expected.length && timingSafeEqual2(actual, expected);
 }
 function newEndpointId() {
   return `wh_${randomBytes5(12).toString("base64url")}`;
@@ -59480,7 +59861,7 @@ var WebhookManager = class {
     this.file = options.file ?? join55(DATA_DIR, "webhooks.json");
     this.now = options.now ?? Date.now;
     try {
-      const parsed = webhookFileSchema.safeParse(parseJson(readFileSync36(this.file, "utf8")));
+      const parsed = webhookFileSchema.safeParse(parseJson(readFileSync37(this.file, "utf8")));
       if (!parsed.success) throw parsed.error;
       this.webhooks = parsed.data.webhooks;
       this.deliveries = parsed.data.deliveries.slice(-MAX_DELIVERIES);
@@ -59503,7 +59884,7 @@ var WebhookManager = class {
     const now = this.now();
     const secret = newSecret();
     const trigger = {
-      id: randomUUID20(),
+      id: randomUUID22(),
       endpointId: newEndpointId(),
       ...clean4,
       secretHash: hashSecret(secret),
@@ -59599,7 +59980,7 @@ var WebhookManager = class {
       contentType: "application/json",
       eventName: eventName2,
       userAgent: "OpenMausBot webhook tester",
-      deliveryId: `test-${randomUUID20()}`
+      deliveryId: `test-${randomUUID22()}`
     });
   }
   recordRejected(endpointId, statusCode, reason, event = {}) {
@@ -59612,7 +59993,7 @@ var WebhookManager = class {
     if (this.options.botState(trigger.botId) === "missing") fail(410, "The assigned MAUS no longer exists");
     const allowed = trigger.eventTypes ?? [];
     if (allowed.length > 0 && (!event.eventName || !allowed.includes(event.eventName))) {
-      const deliveryId3 = String(event.deliveryId ?? "").trim().slice(0, 200) || randomUUID20();
+      const deliveryId3 = String(event.deliveryId ?? "").trim().slice(0, 200) || randomUUID22();
       this.appendAttempt(trigger, event, {
         outcome: "ignored",
         statusCode: 202,
@@ -59647,7 +60028,7 @@ var WebhookManager = class {
     if (recent.length >= RATE_LIMIT) fail(429, "Webhook rate limit exceeded");
     recent.push(now);
     this.rate.set(trigger.endpointId, recent);
-    const deliveryId2 = requestedDeliveryId || randomUUID20();
+    const deliveryId2 = requestedDeliveryId || randomUUID22();
     const run3 = this.options.enqueue({
       webhookId: trigger.id,
       webhookName: trigger.name,
@@ -59677,7 +60058,7 @@ var WebhookManager = class {
   }
   captureVerification(trigger, event) {
     const receivedAt = this.now();
-    const deliveryId2 = String(event.deliveryId ?? "").trim().slice(0, 200) || randomUUID20();
+    const deliveryId2 = String(event.deliveryId ?? "").trim().slice(0, 200) || randomUUID22();
     trigger.verificationPending = false;
     trigger.verifiedAt = receivedAt;
     trigger.lastReceivedAt = receivedAt;
@@ -59711,7 +60092,7 @@ var WebhookManager = class {
   }
   appendAttempt(trigger, event, details) {
     const attempt = {
-      id: randomUUID20(),
+      id: randomUUID22(),
       webhookId: trigger.id,
       receivedAt: this.now(),
       outcome: details.outcome,
@@ -59741,7 +60122,7 @@ var WebhookManager = class {
 };
 
 // server/skill-library.ts
-import { existsSync as existsSync24, readFileSync as readFileSync37, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync25, readFileSync as readFileSync38, readdirSync as readdirSync9 } from "node:fs";
 import { basename as basename8, join as join56 } from "node:path";
 var SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function strings(value) {
@@ -59773,14 +60154,14 @@ function parseSkillManifest(value, directory) {
 function loadSkillDirectory(directory) {
   const manifestPath2 = join56(directory, "manifest.json");
   const skillPath = join56(directory, "SKILL.md");
-  if (!existsSync24(manifestPath2) || !existsSync24(skillPath)) return null;
-  const manifest = parseSkillManifest(JSON.parse(readFileSync37(manifestPath2, "utf8")), directory);
-  const instructions = readFileSync37(skillPath, "utf8").trim();
+  if (!existsSync25(manifestPath2) || !existsSync25(skillPath)) return null;
+  const manifest = parseSkillManifest(JSON.parse(readFileSync38(manifestPath2, "utf8")), directory);
+  const instructions = readFileSync38(skillPath, "utf8").trim();
   if (!instructions.startsWith("---")) throw new Error(`${skillPath} has no skill frontmatter`);
   return { manifest, instructions, directory };
 }
 function loadBundledSkills(root = process.env.OMB_SKILLS_DIR || join56(process.cwd(), "skills")) {
-  if (!existsSync24(root)) return [];
+  if (!existsSync25(root)) return [];
   const skills = [];
   for (const name2 of readdirSync9(root).sort()) {
     const directory = join56(root, name2);
@@ -59790,7 +60171,7 @@ function loadBundledSkills(root = process.env.OMB_SKILLS_DIR || join56(process.c
   return skills;
 }
 function loadUserSkills(root) {
-  if (!existsSync24(root)) return [];
+  if (!existsSync25(root)) return [];
   let names;
   try {
     names = readdirSync9(root).sort();
@@ -60606,8 +60987,8 @@ function createGracefulShutdown({
 
 // electron/data-dir-lease.mjs
 import { execFileSync } from "node:child_process";
-import { createHash as createHash25, randomUUID as randomUUID21 } from "node:crypto";
-import { existsSync as existsSync25, linkSync as linkSync4, mkdirSync as mkdirSync27, readFileSync as readFileSync38, renameSync as renameSync6, unlinkSync as unlinkSync10, writeFileSync as writeFileSync16 } from "node:fs";
+import { createHash as createHash25, randomUUID as randomUUID23 } from "node:crypto";
+import { existsSync as existsSync26, linkSync as linkSync4, mkdirSync as mkdirSync27, readFileSync as readFileSync39, renameSync as renameSync6, unlinkSync as unlinkSync10, writeFileSync as writeFileSync16 } from "node:fs";
 import { hostname as hostname4, uptime } from "node:os";
 import { join as join57 } from "node:path";
 var LEASE_NAME = "openmausbot-server.lease";
@@ -60630,7 +61011,7 @@ var cachedBootSession;
 function readBootSession() {
   try {
     if (process.platform === "linux") {
-      return normalizeBootId(readFileSync38("/proc/sys/kernel/random/boot_id", "utf8"));
+      return normalizeBootId(readFileSync39("/proc/sys/kernel/random/boot_id", "utf8"));
     }
     if (process.platform === "darwin") {
       return normalizeBootId(execFileSync("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"], {
@@ -60677,7 +61058,7 @@ function isReaperOwner(value, targetToken) {
 function parseRecord(path, invalidMessage, validate) {
   let raw;
   try {
-    raw = readFileSync38(path, "utf8");
+    raw = readFileSync39(path, "utf8");
   } catch (error51) {
     if (error51?.code === "ENOENT") return null;
     throw leaseError("OpenMausBot cannot read the data-directory lease; refusing to start to protect its state.", error51);
@@ -60753,7 +61134,7 @@ function claimReaperAuthority2(leasePath, expected) {
       version: 1,
       pid: process.pid,
       host: hostname4(),
-      token: randomUUID21(),
+      token: randomUUID23(),
       createdAt: Date.now(),
       boot: bootSession(),
       uptime: uptimeMs(),
@@ -60800,7 +61181,7 @@ function prepareDataDir(dataDir, legacyDataDir) {
   validateDataDir(dataDir);
   if (legacyDataDir !== void 0) {
     validateDataDir(legacyDataDir);
-    if (!existsSync25(dataDir) && existsSync25(legacyDataDir)) {
+    if (!existsSync26(dataDir) && existsSync26(legacyDataDir)) {
       try {
         renameSync6(legacyDataDir, dataDir);
       } catch {
@@ -60885,7 +61266,7 @@ function acquireDataDirLeaseInternal(dataDir, options = {}) {
     version: 1,
     pid: process.pid,
     host: hostname4(),
-    token: randomUUID21(),
+    token: randomUUID23(),
     createdAt: Date.now(),
     boot: bootSession(),
     uptime: uptimeMs()
@@ -61000,8 +61381,8 @@ var WorkspaceBackupMaintenance = class {
 };
 
 // server/workspace-backup-http.ts
-import { randomUUID as randomUUID23 } from "node:crypto";
-import { createReadStream as createReadStream4, createWriteStream as createWriteStream3, existsSync as existsSync27, lstatSync as lstatSync7, mkdirSync as mkdirSync29, readdirSync as readdirSync11, statSync as statSync10, unlinkSync as unlinkSync11 } from "node:fs";
+import { randomUUID as randomUUID25 } from "node:crypto";
+import { createReadStream as createReadStream4, createWriteStream as createWriteStream3, existsSync as existsSync28, lstatSync as lstatSync8, mkdirSync as mkdirSync29, readdirSync as readdirSync11, statSync as statSync10, unlinkSync as unlinkSync11 } from "node:fs";
 import { join as join59 } from "node:path";
 import { Transform as Transform2 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
@@ -61022,7 +61403,7 @@ var WORKSPACE_BACKUP_CLIENT_KEYS = [
 ];
 
 // server/workspace-backup.ts
-import { createCipheriv, createDecipheriv, createHash as createHash26, randomBytes as randomBytes6, randomUUID as randomUUID22, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash26, randomBytes as randomBytes6, randomUUID as randomUUID24, scrypt } from "node:crypto";
 import {
   chmodSync as chmodSync6,
   closeSync as closeSync11,
@@ -61030,13 +61411,13 @@ import {
   cpSync,
   createReadStream as createReadStream3,
   createWriteStream as createWriteStream2,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   fstatSync as fstatSync6,
   fsyncSync as fsyncSync3,
-  lstatSync as lstatSync6,
+  lstatSync as lstatSync7,
   mkdirSync as mkdirSync28,
   openSync as openSync11,
-  readFileSync as readFileSync39,
+  readFileSync as readFileSync40,
   readdirSync as readdirSync10,
   readSync as readSync6,
   realpathSync as realpathSync10,
@@ -64068,6 +64449,7 @@ var EXCLUDED = /* @__PURE__ */ new Set([
   "environment-id",
   "sessions.json",
   "tunnel-account.json",
+  "team-computers.json",
   "openmausbot-server.lease",
   "box-create-requests.lock",
   "messages.db-wal",
@@ -64092,32 +64474,32 @@ function preserved(name2) {
   const folded = name2.toLowerCase();
   return excluded(folded) && folded !== "messages.db-wal" && folded !== "messages.db-shm";
 }
-function folder(path) {
+function folder2(path) {
   mkdirSync28(path, { recursive: true, mode: 448 });
-  const stat6 = lstatSync6(path);
+  const stat6 = lstatSync7(path);
   if (!stat6.isDirectory() || stat6.isSymbolicLink()) throw new Error("The backup directory must be a real directory, not a symbolic link.");
   chmodSync6(path, 448);
 }
 function backupRoot(dataDir) {
   const root = resolve15(dataDir);
   if (root === parse6(root).root) throw new Error("A filesystem root cannot be a workspace backup target.");
-  const stat6 = lstatSync6(root);
+  const stat6 = lstatSync7(root);
   if (!stat6.isDirectory() || stat6.isSymbolicLink()) throw new Error("The workspace data directory must not be a symbolic link.");
   const path = join58(root, ".backups");
-  folder(path);
+  folder2(path);
   return path;
 }
 function jobPath(dataDir, id) {
   if (!ID.test(id)) throw new Error("Invalid workspace backup identifier.");
   const path = join58(backupRoot(dataDir), id);
   if (entryExists(path)) {
-    const stat6 = lstatSync6(path);
+    const stat6 = lstatSync7(path);
     if (!stat6.isDirectory() || stat6.isSymbolicLink()) throw new Error("Unsafe workspace backup job directory.");
   }
   return path;
 }
 function newJob(dataDir) {
-  const id = randomUUID22();
+  const id = randomUUID24();
   const directory = jobPath(dataDir, id);
   mkdirSync28(directory, { mode: 448 });
   return { id, directory };
@@ -64130,7 +64512,7 @@ function record2(value) {
 }
 function entryExists(path) {
   try {
-    lstatSync6(path);
+    lstatSync7(path);
     return true;
   } catch (error51) {
     if (error51.code === "ENOENT") return false;
@@ -64142,7 +64524,7 @@ function privateJson(path) {
   try {
     const stat6 = fstatSync6(fd);
     if (!stat6.isFile() || stat6.size > MAX_METADATA_BYTES) throw new Error("Workspace backup metadata is too large or is not a regular file.");
-    return JSON.parse(readFileSync39(fd, "utf8"));
+    return JSON.parse(readFileSync40(fd, "utf8"));
   } finally {
     closeSync11(fd);
   }
@@ -64157,7 +64539,7 @@ function privateMetadata(manifest) {
 }
 function assertLocalAuthOutsideSnapshot(dataDir) {
   const configPath = join58(dataDir, "config.json");
-  const config2 = existsSync26(configPath) ? privateJson(configPath) : {};
+  const config2 = existsSync27(configPath) ? privateJson(configPath) : {};
   const instances = record2(config2) && record2(config2.instances) ? config2.instances : {};
   const fields = ["HOME", "USERPROFILE", "CLAUDE_CONFIG_DIR", "CODEX_HOME", "GROK_HOME", "KIMI_CODE_HOME", "HERMES_HOME", "FACTORY_HOME_OVERRIDE", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "LOCALAPPDATA"];
   const check2 = (value, field, home) => {
@@ -64214,7 +64596,7 @@ function copyRegular(source, destination) {
       while (offset < count) offset += writeSync(output, chunk, offset, count - offset);
     }
     const after = fstatSync6(input);
-    const current2 = lstatSync6(source);
+    const current2 = lstatSync7(source);
     if (size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || current2.ino !== before.ino || current2.dev !== before.dev || current2.isSymbolicLink()) {
       throw new Error("A workspace file changed during backup. Stop its writer and retry.");
     }
@@ -64241,7 +64623,7 @@ function hashFile(path) {
   }
 }
 function countJsonArray(path) {
-  if (!existsSync26(path)) return 0;
+  if (!existsSync27(path)) return 0;
   const value = privateJson(path);
   if (!Array.isArray(value)) throw new Error("A workspace roster is not a valid JSON array.");
   const ids = /* @__PURE__ */ new Set();
@@ -64254,7 +64636,7 @@ function countJsonArray(path) {
   return value.length;
 }
 function databaseCounts(path) {
-  if (!existsSync26(path)) return { threads: 0, messages: 0 };
+  if (!existsSync27(path)) return { threads: 0, messages: 0 };
   const db2 = new DatabaseSync2(path, { readOnly: true });
   try {
     const check2 = db2.prepare("PRAGMA quick_check").all();
@@ -64274,7 +64656,7 @@ async function createWorkspaceBackup(dataDir, options) {
   const key3 = await passwordKey(options.password, salt);
   const job = newJob(dataDir);
   const snapshot2 = join58(job.directory, "snapshot");
-  folder(join58(snapshot2, "data"));
+  folder2(join58(snapshot2, "data"));
   const entries = [];
   const warnings = ["Stop external editors and managed desktops before exporting; files written outside this server cannot be frozen by the backup gate.", "Conversation text and user files are not redacted and may contain secrets you pasted. Keep the encrypted backup private.", RESTORE_WARNING];
   let bytes = 0;
@@ -64282,8 +64664,8 @@ async function createWorkspaceBackup(dataDir, options) {
   try {
     const root = realpathSync10(dataDir);
     const sourceDb = join58(root, "messages.db");
-    if (existsSync26(sourceDb)) {
-      if (lstatSync6(sourceDb).isSymbolicLink()) throw new Error("The message database must not be a symbolic link.");
+    if (existsSync27(sourceDb)) {
+      if (lstatSync7(sourceDb).isSymbolicLink()) throw new Error("The message database must not be a symbolic link.");
       const db2 = new DatabaseSync2(sourceDb, { readOnly: true });
       const completionPulse = setInterval(() => {
       }, 25);
@@ -64308,7 +64690,7 @@ async function createWorkspaceBackup(dataDir, options) {
         if (forbiddenArchivePath(path2)) throw new Error("A workspace filename conflicts with a protected authentication or runtime path.");
         if (!validRelative(path2)) throw new Error("A workspace filename cannot be safely restored on supported platforms.");
         const source = join58(directory, name2);
-        const stat6 = lstatSync6(source);
+        const stat6 = lstatSync7(source);
         if (stat6.isSymbolicLink()) {
           let target;
           try {
@@ -64329,7 +64711,7 @@ async function createWorkspaceBackup(dataDir, options) {
         if (entries.length >= MAX_WORKSPACE_BACKUP_FILES) throw new Error("The workspace exceeds the 100,000-entry backup limit.");
         const destination = join58(snapshot2, "data", path2);
         if (stat6.isDirectory()) {
-          folder(destination);
+          folder2(destination);
           entries.push({ path: path2, type: "directory", size: 0, mode: 448 });
           walk2(source, path2);
         } else if (stat6.isFile()) {
@@ -64344,7 +64726,7 @@ async function createWorkspaceBackup(dataDir, options) {
               }
               writeJson(destination, value);
             }
-            copied = { size: lstatSync6(destination).size, mode: 384, sha256: hashFile(destination) };
+            copied = { size: lstatSync7(destination).size, mode: 384, sha256: hashFile(destination) };
           } else copied = copyRegular(path2 === "messages.db" ? join58(snapshot2, "messages-snapshot.db") : source, destination);
           bytes += copied.size;
           if (bytes > MAX_WORKSPACE_BACKUP_BYTES) throw new Error("The workspace exceeds the 10 GB backup limit.");
@@ -64499,7 +64881,7 @@ function validateStaged(directory, expected) {
     for (const name2 of readdirSync10(root)) {
       const path = prefix ? `${prefix}/${name2}` : name2;
       if (!declared.has(path)) throw new Error("Staged workspace contains files absent from its manifest.");
-      const stat6 = lstatSync6(join58(root, name2));
+      const stat6 = lstatSync7(join58(root, name2));
       if (stat6.isSymbolicLink()) throw new Error("Staged workspace contains a symbolic link.");
       if (stat6.isDirectory()) inspect(join58(root, name2), path);
     }
@@ -64507,7 +64889,7 @@ function validateStaged(directory, expected) {
   inspect(join58(directory, "data"));
   for (const entry of manifest.entries) {
     const path = join58(directory, "data", entry.path);
-    const stat6 = lstatSync6(path);
+    const stat6 = lstatSync7(path);
     if (stat6.isSymbolicLink() || (entry.type === "file" ? !stat6.isFile() || stat6.size !== entry.size : !stat6.isDirectory())) {
       throw new Error("Staged workspace files do not match the backup manifest.");
     }
@@ -64520,11 +64902,11 @@ function validateStaged(directory, expected) {
   }
   const data = join58(directory, "data");
   if (countJsonArray(join58(data, "bots.json")) !== manifest.summary.bots || countJsonArray(join58(data, "groups.json")) !== manifest.summary.groups) throw new Error("The backup roster does not match its summary.");
-  if (existsSync26(join58(data, "config.json"))) {
+  if (existsSync27(join58(data, "config.json"))) {
     const config2 = privateJson(join58(data, "config.json"));
     if (JSON.stringify(config2) !== JSON.stringify(portableWorkspaceConfig(config2))) throw new Error("Workspace backup contains non-portable connection settings.");
   }
-  if (existsSync26(join58(data, "webhooks.json"))) {
+  if (existsSync27(join58(data, "webhooks.json"))) {
     const value = privateJson(join58(data, "webhooks.json"));
     if (!record2(value) || Array.isArray(value.webhooks) && value.webhooks.some((webhook) => record2(webhook) && Object.hasOwn(webhook, "secretHash"))) throw new Error("Workspace backup contains webhook credentials.");
   }
@@ -64539,7 +64921,7 @@ async function stageWorkspaceBackup(dataDir, archivePath, options) {
     await decryptArchive(archivePath, plaintext, options.password);
     const expected = await inspectTar(plaintext);
     const staged = join58(job.directory, "staged");
-    folder(staged);
+    folder2(staged);
     await So({ file: plaintext, cwd: staged, strict: true, preservePaths: false, umask: 63, noChmod: true });
     const manifest = validateStaged(staged, expected);
     const versions = [manifest.summary.appVersion, options.currentAppVersion ?? ""].map((version2) => /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version2)?.slice(1).map(Number));
@@ -64566,8 +64948,8 @@ function readStagedWorkspaceBackup(dataDir, id) {
 }
 function commitPendingWorkspaceRestore(dataDir, id) {
   const root = backupRoot(dataDir);
-  if (existsSync26(join58(root, "pending-restore.json"))) throw new Error("A workspace restore is already waiting for restart.");
-  if (existsSync26(join58(root, `safety-${id}`))) throw new Error("This restore was already attempted. Preview the backup again to create a fresh restore attempt.");
+  if (existsSync27(join58(root, "pending-restore.json"))) throw new Error("A workspace restore is already waiting for restart.");
+  if (existsSync27(join58(root, `safety-${id}`))) throw new Error("This restore was already attempted. Preview the backup again to create a fresh restore attempt.");
   const metadata = readStagedWorkspaceBackup(dataDir, id);
   const manifest = validateStaged(join58(jobPath(dataDir, id), "staged"));
   prepareRestore(dataDir, id, manifest);
@@ -64577,7 +64959,7 @@ function commitPendingWorkspaceRestore(dataDir, id) {
 function readPendingWorkspaceRestoreMetadata(dataDir) {
   const root = backupRoot(dataDir);
   const path = join58(root, "pending-restore.json");
-  if (!existsSync26(path)) return null;
+  if (!existsSync27(path)) return null;
   const pending = privateJson(path);
   if (!record2(pending) || typeof pending.id !== "string") throw new Error("Invalid pending workspace restore.");
   return readStagedWorkspaceBackup(dataDir, pending.id);
@@ -64609,8 +64991,8 @@ function rollback(dataDir, journal) {
   const root = backupRoot(dataDir);
   const previousReceipt = join58(root, `safety-${journal.id}`, "previous-restore.json");
   const last = join58(root, "last-restore.json");
-  if (existsSync26(previousReceipt)) writeJson(last, privateJson(previousReceipt));
-  else if (existsSync26(last)) {
+  if (existsSync27(previousReceipt)) writeJson(last, privateJson(previousReceipt));
+  else if (existsSync27(last)) {
     const value = privateJson(last);
     if (record2(value) && value.id === journal.id) rmSync7(last);
   }
@@ -64661,16 +65043,16 @@ function prepareRestore(dataDir, id, manifest) {
   assertLocalAuthOutsideSnapshot(dataDir);
   const job = jobPath(dataDir, id);
   const prepared = join58(job, "apply", "data");
-  if (existsSync26(join58(job, "apply"))) rmSync7(join58(job, "apply"), { recursive: true, force: true });
-  folder(prepared);
-  for (const entry of manifest.entries.filter((entry2) => entry2.type === "directory")) folder(join58(prepared, entry.path));
+  if (existsSync27(join58(job, "apply"))) rmSync7(join58(job, "apply"), { recursive: true, force: true });
+  folder2(prepared);
+  for (const entry of manifest.entries.filter((entry2) => entry2.type === "directory")) folder2(join58(prepared, entry.path));
   for (const entry of manifest.entries) {
     const destination = join58(prepared, entry.path);
     if (entry.type === "file") copyRegular(join58(job, "staged", "data", entry.path), destination);
   }
   const changeJson = (name2, change) => {
     const path = join58(prepared, name2);
-    if (!existsSync26(path)) return;
+    if (!existsSync27(path)) return;
     const value = privateJson(path);
     change(value);
     writeJson(path, value);
@@ -64680,22 +65062,22 @@ function prepareRestore(dataDir, id, manifest) {
   }
   const oldConfig = join58(dataDir, "config.json");
   const newConfig = join58(prepared, "config.json");
-  if (existsSync26(oldConfig) || existsSync26(newConfig)) {
-    writeJson(newConfig, restoredWorkspaceConfig(existsSync26(newConfig) ? privateJson(newConfig) : {}, existsSync26(oldConfig) ? privateJson(oldConfig) : {}));
+  if (existsSync27(oldConfig) || existsSync27(newConfig)) {
+    writeJson(newConfig, restoredWorkspaceConfig(existsSync27(newConfig) ? privateJson(newConfig) : {}, existsSync27(oldConfig) ? privateJson(oldConfig) : {}));
   }
   const browserHomes = ["vm-home"];
   const vmHomes = join58(dataDir, "vm-homes");
   if (entryExists(vmHomes)) {
-    if (!lstatSync6(vmHomes).isDirectory()) throw new Error("Stop managed desktops and repair the VM home directory before restoring.");
+    if (!lstatSync7(vmHomes).isDirectory()) throw new Error("Stop managed desktops and repair the VM home directory before restoring.");
     for (const name2 of readdirSync10(vmHomes)) if (validRelative(name2)) browserHomes.push(`vm-homes/${name2}`);
   }
   for (const home of browserHomes) {
     const homePath = join58(dataDir, home);
     if (!entryExists(homePath)) continue;
-    if (!lstatSync6(homePath).isDirectory()) throw new Error("Stop managed desktops and repair the VM home directory before restoring.");
+    if (!lstatSync7(homePath).isDirectory()) throw new Error("Stop managed desktops and repair the VM home directory before restoring.");
     const source = join58(dataDir, home, ".browser-profiles");
     if (!entryExists(source)) continue;
-    folder(join58(prepared, home));
+    folder2(join58(prepared, home));
     cpSync(source, join58(prepared, home, ".browser-profiles"), { recursive: true, dereference: false, verbatimSymlinks: true, errorOnExist: true, force: false });
   }
   changeJson("routines.json", (value) => {
@@ -64714,7 +65096,7 @@ function prepareRestore(dataDir, id, manifest) {
   });
   changeJson("webhooks.json", (value) => {
     if (!record2(value)) throw new Error("Invalid webhook definitions in workspace backup.");
-    const destination = existsSync26(join58(dataDir, "webhooks.json")) ? privateJson(join58(dataDir, "webhooks.json")) : {};
+    const destination = existsSync27(join58(dataDir, "webhooks.json")) ? privateJson(join58(dataDir, "webhooks.json")) : {};
     const oldHooks = record2(destination) && Array.isArray(destination.webhooks) ? destination.webhooks : [];
     if (Array.isArray(value.webhooks)) {
       for (const webhook of value.webhooks) if (record2(webhook)) {
@@ -64731,8 +65113,8 @@ function prepareRestore(dataDir, id, manifest) {
       for (const call of value.calls) if (record2(call)) call.nextRunAt = null;
     }
   });
-  if (existsSync26(join58(prepared, "delegations.json"))) writeJson(join58(prepared, "delegations.json"), {});
-  if (existsSync26(join58(prepared, "browser-cleanups.json"))) writeJson(join58(prepared, "browser-cleanups.json"), []);
+  if (existsSync27(join58(prepared, "delegations.json"))) writeJson(join58(prepared, "delegations.json"), {});
+  if (existsSync27(join58(prepared, "browser-cleanups.json"))) writeJson(join58(prepared, "browser-cleanups.json"), []);
   for (const entry of manifest.entries) {
     if (/^messages-[^/]+\.json$/.test(entry.path)) changeJson(entry.path, (value) => {
       if (Array.isArray(value)) for (const message3 of value) rebaseMessage(message3, manifest.sourceDataDir, resolve15(dataDir));
@@ -64740,7 +65122,7 @@ function prepareRestore(dataDir, id, manifest) {
     });
   }
   const dbPath = join58(prepared, "messages.db");
-  if (existsSync26(dbPath)) {
+  if (existsSync27(dbPath)) {
     const db2 = new DatabaseSync2(dbPath);
     try {
       db2.exec("BEGIN");
@@ -64772,7 +65154,7 @@ function prepareRestore(dataDir, id, manifest) {
 function readLastWorkspaceRestore(dataDir) {
   const root = backupRoot(dataDir);
   const path = join58(root, "last-restore.json");
-  if (!existsSync26(path)) return null;
+  if (!existsSync27(path)) return null;
   const raw = privateJson(path);
   if (!record2(raw) || raw.restored !== true || typeof raw.id !== "string" || !ID.test(raw.id)) throw new Error("Invalid workspace restore receipt.");
   return raw;
@@ -64799,7 +65181,7 @@ function applyPendingWorkspaceRestore(dataDir) {
   const root = backupRoot(dataDir);
   const journalFile2 = join58(root, "restore-journal.json");
   const pendingFile = join58(root, "pending-restore.json");
-  if (existsSync26(journalFile2)) {
+  if (existsSync27(journalFile2)) {
     const previous2 = readJournal(journalFile2);
     if (previous2.phase === "applying") {
       rollback(dataDir, previous2);
@@ -64807,7 +65189,7 @@ function applyPendingWorkspaceRestore(dataDir) {
       rmSync7(pendingFile, { force: true });
       return { restored: false, rolledBack: true, id: previous2.id, safetyCopyPath: join58(root, `safety-${previous2.id}`) };
     }
-    if (previous2.phase === "committed" && existsSync26(pendingFile)) {
+    if (previous2.phase === "committed" && existsSync27(pendingFile)) {
       const pending2 = privateJson(pendingFile);
       if (record2(pending2) && pending2.id === previous2.id) {
         return finishRestore(dataDir, previous2.id);
@@ -64820,8 +65202,8 @@ function applyPendingWorkspaceRestore(dataDir) {
   const manifest = validateStaged(staged);
   const prepared = prepareRestore(dataDir, pending.id, manifest);
   const safetyCopyPath = join58(root, `safety-${pending.id}`);
-  if (existsSync26(safetyCopyPath)) throw new Error("A safety copy already exists for this restore. Original files have not been changed.");
-  folder(join58(safetyCopyPath, "data"));
+  if (existsSync27(safetyCopyPath)) throw new Error("A safety copy already exists for this restore. Original files have not been changed.");
+  folder2(join58(safetyCopyPath, "data"));
   const journal = {
     id: pending.id,
     phase: "applying",
@@ -64832,7 +65214,7 @@ function applyPendingWorkspaceRestore(dataDir) {
     if (!validRelative(name2) || name2.includes("/") || preserved(name2)) throw new Error("Unsafe workspace restore target.");
   }
   writeJson(join58(safetyCopyPath, "manifest.json"), { id: pending.id, createdAt: (/* @__PURE__ */ new Date()).toISOString(), originalEntries: journal.existing });
-  if (existsSync26(join58(root, "last-restore.json"))) writeJson(join58(safetyCopyPath, "previous-restore.json"), privateJson(join58(root, "last-restore.json")));
+  if (existsSync27(join58(root, "last-restore.json"))) writeJson(join58(safetyCopyPath, "previous-restore.json"), privateJson(join58(root, "last-restore.json")));
   writeJson(journalFile2, journal);
   try {
     for (const name2 of journal.existing) renameSync7(join58(dataDir, name2), join58(safetyCopyPath, "data", name2));
@@ -64851,13 +65233,13 @@ function removeWorkspaceBackupJob(dataDir, id) {
   const path = jobPath(dataDir, id);
   const root = backupRoot(dataDir);
   for (const name2 of ["pending-restore.json", "restore-journal.json", "last-restore.json"]) {
-    if (!existsSync26(join58(root, name2))) continue;
+    if (!existsSync27(join58(root, name2))) continue;
     const value = privateJson(join58(root, name2));
     if (record2(value) && value.id === id) throw new Error("This backup is still needed for restore or recovery and cannot be removed.");
   }
-  if (existsSync26(join58(root, `safety-${id}`))) throw new Error("This backup has a recovery copy and cannot be removed.");
+  if (existsSync27(join58(root, `safety-${id}`))) throw new Error("This backup has a recovery copy and cannot be removed.");
   if (!entryExists(path)) return;
-  if (!lstatSync6(path).isDirectory() || lstatSync6(path).isSymbolicLink()) throw new Error("Unsafe workspace backup cleanup target.");
+  if (!lstatSync7(path).isDirectory() || lstatSync7(path).isSymbolicLink()) throw new Error("Unsafe workspace backup cleanup target.");
   rmSync7(path, { recursive: true, force: true });
 }
 
@@ -64867,7 +65249,7 @@ var MAX_UPLOAD_BYTES = MAX_WORKSPACE_BACKUP_UPLOAD_BYTES;
 var MAX_CLIENT_STATE_BYTES = 2 * 1024 ** 2;
 var EXPIRES_MS = 60 * 6e4;
 var passwordSchema = external_exports.string().min(12, "Use a password of at least 12 characters.").max(1024);
-var failure = (message3, status = 400) => Object.assign(new Error(message3), { status });
+var failure3 = (message3, status = 400) => Object.assign(new Error(message3), { status });
 function isWorkspaceBackupSessionControl(method, path) {
   return method === "GET" && path === "/api/auth/sessions" || method === "POST" && path === "/api/auth/logout" || method === "DELETE" && /^\/api\/auth\/sessions\/[\w-]+$/.test(path);
 }
@@ -64880,7 +65262,7 @@ function createWorkspaceBackupRoutes(options) {
   };
   const owner2 = (auth) => auth.kind === "session" ? auth.session.id : "local-owner";
   const check2 = (req, auth) => {
-    if (!options.authorized(req, auth)) throw failure("Your session changed. Reopen Backups and try again.", 403);
+    if (!options.authorized(req, auth)) throw failure3("Your session changed. Reopen Backups and try again.", 403);
   };
   function remove(id, artifact) {
     if (artifact.path) {
@@ -64899,7 +65281,7 @@ function createWorkspaceBackupRoutes(options) {
   }
   function reclaimAbandoned() {
     const root = join59(options.dataDir, ".backups");
-    if (!existsSync27(root) || lstatSync7(root).isSymbolicLink()) return;
+    if (!existsSync28(root) || lstatSync8(root).isSymbolicLink()) return;
     for (const entry of readdirSync11(root, { withFileTypes: true })) {
       if (!entry.isDirectory() || !/^[a-f0-9-]{36}$/.test(entry.name)) continue;
       if (statSync10(join59(root, entry.name)).mtimeMs + EXPIRES_MS > Date.now()) continue;
@@ -64909,7 +65291,7 @@ function createWorkspaceBackupRoutes(options) {
       }
     }
     const uploads = join59(root, "uploads");
-    if (!existsSync27(uploads) || lstatSync7(uploads).isSymbolicLink()) return;
+    if (!existsSync28(uploads) || lstatSync8(uploads).isSymbolicLink()) return;
     for (const entry of readdirSync11(uploads, { withFileTypes: true })) {
       if (!entry.isFile() || !/^[a-f0-9-]{36}\.ombbackup$/.test(entry.name)) continue;
       const file2 = join59(uploads, entry.name);
@@ -64939,12 +65321,12 @@ function createWorkspaceBackupRoutes(options) {
     expire();
     const artifact = typeof id === "string" ? artifacts.get(id) : void 0;
     if (!artifact || artifact.owner !== owner2(auth) || artifact.kind !== kind) {
-      throw failure("This backup has expired or belongs to another session. Select the file again.", 404);
+      throw failure3("This backup has expired or belongs to another session. Select the file again.", 404);
     }
     return artifact;
   };
   async function operate(work) {
-    if (operating) throw failure("Another backup operation is in progress. Wait for it to finish.", 409);
+    if (operating) throw failure3("Another backup operation is in progress. Wait for it to finish.", 409);
     operating = true;
     try {
       return await work();
@@ -64969,18 +65351,18 @@ function createWorkspaceBackupRoutes(options) {
       if (method === "POST" && path === `${PREFIX}/client-state`) {
         const body = external_exports.object({ restoreId: external_exports.string().uuid() }).parse(await options.readBody(req));
         check2(req, auth);
-        if (!options.restored.restored || body.restoreId !== options.restored.id) throw failure("This restore has not completed. Restart OpenMausBot first.", 409);
+        if (!options.restored.restored || body.restoreId !== options.restored.id) throw failure3("This restore has not completed. Restart OpenMausBot first.", 409);
         json4(res, 200, { clientState: options.restored.clientState ?? {} });
         return true;
       }
       if (method === "POST" && path === `${PREFIX}/export`) {
         const body = external_exports.object({ password: passwordSchema, clientState: external_exports.record(external_exports.string(), external_exports.string()).default({}) }).parse(await options.readBody(req, MAX_CLIENT_STATE_BYTES + 8 * 1024));
-        if (Buffer.byteLength(JSON.stringify(body.clientState)) > MAX_CLIENT_STATE_BYTES) throw failure("Saved drafts exceed the 2 MB backup preference limit.", 413);
+        if (Buffer.byteLength(JSON.stringify(body.clientState)) > MAX_CLIENT_STATE_BYTES) throw failure3("Saved drafts exceed the 2 MB backup preference limit.", 413);
         const clientState = Object.fromEntries(Object.entries(body.clientState).filter(([key3]) => WORKSPACE_BACKUP_CLIENT_KEYS.includes(key3)));
         const result = await operate(() => options.exclusive(async () => {
           check2(req, auth);
           replacePrevious(auth, ["download"]);
-          if (artifacts.size >= 4) throw failure("There are already four backup files in progress. Restart or wait an hour before creating another.", 409);
+          if (artifacts.size >= 4) throw failure3("There are already four backup files in progress. Restart or wait an hour before creating another.", 409);
           return createWorkspaceBackup(options.dataDir, { password: body.password, clientState, appVersion: options.appVersion });
         }));
         try {
@@ -65009,25 +65391,25 @@ function createWorkspaceBackupRoutes(options) {
       if (method === "POST" && path === `${PREFIX}/upload`) {
         await operate(async () => {
           const length = Number(req.headers["content-length"]);
-          if (!Number.isSafeInteger(length) || length <= 0 || length > MAX_UPLOAD_BYTES) throw failure("Select a backup containing no more than 10 GB of workspace data.", 413);
+          if (!Number.isSafeInteger(length) || length <= 0 || length > MAX_UPLOAD_BYTES) throw failure3("Select a backup containing no more than 10 GB of workspace data.", 413);
           replacePrevious(auth, ["upload", "staged"]);
-          if (artifacts.size >= 4) throw failure("There are already four backup files in progress. Restart or wait an hour before uploading another.", 409);
+          if (artifacts.size >= 4) throw failure3("There are already four backup files in progress. Restart or wait an hour before uploading another.", 409);
           const root = join59(options.dataDir, ".backups");
           mkdirSync29(root, { recursive: true, mode: 448 });
-          if (lstatSync7(root).isSymbolicLink()) throw failure("Backup storage must not be a symbolic link.");
+          if (lstatSync8(root).isSymbolicLink()) throw failure3("Backup storage must not be a symbolic link.");
           const directory = join59(root, "uploads");
           mkdirSync29(directory, { recursive: true, mode: 448 });
-          if (lstatSync7(directory).isSymbolicLink()) throw failure("Backup storage must not be a symbolic link.");
-          const id = randomUUID23();
+          if (lstatSync8(directory).isSymbolicLink()) throw failure3("Backup storage must not be a symbolic link.");
+          const id = randomUUID25();
           const file2 = join59(directory, `${id}.ombbackup`);
           let bytes = 0;
           try {
             const limit = new Transform2({ transform(chunk, _encoding, callback) {
               bytes += chunk.length;
-              callback(bytes > MAX_UPLOAD_BYTES ? failure("The backup is too large.", 413) : null, chunk);
+              callback(bytes > MAX_UPLOAD_BYTES ? failure3("The backup is too large.", 413) : null, chunk);
             } });
             await pipeline3(req.iterator({ destroyOnReturn: false }), limit, createWriteStream3(file2, { flags: "wx", mode: 384 }));
-            if (bytes !== length) throw failure("The upload was incomplete. Select the file again.");
+            if (bytes !== length) throw failure3("The upload was incomplete. Select the file again.");
             check2(req, auth);
             artifacts.set(id, { owner: owner2(auth), kind: "upload", path: file2, expires: Date.now() + EXPIRES_MS });
             json4(res, 200, { id });
@@ -65681,17 +66063,17 @@ function unavailable(error51) {
 }
 
 // server/provider-auth-sessions.ts
-var failure2 = (message3, status) => Object.assign(new Error(message3), { status });
+var failure4 = (message3, status) => Object.assign(new Error(message3), { status });
 var ProviderAuthSessions = class {
   flows = /* @__PURE__ */ new Map();
   get active() {
     return [...this.flows.values()].some((flow3) => flow3.busy || !flow3.revoked && flow3.expiresAt > Date.now());
   }
   async start(instance, owner2) {
-    if (!instance.startAuthentication) throw failure2("Account setup is unavailable for this provider.", 404);
+    if (!instance.startAuthentication) throw failure4("Account setup is unavailable for this provider.", 404);
     const existing = this.flows.get(instance.instanceId);
     if (existing && (existing.busy || existing.owner !== owner2 && existing.expiresAt > Date.now())) {
-      throw failure2("A sign-in is already in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
+      throw failure4("A sign-in is already in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
     }
     const resuming = existing && existing.owner === owner2 && existing.expiresAt > Date.now() && !existing.revoked;
     const flow3 = resuming ? existing : { instance, owner: owner2, flowId: null, expiresAt: Date.now() + 15 * 6e4, busy: false, starting: false, revoked: false };
@@ -65702,7 +66084,7 @@ var ProviderAuthSessions = class {
       const result = await instance.startAuthentication();
       if (flow3.revoked || this.flows.get(instance.instanceId) !== flow3) {
         await instance.cancelAuthentication?.();
-        throw failure2("Sign-in cancelled because the session or provider changed.", 409);
+        throw failure4("Sign-in cancelled because the session or provider changed.", 409);
       }
       flow3.flowId = result.flowId;
       const expiry = Date.parse(result.expiresAt ?? "");
@@ -65720,22 +66102,22 @@ var ProviderAuthSessions = class {
   owned(instanceId, owner2, flowId) {
     const flow3 = this.flows.get(instanceId);
     if (!flowId || !flow3 || flow3.revoked || flow3.owner !== owner2 || flow3.flowId !== flowId) {
-      throw failure2("This sign-in is no longer available in this browser. Start a new sign-in.", 404);
+      throw failure4("This sign-in is no longer available in this browser. Start a new sign-in.", 404);
     }
-    if (flow3.busy) throw failure2("The sign-in is still being updated. Try again shortly.", 409);
+    if (flow3.busy) throw failure4("The sign-in is still being updated. Try again shortly.", 409);
     return flow3;
   }
   async status(instanceId, owner2, flowId) {
     const flow3 = this.owned(instanceId, owner2, flowId);
-    if (!flow3.instance.getAuthentication) throw failure2("Sign-in status is unavailable for this provider.", 404);
+    if (!flow3.instance.getAuthentication) throw failure4("Sign-in status is unavailable for this provider.", 404);
     const status = await flow3.instance.getAuthentication(flowId);
-    if (flow3.revoked) throw failure2("This sign-in session ended.", 404);
+    if (flow3.revoked) throw failure4("This sign-in session ended.", 404);
     if (status.phase !== "waiting") flow3.expiresAt = 0;
     return status;
   }
   async complete(instanceId, owner2, flowId, callbackUrl) {
     const flow3 = this.owned(instanceId, owner2, flowId);
-    if (!flow3.instance.completeAuthentication) throw failure2("This provider does not use a callback URL.", 400);
+    if (!flow3.instance.completeAuthentication) throw failure4("This provider does not use a callback URL.", 400);
     flow3.busy = true;
     try {
       await flow3.instance.completeAuthentication(flowId, callbackUrl);
@@ -65758,10 +66140,10 @@ var ProviderAuthSessions = class {
    * admin is still completing must not be pulled away underneath them, and
    * nobody may start one while the credential is being removed. */
   async signOut(instance, owner2) {
-    if (!instance.signOut) throw failure2("Sign-out is unavailable for this provider.", 404);
+    if (!instance.signOut) throw failure4("Sign-out is unavailable for this provider.", 404);
     const existing = this.flows.get(instance.instanceId);
     if (existing && (existing.busy || existing.owner !== owner2 && existing.expiresAt > Date.now() && !existing.revoked)) {
-      throw failure2("A sign-in is in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
+      throw failure4("A sign-in is in progress. Finish or cancel it in the browser that started it, or wait for it to expire.", 409);
     }
     const flow3 = { instance, owner: owner2, flowId: null, expiresAt: Date.now() + 6e4, busy: true, starting: false, revoked: false };
     this.flows.set(instance.instanceId, flow3);
@@ -65796,7 +66178,7 @@ var ProviderAuthSessions = class {
 };
 
 // server/request-auth.ts
-import { timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 import { isIP as isIP2 } from "node:net";
 
 // companion/src/routes.ts
@@ -66063,6 +66445,11 @@ var CLIENT_ALLOW = [
   { methods: ["GET"], path: /^\/api\/auth\/session$/ },
   { methods: ["POST"], path: /^\/api\/auth\/stream-ticket$/ },
   { methods: ["POST"], path: /^\/api\/auth\/logout$/ },
+  // Own outbound desktop connector, additionally bound to a private secret.
+  // Only honoured while features.sharedComputers is on (see requiredScope):
+  // with the feature off these paths are as unlisted as any other, so a
+  // client session is refused exactly the way an unknown route refuses it.
+  { methods: ["POST"], path: /^\/api\/shared-computers\/(?:connect|[\w-]+\/(?:poll|lease|result|disconnect))$/, feature: "sharedComputers" },
   // liveness, identity, the stream
   { methods: ["GET"], path: /^\/api\/health$/ },
   { methods: ["GET"], path: /^\/api\/edition$/ },
@@ -66127,9 +66514,10 @@ var CLIENT_ALLOW = [
   // configured-or-not booleans; the handler strips the few identifying fields for clients
   { methods: ["GET"], path: /^\/api\/config$/ }
 ];
-function requiredScope(method, path) {
+function requiredScope(method, path, features = {}) {
   const upper = method.toUpperCase();
   for (const rule of CLIENT_ALLOW) {
+    if (rule.feature && features[rule.feature] !== true) continue;
     if (rule.path.test(path) && rule.methods.includes(upper)) return "client";
   }
   return "admin";
@@ -66157,7 +66545,7 @@ function secureTokenMatch(actual, expected) {
   if (!actual || !expected) return false;
   const left = Buffer.from(actual);
   const right = Buffer.from(expected);
-  return left.length === right.length && timingSafeEqual2(left, right);
+  return left.length === right.length && timingSafeEqual3(left, right);
 }
 function resolveRequestAuth(req, options) {
   const method = req.method ?? "GET";
@@ -66180,13 +66568,16 @@ function resolveRequestAuth(req, options) {
   }
   if (session && via) {
     if (via === "cookie" && !isSameOrigin(req)) return deny(403, "forbidden: cross-origin request");
-    const needed = requiredScope(method, path);
+    const needed = requiredScope(method, path, options.features ?? {});
     if (!session.scopes.includes(needed)) {
       return deny(403, `forbidden: this session lacks the ${needed} scope`);
     }
     if (via !== "ticket") options.sessions.renew(session.id);
     return { auth: { kind: "session", session, via, scopes: session.scopes }, status: 401, error: "" };
   }
+  if (via) {
+    return deny(401, "unauthorized: this session has expired or was revoked; pair this device again");
+  }
   const proxied = isProxied(req);
   const loopback2 = !proxied && isLoopbackHost(headerValue(req.headers.host)) && isAllowedOrigin(headerValue(req.headers.origin));
   if (loopback2) {
@@ -66200,9 +66591,6 @@ function resolveRequestAuth(req, options) {
     }
     return { auth: { kind: "loopback", scopes: LOOPBACK_SCOPES }, status: 401, error: "" };
   }
-  if (via) {
-    return deny(401, "unauthorized: this session has expired or was revoked; pair this device again");
-  }
   if (proxied) {
     return deny(403, "forbidden: this request came through a proxy (pair this device to use the server remotely)");
   }
@@ -66213,8 +66601,8 @@ function resolveRequestAuth(req, options) {
 }
 
 // server/sessions.ts
-import { createHash as createHash27, randomBytes as randomBytes8, randomUUID as randomUUID24, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
-import { chmodSync as chmodSync7, existsSync as existsSync28, mkdirSync as mkdirSync30, readFileSync as readFileSync40, renameSync as renameSync8, writeFileSync as writeFileSync18 } from "node:fs";
+import { createHash as createHash27, randomBytes as randomBytes8, randomUUID as randomUUID26, timingSafeEqual as timingSafeEqual4 } from "node:crypto";
+import { closeSync as closeSync12, existsSync as existsSync29, fsyncSync as fsyncSync4, mkdirSync as mkdirSync30, openSync as openSync12, readFileSync as readFileSync41, unlinkSync as unlinkSync12 } from "node:fs";
 import { dirname as dirname18 } from "node:path";
 var SCOPES = ["admin", "client"];
 var PAIRING_CODE_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
@@ -66247,14 +66635,16 @@ var sessionSchema = external_exports.object({
   expiresAt: external_exports.number(),
   /** Set when the session came from an account sign-in rather than a code. */
   userId: external_exports.string().max(256).optional(),
-  email: external_exports.string().max(320).optional()
+  email: external_exports.string().max(320).optional(),
+  /** Set only by the internal verified-portal issuance path, never by email or pairing input. */
+  membershipAuthority: external_exports.literal("portal").optional()
 });
-var fileSchema2 = external_exports.object({ version: external_exports.literal(1), sessions: external_exports.array(sessionSchema) });
+var fileSchema3 = external_exports.object({ version: external_exports.literal(1), sessions: external_exports.array(sessionSchema) });
 var sha2562 = (value) => createHash27("sha256").update(value).digest("hex");
 function sameDigest(a, b2) {
   const left = Buffer.from(a, "hex");
   const right = Buffer.from(b2, "hex");
-  return left.length === right.length && timingSafeEqual3(left, right);
+  return left.length === right.length && timingSafeEqual4(left, right);
 }
 function generatePairingCode() {
   const limit = Math.floor(256 / PAIRING_CODE_ALPHABET.length) * PAIRING_CODE_ALPHABET.length;
@@ -66296,34 +66686,69 @@ var SessionRegistry = class {
   lastSeenWrites = /* @__PURE__ */ new Map();
   now;
   options;
+  openMarker;
+  closed = false;
   // No parameter properties: the server runs this file under Node's
   // strip-only TypeScript mode, which only erases types.
   constructor(options) {
     this.options = options;
     this.now = options.now ?? Date.now;
-    this.load();
+    this.openMarker = `${options.file}.open`;
+    const unclean = existsSync29(this.openMarker);
+    try {
+      mkdirSync30(dirname18(options.file), { recursive: true, mode: 448 });
+      writeFileAtomic(this.openMarker, "Session registry is open.\n", { mode: 384 });
+      this.syncDirectory();
+    } catch {
+      throw new Error("Could not establish safe session storage.");
+    }
+    this.load(!unclean);
+    this.revalidateEmailSessions();
   }
-  load() {
-    if (!existsSync28(this.options.file)) return;
+  load(restoreAccounts) {
+    if (!existsSync29(this.options.file)) return;
     let raw;
     try {
-      raw = JSON.parse(readFileSync40(this.options.file, "utf8"));
+      raw = JSON.parse(readFileSync41(this.options.file, "utf8"));
     } catch {
       return;
     }
-    const parsed = fileSchema2.safeParse(raw);
-    if (parsed.success) this.sessions = parsed.data.sessions;
+    const parsed = fileSchema3.safeParse(raw);
+    if (parsed.success) this.sessions = parsed.data.sessions.filter((session) => restoreAccounts || session.email === void 0 && session.userId === void 0);
+  }
+  syncDirectory() {
+    if (process.platform === "win32") return;
+    const fd = openSync12(dirname18(this.options.file), "r");
+    try {
+      fsyncSync4(fd);
+    } finally {
+      closeSync12(fd);
+    }
   }
   /** Atomic write, owner-only, directory owner-only. */
   persist() {
+    if (this.closed) throw new Error("Session registry is closed.");
     const dir = dirname18(this.options.file);
     mkdirSync30(dir, { recursive: true, mode: 448 });
-    const tmp = `${this.options.file}.${process.pid}.tmp`;
-    writeFileSync18(tmp, JSON.stringify({ version: 1, sessions: this.sessions }, null, 2) + "\n", { mode: 384 });
-    chmodSync7(tmp, 384);
-    renameSync8(tmp, this.options.file);
+    writeFileAtomic(this.options.file, JSON.stringify({ version: 1, sessions: this.sessions }, null, 2) + "\n", { mode: 384 });
+    this.syncDirectory();
+  }
+  /** Call after HTTP/stream shutdown. A failed close leaves the open marker,
+   * so account sessions require fresh sign-in after restart. Paired devices
+   * remain durable. Never remove the marker before the reduced set is saved. */
+  close() {
+    if (this.closed) return;
+    try {
+      this.revalidateEmailSessions();
+      this.persist();
+      unlinkSync12(this.openMarker);
+      this.closed = true;
+    } catch {
+      throw new Error("Could not safely close session storage.");
+    }
   }
   prune() {
+    this.revalidateEmailSessions();
     const now = this.now();
     this.pairings = this.pairings.filter((p2) => p2.expiresAt > now);
     this.replays = this.replays.filter((r) => r.expiresAt > now);
@@ -66356,7 +66781,7 @@ var SessionRegistry = class {
     const code = generatePairingCode();
     const scopes = input.scopes?.length ? [...new Set(input.scopes)] : [...SCOPES];
     const pairing = {
-      id: randomUUID24(),
+      id: randomUUID26(),
       codeHash: sha2562(code),
       scopes,
       label: (input.label ?? "").trim().slice(0, 80),
@@ -66428,7 +66853,7 @@ var SessionRegistry = class {
     this.failures.delete(input.source);
     const token = `omb_sess_${randomBytes8(32).toString("base64url")}`;
     const record3 = {
-      id: randomUUID24(),
+      id: randomUUID26(),
       tokenHash: sha2562(token),
       label: (input.label.trim() || pairing.label || input.fallbackLabel?.trim() || "Unnamed device").slice(0, 80),
       scopes: [...pairing.scopes],
@@ -66448,11 +66873,20 @@ var SessionRegistry = class {
   /** A session from a verified account sign-in (server/account-signin.ts)
    * rather than a pairing code: same token, same term, same gates. */
   issue(input) {
+    return this.issueAccount(input);
+  }
+  /** Internal hosted-bridge seam: call only after consuming a verified,
+   * workspace-bound PKCE grant. No HTTP route accepts this marker as input. */
+  issuePortal(input) {
+    if (!/^[A-Za-z0-9_-]{43}$/.test(input.grant) || !input.email) throw new Error("A verified portal identity is required");
+    return this.issueAccount({ label: "Hosted workspace", email: input.email, userId: `portal:${input.grant}`, scopes: input.scopes }, "portal");
+  }
+  issueAccount(input, membershipAuthority) {
     this.prune();
     const now = this.now();
     const token = `omb_sess_${randomBytes8(32).toString("base64url")}`;
     const record3 = {
-      id: randomUUID24(),
+      id: randomUUID26(),
       tokenHash: sha2562(token),
       label: (input.label.trim() || "Unnamed device").slice(0, 80),
       scopes: [...new Set(input.scopes)],
@@ -66462,6 +66896,7 @@ var SessionRegistry = class {
     };
     if (input.userId) record3.userId = input.userId;
     if (input.email) record3.email = input.email;
+    if (membershipAuthority) record3.membershipAuthority = membershipAuthority;
     this.sessions.push(record3);
     this.lastSeenWrites.set(record3.id, now);
     this.persist();
@@ -66479,8 +66914,41 @@ var SessionRegistry = class {
     this.failures.delete(source);
   }
   // ── sessions ───────────────────────────────────────────────────────────
+  /** Email membership is live, not a thirty-day grant. Losing any issued
+   * scope revokes the token and its streams; signing in again obtains the
+   * new role. Promotions never widen existing credentials. Pairing sessions
+   * have no email and remain independent of the hosted sign-in list. */
+  revalidateEmailSessions() {
+    if (this.closed) throw new Error("Session registry is closed.");
+    const eligible = this.sessions.filter((session) => session.email !== void 0 && !(this.options.portalMembership && session.membershipAuthority === "portal"));
+    if (!eligible.length) return;
+    let resolveScopes = this.options.emailScopes;
+    try {
+      if (this.options.emailScopesSnapshot) resolveScopes = this.options.emailScopesSnapshot();
+    } catch {
+      resolveScopes = void 0;
+    }
+    const revoked = eligible.filter((session) => {
+      try {
+        const allowed = resolveScopes?.(session.email);
+        return !allowed || session.scopes.some((scope) => !allowed.includes(scope));
+      } catch {
+        return true;
+      }
+    });
+    if (!revoked.length) return;
+    const ids = new Set(revoked.map((session) => session.id));
+    this.sessions = this.sessions.filter((session) => !ids.has(session.id));
+    for (const session of revoked) this.forget(session.id);
+    try {
+      this.persist();
+    } catch {
+      console.error("Could not persist email session revocation.");
+    }
+  }
   authenticate(token) {
     if (!token) return null;
+    this.revalidateEmailSessions();
     const hash2 = sha2562(token);
     const now = this.now();
     const record3 = this.sessions.find((s3) => sameDigest(s3.tokenHash, hash2));
@@ -66500,6 +66968,7 @@ var SessionRegistry = class {
    * Nothing expired is revived. Writes at most once per half-term, so it
    * adds nothing to the last-seen traffic. Returns whether it renewed. */
   renew(sessionId) {
+    this.revalidateEmailSessions();
     const record3 = this.sessions.find((s3) => s3.id === sessionId);
     const now = this.now();
     if (!record3 || record3.expiresAt <= now) return false;
@@ -66553,7 +67022,7 @@ var SessionRegistry = class {
 };
 
 // server/brand.ts
-import { existsSync as existsSync29, readFileSync as readFileSync41 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync42 } from "node:fs";
 import { join as join60 } from "node:path";
 var HEX_COLOUR = /^#[0-9a-fA-F]{6}$/;
 var MAX_LOGO_CHARS = 3e5;
@@ -66580,10 +67049,10 @@ function loadBrand(options = {}) {
   const file2 = options.file ?? brandFile();
   const isEntitled = options.isEntitled ?? entitled;
   const fallback = (notice) => notice ? { brand: DEFAULT_BRAND, source: "default", file: file2, notice } : { brand: DEFAULT_BRAND, source: "default", file: file2 };
-  if (!existsSync29(file2)) return fallback();
+  if (!existsSync30(file2)) return fallback();
   let raw;
   try {
-    raw = JSON.parse(readFileSync41(file2, "utf8"));
+    raw = JSON.parse(readFileSync42(file2, "utf8"));
   } catch (error51) {
     return fallback(`${file2} is not valid JSON (${error51 instanceof Error ? error51.message : String(error51)}); using the default brand`);
   }
@@ -69094,7 +69563,7 @@ function releaseDataDirLeaseAtExit() {
 }
 process.once("exit", releaseDataDirLeaseAtExit);
 var workspaceRestore = { restored: false };
-if (existsSync30(join61(DATA_DIR, ".backups"))) {
+if (existsSync31(join61(DATA_DIR, ".backups"))) {
   workspaceRestore = applyPendingWorkspaceRestore(DATA_DIR);
   if (!workspaceRestore.restored && !workspaceRestore.rolledBack) {
     workspaceRestore = readLastWorkspaceRestore(DATA_DIR) ?? workspaceRestore;
@@ -69102,8 +69571,22 @@ if (existsSync30(join61(DATA_DIR, ".backups"))) {
 }
 var workspaceMaintenance = new WorkspaceBackupMaintenance();
 var ENVIRONMENT_ID = loadEnvironmentId(DATA_DIR);
-var sessions = new SessionRegistry({ file: join61(DATA_DIR, "sessions.json") });
+function signInAllowList() {
+  const current2 = loadConfig().signIn;
+  return { admins: parseAllowList(current2?.admins?.join(",")), members: parseAllowList(current2?.members?.join(",")) };
+}
+var sessions = new SessionRegistry({
+  file: join61(DATA_DIR, "sessions.json"),
+  emailScopesSnapshot: () => {
+    const membership = signInAllowList();
+    return (email3) => allowedScopes(email3, membership);
+  },
+  portalMembership: hostedWorkspaceConfiguration()?.portalMembership === true
+});
+var sharedComputers = new SharedComputers((id) => sessions.isLive(id));
 var SESSION_COOKIE = sessionCookieName(PORT, ENVIRONMENT_ID);
+var HOSTED_WORKSPACE = hostedWorkspaceConfigured();
+var workspaceAccess = null;
 var DESKTOP_MANAGED = process.env.OMB_DESKTOP_PARENT === "1";
 var desktopMutationToken = DESKTOP_MANAGED ? "" : void 0;
 var companionMutationToken = DESKTOP_MANAGED ? "" : void 0;
@@ -69111,10 +69594,7 @@ var FALLBACK_PUBLIC_URL = process.env.OMB_PUBLIC_URL?.trim().replace(/\/+$/, "")
 var cfg = loadConfig();
 var customDomainVerifier = createCustomDomainVerifier({ environmentId: ENVIRONMENT_ID });
 var emailSignIn = createEmailSignIn({
-  allow: () => {
-    const current2 = loadConfig().signIn;
-    return { admins: parseAllowList(current2?.admins?.join(",")), members: parseAllowList(current2?.members?.join(",")) };
-  }
+  allow: signInAllowList
 });
 var customDomainRevision = 0;
 function savedCustomDomain() {
@@ -69216,7 +69696,7 @@ var INTERNAL_CAPABILITY_ORPHAN_MS = 30 * 24 * 60 * 6e4;
 var internalCapabilities = /* @__PURE__ */ new Map();
 var activeInternalGenerationByThread = /* @__PURE__ */ new Map();
 var internalGenerationByProviderTurn = new ProviderTurnGenerationRegistry();
-function beginInternalCapabilityGeneration(threadId, generation = randomUUID25()) {
+function beginInternalCapabilityGeneration(threadId, generation = randomUUID27()) {
   const previous2 = activeInternalGenerationByThread.get(threadId);
   if (previous2) revokeInternalCapabilityGeneration(threadId, previous2);
   activeInternalGenerationByThread.set(threadId, generation);
@@ -69275,11 +69755,15 @@ function authorizedInternalCapability(header2) {
       continue;
     }
     const expected = Buffer.from(`Bearer ${token}`);
-    if (got.length === expected.length && timingSafeEqual4(got, expected)) return capability;
+    if (got.length === expected.length && timingSafeEqual5(got, expected)) return capability;
   }
   return null;
 }
 function internalCapabilityIsActive(capability) {
+  if (capability.teamComputerId) {
+    const pinned = teamComputerTurns.get(capability.threadId);
+    if (pinned?.computerId !== capability.teamComputerId || pinned.owner.generation !== capability.generation || pinned.botId !== capability.botId) return false;
+  }
   if (capability.localVmTarget) {
     const owner2 = localVmLeaseFor(capability.localVmTarget).current(localVmOwnerBusy);
     if (localVmThreadTargets.get(capability.threadId) !== capability.localVmTarget || owner2?.threadId !== capability.threadId || owner2.botId !== capability.botId) return false;
@@ -69306,7 +69790,7 @@ var phoneSecretEnvelopeSchema = external_exports.object({
 var agentsProxyPath = SPAWNED_PROXIES.agents;
 var phoneProxyPath = SPAWNED_PROXIES.phone;
 var AGENTS_NODE_FLAG = { ELECTRON_RUN_AS_NODE: "1" };
-function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, roomHandoffId, roomCoordination = false) {
+function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, roomHandoffId, roomCoordination = false, ownThreadCreation = false) {
   const token = mintInternalCapability({
     botId,
     threadId,
@@ -69317,7 +69801,8 @@ function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, r
     createdBots: 0,
     openedThreads: 0,
     roomHandoffId,
-    roomCoordination
+    roomCoordination,
+    ownThreadCreation
   });
   return {
     command: process.execPath,
@@ -69330,7 +69815,11 @@ function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, r
       OMB_COMMS_TOKEN: token,
       OMB_TURN_DEPTH: String(depth),
       OMB_ROOM_TURN: roomCoordination ? "1" : "0",
-      OMB_SKILL_AUTHORING_ENABLED: skillAuthoring ? "1" : "0"
+      OMB_OWN_THREAD_CREATION: ownThreadCreation ? "1" : "0",
+      OMB_SKILL_AUTHORING_ENABLED: skillAuthoring ? "1" : "0",
+      // The shared-computer tools are advertised only while the workspace
+      // gate is on; the routes behind them refuse regardless.
+      OMB_SHARED_COMPUTERS_ENABLED: sharedComputersEnabled(cfg) ? "1" : "0"
     }
   };
 }
@@ -69360,8 +69849,10 @@ function settleDirectFollowup(generation) {
 var directTurnBots = /* @__PURE__ */ new Map();
 var providerFleetReloading = false;
 var turnResources = new TurnResources();
+var sharedComputerControl = new SharedComputerControl(turnResources, () => store.bots.some((bot) => botComputerControlSnapshot(bot.id).held));
 var turnResourceOwners = /* @__PURE__ */ new Map();
 var turnComputerResources = /* @__PURE__ */ new Map();
+var teamComputerTurns = /* @__PURE__ */ new Map();
 var settlingResourceOwners = /* @__PURE__ */ new Map();
 function claimTurnResource(owner2, resource) {
   if (!turnResources.claim(resource, owner2)) return false;
@@ -69374,6 +69865,11 @@ function releaseTurnResources(owner2) {
   turnResources.release(owner2);
   if (turnResourceOwners.get(owner2.threadId)?.generation === owner2.generation) turnResourceOwners.delete(owner2.threadId);
   if (turnComputerResources.get(owner2.threadId)?.owner.generation === owner2.generation) turnComputerResources.delete(owner2.threadId);
+  const teamTurn = teamComputerTurns.get(owner2.threadId);
+  if (teamTurn?.owner.generation === owner2.generation) {
+    stopScreenPoller(teamTurn.botId, owner2.threadId);
+    teamComputerTurns.delete(owner2.threadId);
+  }
 }
 function bindTurnComputer(owner2, resource, exclusive = false) {
   if (exclusive && !claimTurnResource(owner2, resource)) {
@@ -69592,12 +70088,15 @@ function connectedAppsIntegration(botId, threadId, generation) {
   });
 }
 var computerControlRevision = /* @__PURE__ */ new Map();
-var computerControl = new ComputerControl((botId, snapshot2) => {
-  computerControlRevision.set(botId, (computerControlRevision.get(botId) ?? 0) + 1);
-  if (snapshot2.held && /^[A-Za-z0-9_-]{1,120}$/.test(botId)) {
-    postDesktopPrivateMessage({ type: "openmausbot:browser-control", botId, held: true });
+var computerControl = new ComputerControl((key3, snapshot2) => {
+  const members = key3.startsWith("computer_") ? store.bots.filter((bot) => inheritedTeamComputer(bot)?.id === key3.slice("computer_".length)).map((bot) => bot.id) : [key3];
+  for (const botId of members) {
+    computerControlRevision.set(botId, (computerControlRevision.get(botId) ?? 0) + 1);
+    if (snapshot2.held && /^[A-Za-z0-9_-]{1,120}$/.test(botId)) {
+      postDesktopPrivateMessage({ type: "openmausbot:browser-control", botId, held: true });
+    }
+    broadcast({ kind: "computer-control", botId, held: snapshot2.held, helpReason: snapshot2.helpReason });
   }
-  broadcast({ kind: "computer-control", botId, held: snapshot2.held, helpReason: snapshot2.helpReason });
 });
 var controlLeaseIdSchema = external_exports.string().min(16).max(120).regex(/^[A-Za-z0-9_-]+$/);
 var routineRequestSourceSchema = {
@@ -69626,6 +70125,7 @@ function controlIntegration(botId, threadId, generation, localVmTarget) {
       depth: 0,
       kind: "computer",
       ...localVmTarget ? { localVmTarget } : {},
+      ...teamComputerTurns.get(threadId) ? { teamComputerId: teamComputerTurns.get(threadId).computerId } : {},
       skillAuthoring: false,
       createdBots: 0,
       openedThreads: 0
@@ -69823,6 +70323,7 @@ function checkedMemberIds(value) {
 }
 var bootSelection = { instanceId: "", model: "" };
 var store = new Store(() => bootSelection);
+var teamComputers = new TeamComputers(join61(DATA_DIR, "team-computers.json"), ENVIRONMENT_ID);
 var followupsReady = false;
 var sendSequencer = new SendSequencer();
 bootSelection = await defaultSelection();
@@ -69846,7 +70347,7 @@ var activeCoordinationForThread = (_threadId) => false;
 var wireTask = ({ resumeCursors: _resumeCursors, lastInstanceId: _lastInstanceId, ...task2 }) => activeCoordinationForThread(task2.threadId) && !task2.busy ? { ...task2, busy: true, activity: "working" } : task2;
 var wireBot = (bot) => {
   const { resumeCursors: _resumeCursors, tasks, approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, ...rest } = bot;
-  const visible = approvalGrant ? { ...rest, approvalMode: "ask", autoApprove: false } : rest;
+  const visible = approvalGrant && !approvalGrant.threadOnly ? { ...rest, approvalMode: "ask", autoApprove: false } : rest;
   return {
     ...visible,
     ...activeCoordinationForThread(bot.threadId) && !visible.busy ? { busy: true, activity: "working" } : {},
@@ -69856,7 +70357,7 @@ var wireBot = (bot) => {
 };
 var wireTrustedApprovalBot = (bot) => {
   const { resumeCursors: _resumeCursors, tasks, approvalGrant: _approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, ...rest } = bot;
-  return { ...rest, avatarUrl: rest.avatarUrl ?? null, ...tasks ? { tasks: tasks.map(wireTask) } : {} };
+  return { ...rest, approvalMode: approvalModeFor(rest), avatarUrl: rest.avatarUrl ?? null, ...tasks ? { tasks: tasks.map(wireTask) } : {} };
 };
 function previewSystemPrompt(bot) {
   const persona = [
@@ -69866,12 +70367,14 @@ function previewSystemPrompt(bot) {
   ].filter(Boolean).join(" ");
   const instance = registry2.get(bot.modelSelection.instanceId);
   const caps = instance?.adapter.capabilities;
-  const computerPromptKind = bot.computer === "vm" ? caps?.computerMcp ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : null : bot.computer === "cloud" ? instance?.driverKind === "boxAgent" ? "box-agent" : caps?.computerMcp ? bot.cloudBackend === "vps" ? "vps" : "box" : null : bot.computer === "local" ? caps?.localComputerMcp ? "local" : null : null;
+  const teamComputer = inheritedTeamComputer(bot);
+  const previewComputer = teamComputer ? "cloud" : bot.computer;
+  const computerPromptKind = previewComputer === "vm" ? caps?.computerMcp ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : null : previewComputer === "cloud" ? instance?.driverKind === "boxAgent" ? "box-agent" : caps?.computerMcp ? bot.cloudBackend === "vps" ? "vps" : "box" : null : previewComputer === "local" ? caps?.localComputerMcp ? "local" : null : null;
   const peers = reachablePeers(store.bots, bot);
   const coordination = bot.chiefOfStaff ? chiefOfStaffSystemPrompt(bot.id, store.bots, true, openMausStatusSystemPrompt()) : peers.length > 0 ? peerRosterSystemPrompt(peers) : "";
   const agentsMounted = caps?.agentsMcp === true;
   const previewPlan = resolveSurface({
-    destination: bot.computer,
+    destination: previewComputer,
     browserOn: caps?.browserMcp === true && builtInBrowserEnabled(cfg) && bot.browser !== false
   });
   const privateWorkspace = instance && !["grok", "boxAgent"].includes(instance.driverKind);
@@ -69885,6 +70388,7 @@ function previewSystemPrompt(bot) {
       })
     },
     { id: "computer", label: "Computer", text: computerPrompt(computerPromptKind) },
+    { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
     { id: "plan", label: "Surface", text: previewPlan.note },
     { id: "composio", label: "Connected apps", text: caps?.composioMcp && bot.composio !== false && configured(cfg) ? COMPOSIO_PROMPT : "" },
     { id: "mcp", label: "MCP servers", text: caps?.customMcp ? customMcpPrompt(Object.keys(customMcpServers(cfg, bot.mcpServers))) : "" },
@@ -69972,11 +70476,21 @@ var approvalModeForTurn = (bot, peerInitiated = false) => {
 function handleDesktopTrustedApprovalMessage(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
   const message3 = raw;
+  const grantTarget = (bot) => bot.approvalGrant?.threadOnly ? store.projectBotForTask(bot.id, bot.approvalGrant.threadId) : bot;
+  const grantBusy = (bot) => bot.approvalGrant?.threadOnly ? threadBusy(bot.id, bot.approvalGrant.threadId) : bot.busy;
+  const grantSupported = (bot, mode2) => supportsApprovalMode(
+    registry2.cliTarget(grantTarget(bot)?.modelSelection.instanceId ?? "")?.driverKind,
+    mode2
+  );
+  const clearGrant = (bot) => store.patchBot(bot.id, {
+    ...!bot.approvalGrant?.threadOnly ? { approvalMode: "ask", autoApprove: false } : {},
+    approvalGrant: void 0
+  });
   const threadCanReceiveGrant = (bot) => {
     const threadId2 = bot.approvalGrant?.threadId;
     if (!threadId2) return true;
     const target = store.projectBotForTask(bot.id, threadId2);
-    return Boolean(target && !threadBusy(bot.id, threadId2) && registry2.cliTarget(target.modelSelection.instanceId)?.driverKind === registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind);
+    return Boolean(target && !threadBusy(bot.id, threadId2) && (bot.approvalGrant?.threadOnly || registry2.cliTarget(target.modelSelection.instanceId)?.driverKind === registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind));
   };
   if (message3.type === "approval-trusted-mode-commit") {
     const requestId2 = typeof message3.requestId === "string" && /^[A-Za-z0-9_-]{1,80}$/.test(message3.requestId) ? message3.requestId : null;
@@ -69985,13 +70499,17 @@ function handleDesktopTrustedApprovalMessage(raw) {
     if (!requestId2) return true;
     if (!botId2 || !mode2) return true;
     const bot = store.bot(botId2);
-    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "committed" && bot.approvalMode === mode2 && !bot.busy && threadCanReceiveGrant(bot) && supportsApprovalMode(registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind, mode2)) {
+    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "committed" && (bot.approvalGrant.threadOnly || bot.approvalMode === mode2) && !grantBusy(bot) && threadCanReceiveGrant(bot) && grantSupported(bot, mode2)) {
       if (bot.approvalGrant.threadId) {
         store.patchTask(botId2, bot.approvalGrant.threadId, { approvalMode: mode2, autoApprove: false });
       }
       store.patchBot(botId2, { approvalGrant: void 0 });
+      postDesktopPrivateMessage({ type: "approval-trusted-mode-commit-result", requestId: requestId2, ok: true, bot: wireBot(store.bot(botId2)) });
     } else if (bot?.approvalGrant?.requestId === requestId2) {
-      store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
+      clearGrant(bot);
+      postDesktopPrivateMessage({ type: "approval-trusted-mode-commit-result", requestId: requestId2, ok: false });
+    } else {
+      postDesktopPrivateMessage({ type: "approval-trusted-mode-commit-result", requestId: requestId2, ok: false });
     }
     return true;
   }
@@ -70013,9 +70531,9 @@ function handleDesktopTrustedApprovalMessage(raw) {
       return true;
     }
     const bot = store.bot(botId2);
-    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "prepared" && bot.approvalMode === mode2) {
-      if (!supportsApprovalMode(registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind, mode2)) {
-        store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
+    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "prepared" && (bot.approvalGrant.threadOnly || bot.approvalMode === mode2)) {
+      if (!grantSupported(bot, mode2)) {
+        clearGrant(bot);
         confirm(false, "This provider does not support the selected approval level");
         return true;
       }
@@ -70026,7 +70544,7 @@ function handleDesktopTrustedApprovalMessage(raw) {
       return true;
     }
     if (bot?.approvalGrant?.requestId === requestId2) {
-      store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
+      clearGrant(bot);
     }
     confirm(false, "The approval confirmation no longer matches this bot");
     return true;
@@ -70049,10 +70567,10 @@ function handleDesktopTrustedApprovalMessage(raw) {
       return true;
     }
     const bot = store.bot(botId2);
-    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "confirmed" && bot.approvalMode === mode2) {
-      if (bot.busy || !supportsApprovalMode(registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind, mode2)) {
-        store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
-        activate(false, bot.busy ? "Stop this bot's turn before changing its approval level" : "This provider does not support the selected approval level");
+    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "confirmed" && (bot.approvalGrant.threadOnly || bot.approvalMode === mode2)) {
+      if (grantBusy(bot) || !grantSupported(bot, mode2)) {
+        clearGrant(bot);
+        activate(false, grantBusy(bot) ? "Stop this bot's turn before changing its approval level" : "This provider does not support the selected approval level");
         return true;
       }
       store.patchBot(botId2, { approvalGrant: { ...bot.approvalGrant, requestId: requestId2, mode: mode2, phase: "activated" } });
@@ -70060,7 +70578,7 @@ function handleDesktopTrustedApprovalMessage(raw) {
       return true;
     }
     if (bot?.approvalGrant?.requestId === requestId2) {
-      store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
+      clearGrant(bot);
     }
     activate(false, "The approval activation no longer matches this bot");
     return true;
@@ -70083,13 +70601,13 @@ function handleDesktopTrustedApprovalMessage(raw) {
       return true;
     }
     const bot = store.bot(botId2);
-    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "activated" && bot.approvalMode === mode2 && !bot.busy && threadCanReceiveGrant(bot) && supportsApprovalMode(registry2.cliTarget(bot.modelSelection.instanceId)?.driverKind, mode2)) {
+    if (bot?.approvalGrant?.requestId === requestId2 && bot.approvalGrant.mode === mode2 && bot.approvalGrant.phase === "activated" && (bot.approvalGrant.threadOnly || bot.approvalMode === mode2) && !grantBusy(bot) && threadCanReceiveGrant(bot) && grantSupported(bot, mode2)) {
       store.patchBot(botId2, { approvalGrant: { ...bot.approvalGrant, requestId: requestId2, mode: mode2, phase: "committed" } });
       finalize2(true);
       return true;
     }
     if (bot?.approvalGrant?.requestId === requestId2) {
-      store.patchBot(botId2, { approvalMode: "ask", autoApprove: false, approvalGrant: void 0 });
+      clearGrant(bot);
     }
     finalize2(false, bot?.busy ? "Stop this bot's turn before changing its approval level" : "The approval finalization no longer matches this bot");
     return true;
@@ -70121,6 +70639,38 @@ function handleDesktopTrustedApprovalMessage(raw) {
   }
   const currentMode = approvalModeFor(existing);
   const threadId = message3.threadId;
+  if (message3.threadOnly !== void 0 && typeof message3.threadOnly !== "boolean") {
+    respond({ ok: false, error: "Invalid thread approval scope" });
+    return true;
+  }
+  if (message3.threadOnly === true) {
+    const target = typeof threadId === "string" ? store.projectBotForTask(botId, threadId) : null;
+    if (!target || message3.modelSelection !== void 0 || message3.updateBotDefault !== void 0) {
+      respond({ ok: false, error: "Choose an existing thread for this approval change" });
+      return true;
+    }
+    const clearsOwnGrant = mode === "ask" && existing.approvalGrant?.threadOnly && existing.approvalGrant.threadId === threadId;
+    if (existing.approvalGrant && !clearsOwnGrant || threadBusy(botId, target.threadId)) {
+      respond({ ok: false, error: "Stop this thread and finish its pending approval change first" });
+      return true;
+    }
+    if (!supportsApprovalMode(registry2.cliTarget(target.modelSelection.instanceId)?.driverKind, mode)) {
+      respond({ ok: false, error: "This thread's provider does not support that approval level" });
+      return true;
+    }
+    if (mode === "auto" && target.computer === "local" && approvalModeFor(target) !== "auto" && message3.acknowledgeLocalAuto !== true) {
+      respond({ ok: false, error: "Auto mode on this computer requires confirming the warning" });
+      return true;
+    }
+    if (mode === "full" || mode === "custom") {
+      store.patchBot(botId, { approvalGrant: { requestId, mode, phase: "prepared", threadId: target.threadId, threadOnly: true } });
+    } else {
+      if (clearsOwnGrant) clearGrant(existing);
+      store.patchTask(botId, target.threadId, { approvalMode: mode, autoApprove: mode === "auto", alwaysAllow: [] });
+    }
+    respond({ ok: true, bot: wireTrustedApprovalBot(store.bot(botId)) });
+    return true;
+  }
   if (message3.modelSelection !== void 0) {
     const target = typeof threadId === "string" ? store.projectBotForTask(botId, threadId) : null;
     if (mode !== "ask" || !target || typeof message3.updateBotDefault !== "boolean") {
@@ -70546,7 +71096,7 @@ function publicGroupState(group) {
 }
 function beginGroupTurnOperation(groupId, threadId, botIds = []) {
   const operation = {
-    id: randomUUID25(),
+    id: randomUUID27(),
     threadId,
     botIds: new Set(botIds),
     cancelled: false,
@@ -70863,8 +71413,8 @@ function messageWindow(threadId, messageId, limit) {
   return { messages: all2.slice(start, stop).map(slimMessage), hasMore: start > 0 };
 }
 var sseClients = /* @__PURE__ */ new Set();
-sessions.onSessionRevoked((sessionId) => {
-  providerAuthSessions.revokeOwner(sessionId);
+function closeSessionStreams(sessionId) {
+  browserLive.closeForOwner(sessionId);
   for (const client of sseClients) {
     if (client.sessionId !== sessionId) continue;
     sseClients.delete(client);
@@ -70873,8 +71423,12 @@ sessions.onSessionRevoked((sessionId) => {
     } catch {
     }
   }
+}
+sessions.onSessionRevoked((sessionId) => {
+  providerAuthSessions.revokeOwner(sessionId);
+  closeSessionStreams(sessionId);
 });
-var STREAM_ID = randomUUID25().slice(0, 8);
+var STREAM_ID = randomUUID27().slice(0, 8);
 var REPLAY_MAX = 500;
 var configuredSseHeartbeatMs = Number(process.env.OMB_SSE_HEARTBEAT_MS);
 var SSE_HEARTBEAT_MS = Number.isFinite(configuredSseHeartbeatMs) && configuredSseHeartbeatMs > 0 ? configuredSseHeartbeatMs : 15e3;
@@ -70890,6 +71444,7 @@ function cursorSeq(raw) {
   return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
 }
 function broadcast(payload) {
+  sessions.revalidateEmailSessions();
   const seq2 = ++lastSeq;
   const kind = String(payload.kind ?? "");
   const frame = `id: ${STREAM_ID}:${seq2}
@@ -71131,15 +71686,99 @@ var checkpointRestoreLeases = /* @__PURE__ */ new Set();
 var LOCAL_VM_IDLE_MS = 8 * 60 * 6e4;
 var LOCAL_VM_DESKTOP_WAIT_MS = 9e4;
 var localVmIdles = /* @__PURE__ */ new Map();
+function inheritedTeamComputer(bot) {
+  return teamComputers.forBot(bot);
+}
+function teamComputerPrompt(computer) {
+  return computer ? `Your team shares the Box computer ${JSON.stringify(computer.name)}. Its desktop files and desktop browser logins are shared with other Auto bots in your team; only one turn may drive it at a time. The separate built-in Browser is not this desktop and does not automatically share its logins.` : "";
+}
+function botComputerControlKey(bot) {
+  const computer = inheritedTeamComputer(bot);
+  return computer ? teamComputerOwner(computer.id) : bot.id;
+}
+function botComputerControlSnapshot(botId, pinnedComputerId) {
+  const own3 = computerControl.snapshot(botId);
+  const bot = store.bot(botId);
+  const key3 = pinnedComputerId ? teamComputerOwner(pinnedComputerId) : bot ? botComputerControlKey(bot) : botId;
+  const shared = computerControl.snapshot(key3);
+  return own3.held ? own3 : shared.held || shared.helpReason ? shared : own3;
+}
+function teamComputerInUse(computer) {
+  computer = teamComputers.get(computer.id) ?? computer;
+  return computerControl.snapshot(teamComputerOwner(computer.id)).held || [...teamComputerTurns.values()].some((turn) => turn.computerId === computer.id) || store.bots.some((bot) => computer.section !== null && sectionKey3(bot.section) === computer.section && (botHasActiveTurn(bot.id) || Boolean(routines?.activeRunForBot(bot.id)) || computerControl.snapshot(bot.id).held));
+}
+function assertTeamControlCanBeTaken(computerId) {
+  if ([...teamComputerTurns.values()].some((turn) => turn.computerId === computerId && turn.remoteAgent)) {
+    throw Object.assign(new Error("Stop the Computer engine's active turn before taking control of this shared desktop"), { status: 409 });
+  }
+}
+function claimTeamComputerLifecycle(computer) {
+  if (computerProviderConfigTransitions.has("box")) throw Object.assign(new Error(providerTransitionMessage("box")), { status: 409 });
+  if (teamComputerInUse(computer)) throw Object.assign(new Error("This team computer is in use; stop the team's work and release computer control first"), { status: 409 });
+  return claimBotComputerLifecycle(teamComputerOwner(computer.id));
+}
+function assertTeamComputerChangeIdle(before, after) {
+  const previous2 = inheritedTeamComputer(before);
+  const next = inheritedTeamComputer(after);
+  if (previous2?.id === next?.id) return;
+  if (botHasActiveTurn(before.id) || routines?.activeRunForBot(before.id) || botComputerControlSnapshot(before.id).held || [previous2, next].some((computer) => computer && (teamComputerInUse(computer) || boxLifecycleBusyBots.has(teamComputerOwner(computer.id))))) {
+    throw Object.assign(new Error("Stop the affected team's work and release computer control before changing its computer access"), { status: 409 });
+  }
+}
+async function teamComputersPayload() {
+  const entries = teamComputers.list();
+  const inventory = await listManagedBoxes(cfg, managedBoxOwners());
+  return {
+    configured: inventory.configured,
+    ...inventory.problem ? { problem: inventory.problem } : {},
+    computers: entries.map((entry) => {
+      const machine = inventory.instances.find((instance) => instance.ownerBotId === teamComputerOwner(entry.id));
+      return {
+        id: entry.id,
+        name: entry.name,
+        section: entry.section,
+        held: computerControl.snapshot(teamComputerOwner(entry.id)).held,
+        state: boxLifecycleBusyBots.has(teamComputerOwner(entry.id)) ? "working" : machine?.state ?? (inventory.available ? "missing" : "unavailable"),
+        ...entry.problem || inventory.problem ? { problem: entry.problem || inventory.problem } : {}
+      };
+    })
+  };
+}
+async function attachTeamBox(computer, botId, owner2, canMount, remoteAgent) {
+  if (!canMount) throw new Error("This model engine cannot use the team's Box computer; choose an engine with computer tools or an explicit bot destination");
+  if (!boxConfigured(cfg)) throw new Error("The team's Box account is not configured; reconnect it in Settings");
+  const ownerId = teamComputerOwner(computer.id);
+  if (boxLifecycleBusyBots.has(ownerId)) throw new Error("The team computer is being changed; wait for it to finish");
+  if (computerControl.snapshot(ownerId).held) throw new Error("Release human control of the team computer before starting another turn");
+  bindTurnComputer(owner2, `computer:box-bot:${ownerId}`, true);
+  teamComputerTurns.set(owner2.threadId, { owner: owner2, computerId: computer.id, botId, remoteAgent });
+  let machine = await findBox(cfg, ownerId);
+  if (!machine) throw new Error("The team's Box computer is missing; explicitly create or retry it from the Team map");
+  bindTurnComputer(owner2, `computer:box:${machine.id}`, true);
+  const action = boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null });
+  if (action === "wake") machine = await readyBox(cfg, ownerId);
+  if (!machine || boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null }) !== "attach") {
+    throw new Error("The team computer is not ready; check it in the Team map");
+  }
+  if (turnResourceOwners.get(owner2.threadId)?.generation !== owner2.generation || !turnResources.owns(`computer:box:${machine.id}`, owner2)) throw new Error("This computer turn ended while its machine was starting");
+  return {
+    integration: { kind: "box", boxId: machine.id, token: cfg.box.token, control: controlIntegration(botId, owner2.threadId, owner2.generation) },
+    capture: () => screenshotBox(cfg, ownerId, machine.id)
+  };
+}
 function managedBoxOwners() {
-  return store.bots.map((bot) => ({
+  return [...store.bots.map((bot) => ({
     botId: bot.id,
     name: bot.name,
     // A machine is not safe to mutate while any app-level work or human
     // control lease still names its owner. This is deliberately conservative
     // across destination changes: an old Box may still contain valuable state.
     inUse: bot.busy === true || hasDirectDispatch(bot.id) || activeGroupTurnForBot(bot.id) !== null || Boolean(routines?.activeRunForBot(bot.id)) || activeVpsThreads.has(bot.id) || computerControl.snapshot(bot.id).held
-  }));
+  })), ...teamComputers.list().map((computer) => ({
+    botId: teamComputerOwner(computer.id),
+    name: computer.name,
+    inUse: teamComputerInUse(computer)
+  }))];
 }
 function botHasActiveTurn(botId) {
   const bot = store.bot(botId);
@@ -71172,6 +71811,7 @@ function providerOperationConflict(provider) {
 }
 function turnProvider(bot, runOn2) {
   if (runOn2 === "cloud" || registry2.get(bot.modelSelection.instanceId)?.driverKind === "boxAgent") return "box";
+  if (inheritedTeamComputer(bot)) return "box";
   if (bot.computer !== void 0 && bot.computer !== "cloud") return null;
   return bot.cloudBackend === "vps" ? "vps" : "box";
 }
@@ -71188,6 +71828,8 @@ function claimBoxInventoryRequest(boxId) {
 }
 function claimManagedBoxMutation(instance) {
   const ownerBotId = instance.ownerBotId;
+  const teamComputer = teamComputers.list().find((computer) => teamComputerOwner(computer.id) === ownerBotId);
+  if (teamComputer) return claimTeamComputerLifecycle(teamComputer);
   if (!ownerBotId) {
     if (orphanBoxLifecycleBusyIds.has(instance.boxId)) {
       throw Object.assign(new Error("this cloud computer is being changed \u2014 wait for it to finish"), { status: 409 });
@@ -71387,7 +72029,7 @@ bus.subscribe((event) => {
           const existing = store.messagesFor(event.threadId).find((m2) => m2.id === messageId)?.tool;
           toolName = existing?.name ?? "tool";
           store.patchMessage(event.threadId, messageId, {
-            tool: { name: toolName, ok: event.ok, spoken: existing?.spoken, summary: existing?.summary }
+            tool: { ...existing, name: toolName, ok: event.ok, output: event.output }
           });
           toolMessageByItem.delete(itemKey);
         }
@@ -71406,7 +72048,7 @@ bus.subscribe((event) => {
         const message3 = pushMessage({
           role: "bot",
           kind: "activity",
-          tool: { name: name2, spoken: narrateTool(name2) ?? void 0, summary: event.summary }
+          tool: { name: name2, spoken: narrateTool(name2) ?? void 0, summary: event.summary, input: event.input }
         });
         if (event.itemId) toolMessageByItem.set(`${event.threadId}:${event.itemId}`, message3.id);
       }
@@ -71784,7 +72426,7 @@ function markTaskContextExternallyUpdated(bot, threadId) {
   if (!task2) return;
   store.patchTask(bot.id, threadId, {
     resumeCursors: {},
-    lastInstanceId: `${EXTERNAL_CONTEXT_MARKER_PREFIX}${randomUUID25()}`,
+    lastInstanceId: `${EXTERNAL_CONTEXT_MARKER_PREFIX}${randomUUID27()}`,
     unread: true
   });
 }
@@ -72010,9 +72652,9 @@ function drainQueuedSends() {
     store,
     (botId, threadId, prompt, userMessage, excludeIds, unattended) => (
       // A plain attended turn — no automationSource, no comms depth: exactly
-      // what typing the same words into an idle bot would run. The one
-      // exception is `unattended`: a thread a bot opened on itself while
-      // nobody was watching stays unwatched through the wait for a slot.
+      // what typing the same words into an idle bot would run. Self-opened
+      // work retains `unattended` and the message's bot-origin provenance
+      // through the wait for a slot.
       // Drain just appended the held lines; userMessage keeps startTurn
       // from duplicating the last one, and excludeIds drops every drained
       // line from the transcript-replay so they are not also in `prompt`.
@@ -72058,12 +72700,13 @@ async function startOrQueueDirectMessage(botId, threadId, text8, replyTo, sendId
 }
 var MAX_THREADS_OPENED_PER_TURN = 5;
 async function startOrQueueOpenedThread(botId, threadId, text8, unattended) {
+  const peerAsk = { botId, name: store.bot(botId).name, unattended: unattended || void 0 };
   if (botAtThreadCapacity(botId) || activeGroupTurnForBot(botId)) {
-    queueSteeredMessage(botId, threadId, text8, { reason: "capacity", unattended });
+    queueSteeredMessage(botId, threadId, text8, { reason: "capacity", unattended, peerAsk });
     return { state: "queued", position: queuedThreadPosition(botId, threadId) ?? 1 };
   }
   try {
-    await startTurn(botId, text8, { threadId, unattended });
+    await startTurn(botId, text8, { threadId, unattended, peerAsk });
     return { state: "running" };
   } catch (error51) {
     const why = error51 instanceof Error ? error51.message : String(error51);
@@ -72098,7 +72741,7 @@ function startScreenPoller(botId, threadId, captures, { screenIsTheWork = false
       browser: guarded(captures.browser, browserSession ? `browser:${browserSession}` : void 0)
     },
     control: () => ({
-      held: computerControl.snapshot(botId).held,
+      held: botComputerControlSnapshot(botId, teamComputerTurns.get(threadId)?.computerId).held,
       revision: computerControlRevision.get(botId) ?? 0
     }),
     onFrame: (frame) => broadcast({ kind: "screen", botId, threadId, ...frame }),
@@ -72238,7 +72881,7 @@ async function startTurn(botId, text8, opts) {
     userMessage = edited;
   }
   if (!userMessage) {
-    userMessage = opts?.cardContinuation ? { id: `card-${randomUUID25()}`, at: Date.now(), role: "user", kind: "text", text: text8 } : store.appendMessage(threadId, {
+    userMessage = opts?.cardContinuation ? { id: `card-${randomUUID27()}`, at: Date.now(), role: "user", kind: "text", text: text8 } : store.appendMessage(threadId, {
       role: "user",
       kind: "text",
       text: text8,
@@ -72248,7 +72891,7 @@ async function startTurn(botId, text8, opts) {
     });
   }
   if (!opts?.cardContinuation) {
-    if (commsDepth === 0 && opts?.automationSource === void 0 && !opts?.unattended) {
+    if (commsDepth === 0 && opts?.automationSource === void 0 && !opts?.unattended && !userMessage.peerAsk) {
       personAskAt.set(threadId, userMessage.at);
       if (task2.routineRunId) store.patchTask(bot.id, threadId, { routineRunId: void 0 });
     } else {
@@ -72291,7 +72934,7 @@ async function startTurn(botId, text8, opts) {
     const drift = checkSoulDrift(bot.id, bot.soul ?? "", bot.soulHash ?? "");
     if (drift.drift !== Boolean(bot.soulDrift)) store.patchBot(bot.id, { soulDrift: drift.drift });
   }
-  const dispatchClaimId = randomUUID25();
+  const dispatchClaimId = randomUUID27();
   const resourceOwner = { threadId, generation: dispatchClaimId };
   turnResourceOwners.set(threadId, resourceOwner);
   directTurnGenerationByThread.set(threadId, dispatchClaimId);
@@ -72347,13 +72990,14 @@ async function startTurn(botId, text8, opts) {
       const checkpointCwd = cwd && cwd !== privateWorkspace ? cwd : void 0;
       const dwebUrl = process.env.DWEB_URL?.trim();
       if (dwebUrl) integrations.dweb = { url: dwebUrl };
-      const cloudBackend = opts?.runOn === "cloud" || bot.cloudBackend !== "vps" ? "box" : "vps";
+      const teamComputer = inheritedTeamComputer(bot);
+      const cloudBackend = teamComputer || opts?.runOn === "cloud" || bot.cloudBackend !== "vps" ? "box" : "vps";
       const mountsComputerMcp = instance.adapter.capabilities.computerMcp === true;
       const mountsCloudComputer = mountsComputerMcp || instance.driverKind === "boxAgent";
       const mountsLocalComputer = instance.adapter.capabilities.localComputerMcp === true;
       const browserOn = builtInBrowserEnabled(cfg) && bot.browser !== false && instance.adapter.capabilities.browserMcp === true;
       const plan = resolveSurface({
-        destination: opts?.runOn === "cloud" ? "cloud" : bot.computer,
+        destination: teamComputer || opts?.runOn === "cloud" ? "cloud" : bot.computer,
         // cloud routine overrides the MAUS default
         browserOn
       });
@@ -72438,7 +73082,13 @@ async function startTurn(botId, text8, opts) {
           }
         }
       }
-      if ((wants2 === "cloud" || wants2 === void 0) && cloudBackend === "box" && boxConfigured(cfg)) {
+      if (teamComputer) {
+        const attached = await attachTeamBox(teamComputer, bot.id, resourceOwner, mountsCloudComputer, instance.driverKind === "boxAgent");
+        integrations.computer = attached.integration;
+        previewCapture = attached.capture;
+        computerKind = "box";
+      }
+      if (!teamComputer && (wants2 === "cloud" || wants2 === void 0) && cloudBackend === "box" && boxConfigured(cfg)) {
         if (wants2 === "cloud") bindTurnComputer(resourceOwner, `computer:box-bot:${bot.id}`, true);
         if (!mountsCloudComputer && wants2 === "cloud") {
           throw new Error("this model engine cannot use computer tools \u2014 choose Claude, an ACP engine, or the Computer engine");
@@ -72506,7 +73156,9 @@ async function startTurn(botId, text8, opts) {
       }
       const sectionPeers = reachablePeers(store.bots, bot);
       if (agentsMounted) {
-        integrations.agents = agentsIntegration(bot.id, threadId, commsDepth, skillAuthoring, dispatchClaimId, opts?.coordination?.id, boundedCoordination);
+        const origin = opts?.cardContinuation ? store.activePath(threadId).findLast((message3) => message3.role === "user" && message3.kind === "text") : userMessage;
+        const ownThreadCreation = boundedCoordination && !opts?.coordination && Boolean(origin && !origin.peerAsk);
+        integrations.agents = agentsIntegration(bot.id, threadId, commsDepth, skillAuthoring, dispatchClaimId, opts?.coordination?.id, boundedCoordination, ownThreadCreation);
       }
       const tagged = integrations.agents ? mentionedBots(
         providerText,
@@ -72564,6 +73216,7 @@ async function startTurn(botId, text8, opts) {
         { id: "setup", label: "Setup", text: setupSystemPrompt(setupMode, { skills: skillAuthoring, cwd: liveBot?.cwd ?? bot.cwd }) },
         { id: "files", label: "File locations", text: worksInWorkspace && opts?.runOn !== "cloud" ? workspaceLocationsPrompt(bot.id, cwd, liveBot?.cwd ?? bot.cwd) : "" },
         { id: "computer", label: "Computer", text: computerPrompt(computerPromptKind) },
+        { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
         { id: "plan", label: "Surface", text: plan.note },
         // gated on the integration, not the key: the hint only goes to a
         // bot whose driver actually mounted the tools
@@ -72821,8 +73474,8 @@ async function stopBotForEmergencyApprovalDowngrade(botId) {
       registry2.get(bot.modelSelection.instanceId)?.adapter.interruptTurn(groupTurn.threadId)
     ]);
     closeOpenApprovals(groupTurn.threadId);
-    const failure3 = results.find((result) => result.status === "rejected");
-    if (failure3) throw failure3.reason;
+    const failure5 = results.find((result) => result.status === "rejected");
+    if (failure5) throw failure5.reason;
     return;
   }
   await directStop;
@@ -73012,7 +73665,7 @@ async function deleteBotWithLifecycle(botId, revalidate = () => {
         return deletionResponse(409, { error: "stop this bot's Local VM turn or setup action before deleting the bot" });
       }
       const vm = await containerComputerStatus(void 0, void 0, target);
-      if (!vm.daemonUp && existsSync30(target.workspaceDir)) {
+      if (!vm.daemonUp && existsSync31(target.workspaceDir)) {
         return deletionResponse(409, {
           error: "start the container runtime and delete this bot's Local VM before deleting the bot"
         });
@@ -73110,7 +73763,7 @@ async function deleteBotWithLifecycle(botId, revalidate = () => {
     }
     for (const dir of [EVENTS_DIR, NATIVE_DIR]) {
       try {
-        unlinkSync12(join61(dir, `${bot.threadId}.ndjson`));
+        unlinkSync13(join61(dir, `${bot.threadId}.ndjson`));
       } catch {
       }
     }
@@ -73234,6 +73887,12 @@ async function resolveAndSendTeamSetup(res, args, ownerReview) {
     json3(res, 403, { error: "Approve team setup or deletion from the desktop app or a paired owner device. In a local browser, wait until every bot is idle." });
     return true;
   }
+  if (args.behavior === "allow" && !card.answered && !card.dismissed) {
+    for (const operation of card.teamSetupRequest.operations) {
+      const before = store.bot(operation.botId);
+      if (before && operation.action === "update") assertTeamComputerChangeIdle(before, { ...before, ...operation.fields });
+    }
+  }
   const resumeGeneration = teamSetupResumeGenerations.get(args.threadId) ?? 0;
   const resolved = await teamSetupRequests.resolve(args);
   if (!resolved) return false;
@@ -73670,8 +74329,9 @@ async function runGroupMemberTurn(groupId, threadId, botId, hop, spoken = /* @__
     groupSpeakers.set(threadId, roomSpeaker);
     store.patchGroup(readyGroup.id, { busyBotId: bot.id });
     orchestration?.onClaimed?.();
+    const roomTeamComputer = inheritedTeamComputer(readyBot);
     const roomPlan = resolveSurface({
-      destination: readyBot.computer,
+      destination: roomTeamComputer ? "cloud" : readyBot.computer,
       browserOn: builtInBrowserEnabled(cfg) && readyBot.browser !== false && instance.adapter.capabilities.browserMcp === true
     });
     if (roomPlan.browser) {
@@ -73683,6 +74343,18 @@ async function runGroupMemberTurn(groupId, threadId, botId, hop, spoken = /* @__
     if (isCancelled?.() || !browserReadyBot?.busy || groupSpeakers.get(threadId) !== roomSpeaker || activeInternalGenerationByThread.get(threadId) !== internalGeneration) {
       return false;
     }
+    if (roomTeamComputer) {
+      const attached = await attachTeamBox(
+        roomTeamComputer,
+        readyBot.id,
+        resourceOwner,
+        instance.adapter.capabilities.computerMcp === true || instance.driverKind === "boxAgent",
+        instance.driverKind === "boxAgent"
+      );
+      if (isCancelled?.() || groupSpeakers.get(threadId) !== roomSpeaker || activeInternalGenerationByThread.get(threadId) !== internalGeneration) return false;
+      integrations.computer = attached.integration;
+      startScreenPoller(readyBot.id, threadId, { computer: attached.capture }, { screenIsTheWork: instance.driverKind === "boxAgent" });
+    }
     if (readyBot.computer === "vm") {
       if (instance.adapter.capabilities.computerMcp !== true || instance.driverKind === "boxAgent") {
         throw new Error("this model engine cannot use the Local VM");
@@ -73754,7 +74426,8 @@ ${cardContinuation}` : ""}`;
     const roomSystem = buildSystemPrompt(system, store.bot(bot.id)?.soul ?? bot.soul ?? "", [
       { id: "files", label: "File locations", text: workspace ? workspaceLocationsPrompt(bot.id, cwd, readyBot.cwd) : "" },
       { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
-      { id: "computer", label: "Computer", text: computerPrompt(roomVmTarget ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : null) },
+      { id: "computer", label: "Computer", text: computerPrompt(roomTeamComputer ? instance.driverKind === "boxAgent" ? "box-agent" : "box" : roomVmTarget ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : null) },
+      { id: "team-computer", label: "Team computer", text: teamComputerPrompt(roomTeamComputer) },
       { id: "plan", label: "Surface", text: roomPlan.note },
       { id: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
       { id: "recall", label: "Recall", text: integrations.agents ? SESSION_SEARCH_SYSTEM_PROMPT : "" },
@@ -73786,7 +74459,7 @@ ${memorySystemPrompt(bot.id, { managedWrites: Boolean(integrations.agents) }).tr
     let replyText = "";
     let providerTurnId;
     let abandoned = false;
-    const retirementOwner = `room-abandoned:${randomUUID25()}`;
+    const retirementOwner = `room-abandoned:${randomUUID27()}`;
     const abandonProviderTurn = () => {
       if (abandoned) return;
       abandoned = true;
@@ -74391,7 +75064,7 @@ function startGroupTurn(groupId, text8, replyTo, sendId, channelMode = "chat", q
     goalCoordinator ? [] : responders.map((responder) => responder.id)
   );
   if (goalCoordinator) {
-    const runId = options.goalRunId?.trim() || `goal-${Date.now().toString(36)}-${randomUUID25()}`;
+    const runId = options.goalRunId?.trim() || `goal-${Date.now().toString(36)}-${randomUUID27()}`;
     const startedAt = Date.now();
     const detail = `${goalCoordinator.name} is coordinating this goal.`;
     const card = store.appendMessage(threadId, {
@@ -74650,7 +75323,7 @@ Adds one line to the prompt index; the body is read only when used.${warnings}`,
   };
 }
 function appendSkillRequestCard(args) {
-  const requestId = randomUUID25();
+  const requestId = randomUUID27();
   const copy = skillCardCopy(args.staged);
   const payload = {
     version: 1,
@@ -75235,7 +75908,7 @@ async function perBotLocalVmCountForModeChange() {
   if (targets.length === 0) return 0;
   const runtime = await containerRuntimeStatus();
   if (!runtime.runtime || !runtime.daemonUp) {
-    return targets.some((target) => existsSync30(target.workspaceDir)) ? null : 0;
+    return targets.some((target) => existsSync31(target.workspaceDir)) ? null : 0;
   }
   return existingPerBotLocalVmCount(runtime.runtime);
 }
@@ -75279,7 +75952,11 @@ function configStatus() {
     features: {
       skillAuthoring: skillAuthoringEnabled(cfg),
       showToolCalls: showToolCallsEnabled(cfg),
-      browser: builtInBrowserEnabled(cfg)
+      browser: builtInBrowserEnabled(cfg),
+      // Maintainer-only escape hatch, not a Settings toggle: the desktop
+      // shell and the Settings UI read it so they offer nothing this server
+      // would refuse.
+      sharedComputers: sharedComputersEnabled(cfg)
     },
     // first-run progress — not a secret; the app decides whether to show
     // the welcome tour from this, never from browser storage
@@ -75411,13 +76088,13 @@ function serveStatic(res, path) {
   const safe = path === "/" ? "/index.html" : path.replace(/\.\./g, "");
   const file2 = join61(STATIC_DIR, safe);
   try {
-    const data = readFileSync42(file2);
+    const data = readFileSync43(file2);
     res.writeHead(200, { "content-type": MIME[extname5(file2)] ?? "application/octet-stream" });
     res.end(data);
     return true;
   } catch {
     try {
-      const data = readFileSync42(join61(STATIC_DIR, "index.html"));
+      const data = readFileSync43(join61(STATIC_DIR, "index.html"));
       res.writeHead(200, { "content-type": "text/html" });
       res.end(data);
       return true;
@@ -75493,8 +76170,13 @@ var workspaceBackupRoutes = createWorkspaceBackupRoutes({
     }).auth;
     return Boolean(current2?.scopes.includes("admin") && current2.kind === original.kind && (current2.kind !== "session" || original.kind === "session" && current2.session.id === original.session.id));
   },
-  exclusive: (work, keepLocked) => workspaceMaintenance.run(work, {
-    idle: () => !providerFleetReloading && !providerAuthSessions.active && !browserEngineInstall && !routines?.isTicking && !calendarCalls?.isTicking && !localVmImageBusy && !localVmProvisionBusy && !localVmModeChangeBusy && !localVmLifecycleBusy.size && !boxLifecycleBusyBots.size && !vpsPreviewRequests.size && !orphanBoxLifecycleBusyIds.size && !computerProviderConfigTransitions.size && !checkpointRestoreLeases.size && store.bots.every((bot) => !botHasActiveTurn(bot.id) && !routines?.activeRunForBot(bot.id) && !computerControl.snapshot(bot.id).held) && store.groups.every((group) => !groupIsWorking(group)),
+  exclusive: (work, keepLocked) => workspaceMaintenance.run(async () => {
+    if (keepLocked && teamComputers.list().some((computer) => computer.section !== null)) {
+      throw Object.assign(new Error("Unassign team computers before restoring this workspace"), { status: 409 });
+    }
+    return work();
+  }, {
+    idle: () => !providerFleetReloading && !providerAuthSessions.active && !browserEngineInstall && !routines?.isTicking && !calendarCalls?.isTicking && !localVmImageBusy && !localVmProvisionBusy && !localVmModeChangeBusy && !localVmLifecycleBusy.size && !boxLifecycleBusyBots.size && !vpsPreviewRequests.size && !orphanBoxLifecycleBusyIds.size && !computerProviderConfigTransitions.size && !checkpointRestoreLeases.size && teamComputers.list().every((computer) => !teamComputerInUse(computer)) && store.bots.every((bot) => !botHasActiveTurn(bot.id) && !routines?.activeRunForBot(bot.id) && !botComputerControlSnapshot(bot.id).held) && store.groups.every((group) => !groupIsWorking(group)),
     pause: () => {
       routines?.stop();
       calendarCalls?.stop();
@@ -75523,9 +76205,28 @@ var handleRequest = async (req, res) => {
   let m2 = null;
   let releaseWorkspaceRequest;
   try {
+    if (method === "GET" && path === "/api/health/hosted") {
+      res.setHeader("cache-control", "no-store");
+      const hosted = hostedWorkspaceConfiguration();
+      if (!hosted?.portalMembership || !workspaceAccess || !entitled("admin")) {
+        return json3(res, 503, { error: "Hosted workspace readiness is unavailable." });
+      }
+      res.setHeader(HOSTED_CONTRACT_HEADER, String(HOSTED_CONTRACT_VERSION));
+      return json3(res, 200, { ok: true, service: "openmausbot", membershipAuthority: "portal", workspace: hosted.workspace, ...HOSTED_CONTRACT_METADATA });
+    }
+    if (HOSTED_WORKSPACE) {
+      if (method === "POST" && ["/api/auth/pair", "/api/auth/pairing", "/api/auth/email/start", "/api/auth/email/verify"].includes(path)) {
+        return json3(res, 403, { error: "Sign in through the workspace portal." });
+      }
+      if (workspaceAccess) {
+        if (await workspaceAccess.handlePublic(req, res, url2)) return;
+      } else if (path.startsWith("/api/auth/hosted/") || path === "/pair" || path === "/" && (!isLoopbackHost(req.headers.host) || isProxied(req))) {
+        return json3(res, 503, { error: "Workspace sign-in is unavailable." });
+      }
+    }
     if (method === "GET" && !path.startsWith("/api/") && !path.startsWith("/.well-known/") && serveStatic(res, path)) return;
     if (method === "GET" && path === "/.well-known/openmausbot/environment") {
-      return json3(res, 200, environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: emailSignIn.enabled() }));
+      return json3(res, 200, environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: !HOSTED_WORKSPACE && emailSignIn.enabled(), sharedComputers: sharedComputersEnabled(cfg) }));
     }
     const domainCheck = /^\/\.well-known\/openmausbot\/domain-check\/([a-f0-9]{64})$/.exec(path);
     if (method === "GET" && domainCheck) {
@@ -75561,7 +76262,7 @@ var handleRequest = async (req, res) => {
       }
       sessions.clearFailures(source);
       const issued = sessions.issue({ label: label.trim() || labelFromUserAgent(req.headers["user-agent"]), scopes: verified.scopes, userId: verified.userId, email: verified.email });
-      const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: true });
+      const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: true, sharedComputers: sharedComputersEnabled(cfg) });
       const secure = requestOrigin(req)?.startsWith("https://") === true;
       res.setHeader("set-cookie", serializeSessionCookie(SESSION_COOKIE, issued.token, { secure, maxAgeSeconds: cookieMaxAgeSeconds(issued.session) }));
       return json3(res, 200, { session: issued.session, environment });
@@ -75580,7 +76281,7 @@ var handleRequest = async (req, res) => {
         console.warn(`pairing refused from ${requestSource(req)}: ${result.error}`);
         return json3(res, result.status, { error: result.error });
       }
-      const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: emailSignIn.enabled() });
+      const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: emailSignIn.enabled(), sharedComputers: sharedComputersEnabled(cfg) });
       if (wantsCookie) {
         const secure = requestOrigin(req)?.startsWith("https://") === true;
         res.setHeader("set-cookie", serializeSessionCookie(SESSION_COOKIE, result.token, { secure, maxAgeSeconds: cookieMaxAgeSeconds(result.session) }));
@@ -75594,12 +76295,13 @@ var handleRequest = async (req, res) => {
       streamPath: "/api/events",
       url: url2,
       loopbackMutationToken: desktopMutationToken,
-      companionMutationToken
+      companionMutationToken,
+      features: { sharedComputers: sharedComputersEnabled(cfg) }
     });
     if (gate.auth?.kind === "session" && gate.auth.via === "cookie") {
       const presented = parseCookies(req.headers.cookie).get(SESSION_COOKIE);
       if (presented) {
-        const secure = requestOrigin(req)?.startsWith("https://") === true;
+        const secure = HOSTED_WORKSPACE || requestOrigin(req)?.startsWith("https://") === true;
         res.setHeader("set-cookie", serializeSessionCookie(SESSION_COOKIE, presented, { secure, maxAgeSeconds: cookieMaxAgeSeconds(gate.auth.session) }));
       }
     }
@@ -75611,8 +76313,15 @@ var handleRequest = async (req, res) => {
     }
     if (!gate.auth) return json3(res, gate.status, { error: gate.error });
     const auth = gate.auth;
+    if (HOSTED_WORKSPACE && auth.kind === "session") {
+      const failure5 = workspaceAccess ? await workspaceAccess.authorize(req, auth) : { status: 503, error: "Workspace sign-in is unavailable." };
+      if (failure5) return json3(res, failure5.status, { error: failure5.error });
+    }
+    if (method === "POST" && path === "/api/workspace-backup/restore" && teamComputers.list().some((computer) => computer.section !== null)) {
+      return json3(res, 409, { error: "Unassign team computers before restoring a workspace; restored team names must not gain access to existing desktops" });
+    }
     if (await workspaceBackupRoutes(req, res, path, auth)) return;
-    if (path.startsWith("/api/") && path !== "/api/events" && path !== "/api/health" && !isWorkspaceBackupSessionControl(method, path)) {
+    if (path.startsWith("/api/") && path !== "/api/events" && path !== "/api/health" && !path.startsWith("/api/shared-computers/") && !isWorkspaceBackupSessionControl(method, path)) {
       releaseWorkspaceRequest = workspaceMaintenance.request();
     }
     if (method === "GET" && path === "/api/auth/session") {
@@ -75694,6 +76403,39 @@ var handleRequest = async (req, res) => {
       const cancelled = sessions.cancelPairing(m2[1]);
       return json3(res, cancelled ? 200 : 404, cancelled ? { ok: true } : { error: "no such pairing code" });
     }
+    if (method === "POST" && path === "/api/desktop/shared-computer-control" && sharedComputersEnabled(cfg)) {
+      if (auth.kind !== "loopback") return json3(res, 403, { error: "Local desktop only" });
+      const body = await readBody(req, 1024);
+      if (!sharedComputersEnabled(cfg)) return json3(res, 404, { error: `no route: ${method} ${path}` });
+      if (!external_exports.string().uuid().safeParse(body?.id).success || !["acquire", "release"].includes(body?.action)) return json3(res, 400, { error: "Invalid computer lease" });
+      if (body.action === "release") sharedComputerControl.release(body.id);
+      else sharedComputerControl.acquire(body.id);
+      return json3(res, 200, { ok: true });
+    }
+    if (method === "POST" && path.startsWith("/api/shared-computers/") && sharedComputersEnabled(cfg)) {
+      if (auth.kind !== "session") return json3(res, 403, { error: "Pair this desktop first" });
+      if (!/^application\/json\b/i.test(String(req.headers["content-type"] ?? ""))) return json3(res, 415, { error: "JSON required" });
+      const body = await readBody(req, 4e6);
+      if (!sharedComputersEnabled(cfg)) return json3(res, 404, { error: `no route: ${method} ${path}` });
+      if (!sessions.isLive(auth.session.id)) return json3(res, 401, { error: "Session ended" });
+      const secret = String(req.headers["x-omb-computer-secret"] ?? "");
+      if (path === "/api/shared-computers/connect") {
+        const parsed = sharedComputerRegistration.safeParse(body);
+        if (!parsed.success) return json3(res, 400, { error: "Invalid computer registration" });
+        const registration = parsed.data;
+        if (registration.environmentId !== ENVIRONMENT_ID) return json3(res, 409, { error: "Workspace identity changed. Pair again before sharing this computer." });
+        sharedComputers.register(registration, auth.session.id, secret);
+        return json3(res, 200, { ok: true });
+      }
+      const route = /^\/api\/shared-computers\/([\w-]+)\/(poll|lease|result|disconnect)$/.exec(path);
+      if (!route) return json3(res, 404, { error: "not found" });
+      const [, id, action] = route;
+      if (action === "poll") return json3(res, 200, { job: await sharedComputers.poll(id, auth.session.id, secret) });
+      if (action === "lease") return json3(res, 200, { active: sharedComputers.liveJob(id, auth.session.id, secret, String(body?.jobId)) });
+      if (action === "result") sharedComputers.complete(id, auth.session.id, secret, String(body?.jobId), body?.result);
+      if (action === "disconnect") sharedComputers.disconnect(id, auth.session.id, secret);
+      return json3(res, 200, { ok: true });
+    }
     if (method === "GET" && path === "/api/auth/sessions") {
       return json3(res, 200, { sessions: sessions.list(), current: auth.kind === "session" ? auth.session.id : null });
     }
@@ -75708,7 +76450,7 @@ var handleRequest = async (req, res) => {
       const actual = Array.isArray(req.headers["x-openmausbot-test-capability"]) ? "" : String(req.headers["x-openmausbot-test-capability"] ?? "");
       const expectedBytes = Buffer.from(expected);
       const actualBytes = Buffer.from(actual);
-      if (!expected || actualBytes.length !== expectedBytes.length || !timingSafeEqual4(actualBytes, expectedBytes)) return json3(res, 404, { error: "not found" });
+      if (!expected || actualBytes.length !== expectedBytes.length || !timingSafeEqual5(actualBytes, expectedBytes)) return json3(res, 404, { error: "not found" });
       const parsed = external_exports.object({
         botId: external_exports.string().regex(/^[\w-]{1,128}$/),
         threadId: external_exports.string().regex(/^[\w-]{1,128}$/),
@@ -75741,7 +76483,7 @@ var handleRequest = async (req, res) => {
       if (internalCapability.kind !== requiredCapabilityKind) {
         return json3(res, 403, { error: "this internal capability cannot access that service" });
       }
-      if (internalCapability.roomCoordination && method === "POST" && ["/api/internal/ask-bot", "/api/internal/delegate-bot", "/api/internal/threads"].includes(path)) {
+      if (internalCapability.roomCoordination && method === "POST" && ["/api/internal/ask-bot", "/api/internal/delegate-bot"].includes(path)) {
         return json3(res, 409, { error: "Use coordinate_bots for teamwork; it queues actual teammates and resumes you automatically." });
       }
       for (const key3 of ["self", "fromBotId", "botId"]) {
@@ -75819,6 +76561,13 @@ var handleRequest = async (req, res) => {
         requireActiveInternalCapability();
         return json3(res, 200, { result });
       }
+      if (method === "GET" && path === "/api/internal/shared-computers" && sharedComputersEnabled(cfg)) return json3(res, 200, { computers: sharedComputers.list() });
+      if (method === "POST" && path === "/api/internal/shared-computers" && sharedComputersEnabled(cfg)) {
+        const parsed = sharedComputerOperation.safeParse(await readInternalBody());
+        if (!sharedComputersEnabled(cfg)) return json3(res, 404, { error: "unknown internal endpoint" });
+        if (!parsed.success) return json3(res, 400, { error: "Invalid shared computer operation" });
+        return json3(res, 200, { result: await sharedComputers.request(parsed.data, () => sharedComputersEnabled(cfg) && internalCapabilityIsActive(internalCapability)) });
+      }
       if (method === "GET" && path === "/api/internal/agents") {
         const sender = internalSender;
         const bots = reachablePeers(store.bots, sender).map((b2) => {
@@ -75848,6 +76597,7 @@ var handleRequest = async (req, res) => {
           if (task2.activity === "waiting-on-you") return "waiting-on-you";
           if (threadBusy(bot.id, task2.threadId)) return "running";
           if (queuedThreadPosition(bot.id, task2.threadId) !== null) return "queued";
+          if (roomHandoffs.activeDirect(task2.threadId)) return "queued";
           if (task2.closedBy) return "closed";
           return "idle";
         };
@@ -75898,7 +76648,7 @@ var handleRequest = async (req, res) => {
           return json3(res, 403, { error: "that thread is not yours to close \u2014 only the bot that opened it, or its own bot, can" });
         }
         if (threadId === fromThreadId) return json3(res, 400, { error: "you cannot close the thread you are speaking in \u2014 finish your turn instead" });
-        if (threadBusy(owner2.id, threadId)) {
+        if (threadBusy(owner2.id, threadId) || queuedThreadPosition(owner2.id, threadId) !== null || roomHandoffs.activeDirect(threadId)) {
           return json3(res, 409, { error: `#${task2.title} is still running \u2014 wait for it to finish (list_threads), or the person can stop it from the app` });
         }
         if (task2.closedBy) {
@@ -76518,7 +77268,13 @@ var handleRequest = async (req, res) => {
                 const existing = roomHandoffs.children(internalCapability.roomHandoffId ?? internalCapability.generation).find((node3) => node3.key === parsed.data.requestKey + ":" + target.botId);
                 if (existing) target.threadId = existing.threadId;
                 else {
-                  const task2 = store.createTask(target.botId, parsed.data.message, false);
+                  const task2 = store.createTask(
+                    target.botId,
+                    parsed.data.message,
+                    false,
+                    void 0,
+                    { botId: internalSender.id, name: internalSender.name, at: Date.now() }
+                  );
                   if (!task2) throw new Error("The recipient no longer exists");
                   target.threadId = createdThread = task2.threadId;
                 }
@@ -76660,15 +77416,23 @@ var handleRequest = async (req, res) => {
         const toBotId = typeof body.toBotId === "string" && body.toBotId.trim() ? body.toBotId.trim() : from.id;
         const target = store.bot(toBotId);
         if (!target) return json3(res, 404, { error: "no such bot" });
-        const folder2 = typeof body.folder === "string" ? body.folder.trim() : "";
+        if (internalCapability.roomCoordination) {
+          if (target.id !== from.id) {
+            return json3(res, 409, { error: "Use coordinate_bots for teamwork; it queues actual teammates and resumes you automatically." });
+          }
+          if (!internalCapability.ownThreadCreation) {
+            return json3(res, 409, { error: "Only a direct user request can open separate self-owned threads. Finish this assigned work here; use coordinate_bots for teammates." });
+          }
+        }
+        const folder3 = typeof body.folder === "string" ? body.folder.trim() : "";
         let projectId;
-        if (folder2) {
+        if (folder3) {
           const project = (target.projects ?? []).find(
-            (candidate) => candidate.id === folder2 || candidate.name.trim().toLowerCase() === folder2.toLowerCase()
+            (candidate) => candidate.id === folder3 || candidate.name.trim().toLowerCase() === folder3.toLowerCase()
           );
           if (!project) {
             const names = (target.projects ?? []).map((candidate) => candidate.name).join(", ");
-            return json3(res, 400, { error: `@${target.name} has no folder named "${folder2}"${names ? ` \u2014 the folders are: ${names}` : " \u2014 it has no folders; leave folder out"}` });
+            return json3(res, 400, { error: `@${target.name} has no folder named "${folder3}"${names ? ` \u2014 the folders are: ${names}` : " \u2014 it has no folders; leave folder out"}` });
           }
           projectId = project.id;
         }
@@ -76920,7 +77684,7 @@ ${message3}`;
             description: `${reason ? `${target.description} ${reason}` : target.description} ${from.name} can use it but never read it back.`,
             placeholder: target.placeholder,
             helpUrl: target.helpUrl,
-            requestKey: randomUUID25()
+            requestKey: randomUUID27()
           }
         });
         return json3(res, 201, { messageId: message3.id, label: target.label });
@@ -76949,7 +77713,7 @@ ${message3}`;
         const bot = store.bot(botId);
         if (!bot) return json3(res, 404, { error: "no such bot" });
         if (method === "GET") {
-          const snapshot2 = computerControl.snapshot(botId);
+          const snapshot2 = botComputerControlSnapshot(botId, internalCapability.teamComputerId);
           const computer = turnComputerResources.get(internalCapability.threadId);
           if (!snapshot2.held && computer && computer.owner.generation === internalCapability.generation && !claimTurnResource(computer.owner, computer.resource)) {
             return json3(res, 200, {
@@ -76962,7 +77726,8 @@ ${message3}`;
         }
         if (method === "POST") {
           const body = await readInternalBody();
-          const { snapshot: snapshot2, requestId } = computerControl.requestHelpLease(botId, body.reason);
+          const controlKey = internalCapability.teamComputerId ? teamComputerOwner(internalCapability.teamComputerId) : botId;
+          const { snapshot: snapshot2, requestId } = computerControl.requestHelpLease(controlKey, body.reason);
           const roomTurn = activeGroupTurnForBot(bot.id);
           const target = blockedTarget({ ...bot, threadId: internalCapability.threadId }, roomTurn && { ...roomTurn.group, threadId: roomTurn.threadId });
           notify(
@@ -76974,7 +77739,7 @@ ${message3}`;
         }
         if (method === "DELETE") {
           const body = await readInternalBody();
-          const snapshot2 = computerControl.expireHelp(botId, body.requestId);
+          const snapshot2 = computerControl.expireHelp(internalCapability.teamComputerId ? teamComputerOwner(internalCapability.teamComputerId) : botId, body.requestId);
           return json3(res, 200, { held: snapshot2.held, helpOpen: snapshot2.helpReason !== null });
         }
         return json3(res, 405, { error: "method not allowed" });
@@ -77173,6 +77938,10 @@ ${message3}`;
       }
       const browser = await browserIntegration(bot.id, bot.browserProfile);
       if (!browser) return json3(res, 503, { error: "Install the browser engine first." });
+      if (HOSTED_WORKSPACE && auth.kind === "session") {
+        const failure5 = workspaceAccess ? await workspaceAccess.authorize(req, auth) : { status: 503, error: "Workspace sign-in is unavailable." };
+        if (failure5) return json3(res, failure5.status, { error: failure5.error });
+      }
       const owner2 = auth.kind === "session" ? auth.session.id : "local-owner";
       const isCurrent = () => {
         const current2 = store.bot(bot.id);
@@ -77270,7 +78039,7 @@ data: ${JSON.stringify({ kind: "ping" })}
         groups: store.groups.map((g2) => ({ ...publicGroupState(g2), ...messagePage(g2.threadId, limit) })),
         computerControl: Object.fromEntries(
           store.bots.map((bot) => {
-            const snapshot2 = computerControl.snapshot(bot.id);
+            const snapshot2 = botComputerControlSnapshot(bot.id);
             return [bot.id, { held: snapshot2.held, helpReason: snapshot2.helpReason }];
           })
         )
@@ -77974,7 +78743,7 @@ data: ${JSON.stringify({ kind: "ping" })}
       for (const threadId of threadIds) {
         for (const dir of [EVENTS_DIR, NATIVE_DIR]) {
           try {
-            unlinkSync12(join61(dir, `${threadId}.ndjson`));
+            unlinkSync13(join61(dir, `${threadId}.ndjson`));
           } catch {
           }
         }
@@ -78128,6 +78897,7 @@ data: ${JSON.stringify({ kind: "ping" })}
     if (path === "/api/sidebar-sections" && (method === "PATCH" || method === "DELETE")) {
       const section2 = url2.searchParams.get("section")?.trim();
       if (!section2) return json3(res, 400, { error: "Choose a named team" });
+      if (teamComputers.forSection(section2)) return json3(res, 409, { error: "Unassign this team's computer before renaming or deleting the team" });
       let nextName = null;
       if (method === "PATCH") {
         const parsed = external_exports.object({ name: external_exports.string().trim().min(1).max(60) }).strict().safeParse(await readBody(req));
@@ -78149,6 +78919,10 @@ data: ${JSON.stringify({ kind: "ping" })}
       }
       const botIds = [...new Set(parsed.data.botIds)];
       if (!name2 && !botIds.length) return json3(res, 400, { error: "Team name is required" });
+      for (const botId of botIds) {
+        const bot = store.bot(botId);
+        if (bot) assertTeamComputerChangeIdle(bot, { ...bot, section: name2 || void 0 });
+      }
       const result = store.setBotsSection(botIds, name2);
       if (!result.ok) {
         if (result.reason === "chief-conflict") {
@@ -78637,11 +79411,13 @@ data: ${JSON.stringify({ kind: "ping" })}
         return json3(res, 409, { error: "Stop the bot and release browser control before changing its profile." });
       }
       if (profile.patch.soul !== void 0) {
+        if (freshBrowserBot) assertTeamComputerChangeIdle(freshBrowserBot, { ...freshBrowserBot, ...patch });
         const runtimePatch = { ...patch };
         for (const field of Object.keys(profile.patch)) delete runtimePatch[field];
         if (Object.keys(runtimePatch).length) store.patchBot(m2[1], runtimePatch);
         bot = store.patchBotProfile(m2[1], profile.patch);
       } else {
+        if (freshBrowserBot) assertTeamComputerChangeIdle(freshBrowserBot, { ...freshBrowserBot, ...patch });
         bot = store.patchBot(m2[1], patch);
       }
       if (!bot) return json3(res, 404, { error: "no such bot" });
@@ -79523,6 +80299,104 @@ data: ${JSON.stringify({ kind: "ping" })}
       broadcast({ kind: "bot", bot: fresh });
       return json3(res, 200, { bot: fresh });
     }
+    if (path === "/api/team-computers" && method === "GET") {
+      res.setHeader("cache-control", "private, no-store");
+      return json3(res, 200, await teamComputersPayload());
+    }
+    m2 = path.match(/^\/api\/team-computers(?:\/([\w-]+)(?:\/(provision|join|sleep|control))?)?$/);
+    if (m2) {
+      const computerId = m2[1];
+      const action = m2[2];
+      let found = computerId ? teamComputers.get(computerId) : void 0;
+      if (computerId && !found) return json3(res, 404, { error: "No such team computer" });
+      if (method === "GET" && action === "control" && found) {
+        return json3(res, 200, computerControl.snapshot(teamComputerOwner(found.id)));
+      }
+      if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) return json3(res, 415, { error: "content-type must be application/json" });
+      const body = await readBody(req);
+      found = computerId ? teamComputers.get(computerId) : void 0;
+      const assertCurrentOwner = () => {
+        if (auth.kind === "session" && !sessions.isLive(auth.session.id)) throw Object.assign(new Error("Your session ended; sign in again"), { status: 401 });
+        if (computerProviderConfigTransitions.has("box")) throw Object.assign(new Error(providerTransitionMessage("box")), { status: 409 });
+      };
+      assertCurrentOwner();
+      if (action === "control" && method === "POST" && found) {
+        const parsed = external_exports.object({ action: external_exports.enum(["take", "release"]), controlLeaseId: controlLeaseIdSchema.optional() }).strict().safeParse(body);
+        if (!parsed.success) return json3(res, 400, { error: "Choose take or release with a valid optional controlLeaseId" });
+        const key3 = teamComputerOwner(found.id);
+        if (parsed.data.action === "take" && boxLifecycleBusyBots.has(key3)) return json3(res, 409, { error: "Wait for this computer's action to finish before taking control" });
+        if (parsed.data.action === "take") assertTeamControlCanBeTaken(found.id);
+        if (parsed.data.controlLeaseId) {
+          const result = parsed.data.action === "take" ? computerControl.acquireLease(key3, parsed.data.controlLeaseId) : computerControl.releaseLease(key3, parsed.data.controlLeaseId);
+          return json3(res, 200, { ...result.snapshot, ...result });
+        }
+        return json3(res, 200, parsed.data.action === "take" ? computerControl.take(key3) : computerControl.release(key3));
+      }
+      if (method === "PATCH" && found && !action) {
+        const parsed = teamComputerAssignment.safeParse(body);
+        if (!parsed.success) return json3(res, 400, { error: "Confirm shared desktop access with section and acknowledgeSharedAccess: true" });
+        const section2 = parsed.data.section;
+        const checkAssignment = () => {
+          assertCurrentOwner();
+          if (section2 !== null && section2 !== "" && !store.sections.includes(section2)) throw Object.assign(new Error("Create the team before assigning a computer"), { status: 404 });
+          if (section2 !== null && store.bots.some((bot) => sectionKey3(bot.section) === section2 && (botHasActiveTurn(bot.id) || routines?.activeRunForBot(bot.id) || botComputerControlSnapshot(bot.id).held || boxLifecycleBusyBots.has(bot.id)))) throw Object.assign(new Error("Stop the target team's work and release computer control before assigning this computer"), { status: 409 });
+        };
+        checkAssignment();
+        const release = claimTeamComputerLifecycle(found);
+        try {
+          if (section2 !== null && !await findBox(cfg, teamComputerOwner(found.id))) return json3(res, 409, { error: "Create or retry this computer before assigning it to a team" });
+          checkAssignment();
+          if (teamComputerInUse(found)) return json3(res, 409, { error: "This team computer became busy; stop its work before assigning it" });
+          teamComputers.assign(found.id, section2);
+          return json3(res, 200, { ok: true });
+        } finally {
+          release();
+        }
+      }
+      if (method === "POST" && !computerId) {
+        const parsed = teamComputerCreate.safeParse(body);
+        if (!parsed.success) return json3(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid Box" });
+        if (!boxConfigured(cfg)) return json3(res, 409, { error: "Configure Box in Settings before creating a cloud computer" });
+        const computer = teamComputers.create(parsed.data.name, parsed.data.requestId);
+        const release = claimTeamComputerLifecycle(computer);
+        try {
+          await provisionBox(cfg, teamComputerOwner(computer.id), computer.name);
+          teamComputers.setProblem(computer.id);
+          return json3(res, 201, { id: computer.id });
+        } catch (error51) {
+          teamComputers.setProblem(computer.id, redactSecretsInText(error51 instanceof Error ? error51.message : String(error51)));
+          throw error51;
+        } finally {
+          release();
+        }
+      }
+      if (method === "POST" && found && action && action !== "control") {
+        if (action === "provision" && body?.acknowledgeCost !== true) return json3(res, 400, { error: "Confirm Box creation or wake costs with acknowledgeCost: true" });
+        if (action === "join") {
+          const key3 = teamComputerOwner(found.id);
+          if (boxLifecycleBusyBots.has(key3)) return json3(res, 409, { error: "Wait for this computer's action to finish" });
+          if (!computerControl.snapshot(key3).held) return json3(res, 409, { error: "Take control before opening this shared desktop" });
+          const release2 = claimBotComputerLifecycle(key3);
+          try {
+            return json3(res, 200, await joinReadyBox(cfg, key3));
+          } finally {
+            release2();
+          }
+        }
+        const release = claimTeamComputerLifecycle(found);
+        try {
+          const result = action === "provision" ? await provisionBox(cfg, teamComputerOwner(found.id), found.name) : await sleepBox(cfg, teamComputerOwner(found.id));
+          teamComputers.setProblem(found.id);
+          return json3(res, 200, result);
+        } catch (error51) {
+          teamComputers.setProblem(found.id, redactSecretsInText(error51 instanceof Error ? error51.message : String(error51)));
+          throw error51;
+        } finally {
+          release();
+        }
+      }
+      return json3(res, 405, { error: "method not allowed" });
+    }
     if (method === "GET" && path === "/api/computers/boxes") {
       res.setHeader("cache-control", "private, no-store");
       return json3(res, 200, await listManagedBoxes(cfg, managedBoxOwners()));
@@ -79804,8 +80678,10 @@ data: ${JSON.stringify({ kind: "ping" })}
       }
       const kind = provider;
       const saved = kind === "anthropic" ? cfg.anthropic : kind === "openaiCompat" ? cfg.openaiCompat : cfg.xai;
-      const pasted = typeof body?.key === "string" ? body.key.trim() : "";
-      const key3 = pasted || saved?.key || "";
+      if (body?.key !== void 0 && typeof body.key !== "string") {
+        return json3(res, 400, { error: "key must be a string" });
+      }
+      const key3 = typeof body?.key === "string" ? body.key.trim() : saved?.key?.trim() || "";
       if (!key3) return json3(res, 400, { error: "No key to test. Paste one or save one first." });
       if (key3.length > 512) return json3(res, 400, { error: "That does not look like an API key." });
       const url3 = typeof body?.url === "string" && body.url.trim() ? body.url.trim() : saved?.url;
@@ -80416,6 +81292,11 @@ data: ${JSON.stringify({ kind: "ping" })}
           throw error51;
         }
         let browserReferenceCleanupError = null;
+        if (patch.signIn !== void 0) sessions.revalidateEmailSessions();
+        if (!sharedComputersEnabled(cfg)) {
+          sharedComputers.close();
+          sharedComputerControl.close();
+        }
         if (disablingBuiltInBrowser) browserLive.closeAll();
         for (const request2 of browserCleanupRequests) {
           if (request2.kind === "profile") browserLive.closeForSession(browserSessionId("", request2.partitionId));
@@ -80670,29 +81551,36 @@ data: ${JSON.stringify({ kind: "ping" })}
     if (m2 && method === "GET") {
       const bot = store.bot(m2[1]);
       if (!bot) return json3(res, 404, { error: "no such bot" });
+      const teamComputer = inheritedTeamComputer(bot);
+      if (teamComputer) return json3(res, 200, { backend: "box", teamComputer: { id: teamComputer.id, name: teamComputer.name }, ...await boxStatus(cfg, teamComputerOwner(teamComputer.id)) });
       return bot.cloudBackend === "vps" ? json3(res, 200, { backend: "vps", ...await vpsComputerStatus(cfg, bot.id) }) : json3(res, 200, { backend: "box", ...await boxStatus(cfg, bot.id) });
     }
     m2 = path.match(/^\/api\/bots\/([\w-]+)\/computer\/control$/);
     if (m2) {
       const bot = store.bot(m2[1]);
       if (!bot) return json3(res, 404, { error: "no such bot" });
-      if (method === "GET") return json3(res, 200, computerControl.snapshot(bot.id));
+      if (method === "GET") return json3(res, 200, botComputerControlSnapshot(bot.id));
       if (method === "POST") {
         if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
           return json3(res, 415, { error: "content-type must be application/json" });
         }
         const body = await readBody(req);
         const action = String(body.action ?? "");
+        const currentBot = store.bot(bot.id);
+        if (!currentBot) return json3(res, 404, { error: "no such bot" });
+        const controlKey = botComputerControlKey(currentBot);
+        const teamComputer = inheritedTeamComputer(currentBot);
+        if (action === "take" && teamComputer) assertTeamControlCanBeTaken(teamComputer.id);
         const leaseResult = body.controlLeaseId === void 0 ? null : controlLeaseIdSchema.safeParse(body.controlLeaseId);
         if (leaseResult && !leaseResult.success) {
           return json3(res, 400, { error: "controlLeaseId is invalid" });
         }
         const controlLeaseId = leaseResult?.data;
-        if (action === "take" && boxLifecycleBusyBots.has(bot.id)) {
+        if (action === "take" && (boxLifecycleBusyBots.has(bot.id) || boxLifecycleBusyBots.has(controlKey))) {
           return json3(res, 409, { error: "this bot's cloud computer is being changed \u2014 wait before taking control" });
         }
         if (action === "take" && controlLeaseId) {
-          const result = computerControl.acquireLease(bot.id, controlLeaseId);
+          const result = computerControl.acquireLease(controlKey, controlLeaseId);
           return json3(res, 200, {
             ...result.snapshot,
             owned: result.owned,
@@ -80700,12 +81588,12 @@ data: ${JSON.stringify({ kind: "ping" })}
           });
         }
         if (action === "release" && controlLeaseId) {
-          const result = computerControl.releaseLease(bot.id, controlLeaseId);
+          const result = computerControl.releaseLease(controlKey, controlLeaseId);
           return json3(res, 200, { ...result.snapshot, released: result.released });
         }
-        if (action === "take") return json3(res, 200, computerControl.take(bot.id));
-        if (action === "release") return json3(res, 200, computerControl.release(bot.id));
-        if (action === "dismiss-help") return json3(res, 200, computerControl.dismissHelp(bot.id));
+        if (action === "take") return json3(res, 200, computerControl.take(controlKey));
+        if (action === "release") return json3(res, 200, computerControl.release(controlKey));
+        if (action === "dismiss-help") return json3(res, 200, computerControl.dismissHelp(controlKey));
         return json3(res, 400, { error: "action must be take, release, or dismiss-help" });
       }
       return json3(res, 405, { error: "method not allowed" });
@@ -80734,6 +81622,22 @@ data: ${JSON.stringify({ kind: "ping" })}
       if (boxLifecycleBusyBots.has(botId)) {
         return json3(res, 409, { error: "this bot's cloud computer is being changed \u2014 wait for it to finish" });
       }
+      const teamComputer = inheritedTeamComputer(bot);
+      if (teamComputer) {
+        const key3 = teamComputerOwner(teamComputer.id);
+        if (boxLifecycleBusyBots.has(key3)) return json3(res, 409, { error: "This team computer is being changed; wait for it to finish" });
+        if (m2[2] === "provision" || m2[2] === "remove") return json3(res, 409, { error: "Manage this shared computer from the Team map" });
+        if (m2[2] === "exec") return json3(res, 409, { error: "Use the bot's scoped computer tools for this shared desktop" });
+        if (m2[2] === "join" && !computerControl.snapshot(key3).held) return json3(res, 409, { error: "Take control before opening this shared desktop" });
+        const release = m2[2] === "sleep" ? claimTeamComputerLifecycle(teamComputer) : claimBotComputerLifecycle(key3);
+        try {
+          if (m2[2] === "join") return json3(res, 200, await joinReadyBox(cfg, key3));
+          if (m2[2] === "screenshot") return json3(res, 200, await screenshotBox(cfg, key3));
+          return json3(res, 200, await sleepBox(cfg, key3));
+        } finally {
+          release();
+        }
+      }
       if (bot.cloudBackend === "vps") {
         if (m2[2] === "screenshot") {
           let preview = vpsPreviewRequests.get(botId);
@@ -80818,6 +81722,11 @@ data: ${JSON.stringify({ kind: "ping" })}
 var server = createServer3(handleRequest);
 calendarCalls.start();
 console.log(describeEdition(await loadEnterpriseLayer()));
+workspaceAccess = createWorkspaceAccess({ sessions, cookieName: SESSION_COOKIE, closeSessionStreams });
+var workspaceAccessTimer = workspaceAccess ? setInterval(() => {
+  void workspaceAccess.revalidate().catch((error51) => console.warn("workspace access revalidation failed", error51));
+}, 1e4) : null;
+workspaceAccessTimer?.unref();
 console.log(describeBrand(loadBrand()));
 try {
   const reclaimedPartials = cleanupStaleAttachmentPartials();
@@ -80886,7 +81795,10 @@ var gracefulShutdown = createGracefulShutdown({
   cleanup: [
     () => {
       followupsReady = false;
+      if (workspaceAccessTimer) clearInterval(workspaceAccessTimer);
       revokeAllInternalCapabilities();
+      sharedComputers.close();
+      sharedComputerControl.close();
       browserLive.closeAll();
       for (const idle of localVmIdles.values()) idle.cancel();
       closeAllVpsDesktopTunnels();
@@ -80910,6 +81822,12 @@ var gracefulShutdown = createGracefulShutdown({
   // the shutdown deadline), immediately before the process exits, so no new
   // server can overlap with a still-mutating old one.
   exit: (code) => {
+    try {
+      sessions.close();
+    } catch {
+      console.error("Session persistence failed during shutdown; account sign-in will be required again.");
+      code = 1;
+    }
     closeMessageDb();
     releaseDataDirLeaseAtExit();
     process.exit(code);