@nexusgame/dev 0.2.0 → 0.4.0

package/dist/engine-worker.js

@@ -2670,6 +2670,15 @@ var sign2 = Jwt.sign;
 
 // src/runtime/game-worker-client.ts
 function resolveGameWorkerClient(gameId, baseUrl, env) {
+  const normalizedBaseUrl = (baseUrl || "").replace(/\/$/, "");
+  if (normalizedBaseUrl) {
+    return {
+      async fetch(path, init) {
+        const cleanPath = path.startsWith("/") ? path : `/${path}`;
+        return fetch(`${normalizedBaseUrl}${cleanPath}`, init);
+      }
+    };
+  }
   const bindingName = `GAME_${gameId.toUpperCase()}`;
   const binding = env[bindingName];
   if (binding && typeof binding.fetch === "function") {
@@ -2681,14 +2690,7 @@ function resolveGameWorkerClient(gameId, baseUrl, env) {
       }
     };
   }
-  console.log("Using global fetch for game", gameId);
-  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
-  return {
-    async fetch(path, init) {
-      const cleanPath = path.startsWith("/") ? path : `/${path}`;
-      return fetch(`${normalizedBaseUrl}${cleanPath}`, init);
-    }
-  };
+  throw new Error(`No game worker URL or service binding for game ${gameId}`);
 }
 
 // src/managers/base.ts
@@ -2698,6 +2700,18 @@ var BaseManager = class {
   }
 };
 
+// src/identity.ts
+function generateLlmUserId(modelName) {
+  const uuid = crypto.randomUUID().slice(0, 8);
+  return `llm:${modelName}:${uuid}`;
+}
+function getRoleForUser(roleMapping, userId) {
+  for (const [roleId, uid] of Object.entries(roleMapping)) {
+    if (uid === userId) return roleId;
+  }
+  return null;
+}
+
 // src/managers/presence.ts
 var PresenceManager = class extends BaseManager {
   async handleSession(ws, userId, displayName) {
@@ -2729,7 +2743,10 @@ var PresenceManager = class extends BaseManager {
     this.room.connections.set(ws, userId);
     this.room.sessions.set(userId, ws);
     await this.room.persist("players");
-    this.sendSyncState(ws, userId);
+    await this.sendSyncState(ws, userId);
+    if (isOwner) {
+      this.room.sendPendingJoinRequests(ws);
+    }
     if (isAlreadyMember || isOwner) {
       this.broadcastSyncStateExcept(userId);
     }
@@ -2814,7 +2831,7 @@ var PresenceManager = class extends BaseManager {
       ownerDisplayName: isAuthorized ? this.room.ownerDisplayName : "Room Owner",
       name: isAuthorized ? this.room.name : "",
       isPublic: isAuthorized ? this.room.isPublic : true,
-      phase: isAuthorized ? this.room.phase : "authorized_check",
+      phase: isAuthorized ? this.room.phase : null,
       players: clientPlayers,
       gameConfig: isAuthorized && this.room.gameConfig ? {
         gameId: this.room.gameConfig.gameId,
@@ -2856,8 +2873,6 @@ var PresenceManager = class extends BaseManager {
 };
 
 // src/managers/room.ts
-var WORKER_VERIFY_PATH = "/__nexus_worker_verify";
-var WORKER_VERIFY_SIGNATURE = "NEXUS_GAME_WORKER_VERIFIED_V1";
 var RoomManager = class extends BaseManager {
   async handleSelectRole(userId, roleId) {
     if (this.room.phase !== "lobby") {
@@ -2887,6 +2902,7 @@ var RoomManager = class extends BaseManager {
       }
     }
     delete this.room.players[userId];
+    await this.room.clearJoinRequest(userId);
     const ws = this.room.sessions.get(userId);
     if (ws) {
       try {
@@ -2899,116 +2915,20 @@ var RoomManager = class extends BaseManager {
     await this.room.persist("players", "roleMapping");
     this.room.broadcastSyncState();
   }
-  async handleAdminSetGame(userId, payload) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase !== "lobby") {
-      return this.room.sendErrorToUser(userId, "Can only set game in lobby phase");
-    }
-    try {
-      const baseUrl = payload.gameWorkerUrl.replace(/\/$/, "");
-      const client = resolveGameWorkerClient(payload.gameId, baseUrl, this.room.bindings);
-      const verifyRes = await client.fetch(WORKER_VERIFY_PATH);
-      if (!verifyRes.ok) {
-        return this.room.sendErrorToUser(userId, "Game worker verification failed");
-      }
-      const signature = (await verifyRes.text()).trim();
-      if (signature !== WORKER_VERIFY_SIGNATURE) {
-        return this.room.sendErrorToUser(userId, "Game worker verification signature mismatch");
-      }
-      const metaRes = await client.fetch("/metadata");
-      if (!metaRes.ok) {
-        return this.room.sendErrorToUser(userId, "Failed to fetch game metadata");
-      }
-      const metadata = await metaRes.json();
-      let roleIds;
-      let resolvedPlayerCount;
-      if (Array.isArray(metadata.roleIds)) {
-        roleIds = metadata.roleIds;
-        resolvedPlayerCount = roleIds.length;
-      } else {
-        const counts = Object.keys(metadata.roleIds).map(Number).sort((a, b) => a - b);
-        const selectedCount = payload.selectedPlayerCount;
-        const effectiveCount = selectedCount && metadata.roleIds[selectedCount] ? selectedCount : counts[0];
-        roleIds = metadata.roleIds[effectiveCount] || [];
-        resolvedPlayerCount = effectiveCount;
-      }
-      this.room.gameConfig = {
-        gameWorkerUrl: baseUrl,
-        gameId: payload.gameId || metadata.id,
-        maxPlayers: roleIds.length,
-        roleIds,
-        selectedPlayerCount: resolvedPlayerCount,
-        enable_llm_memory: metadata.enable_llm_memory,
-        auto_save_mode: metadata.auto_save_mode
-      };
-      this.room.roleMapping = {};
-      await this.room.persist("gameConfig", "roleMapping");
-      this.room.broadcastSyncState();
-      this.room.waitUntil(this.room.syncRoomMeta());
-    } catch (e) {
-      console.error("[RoomManager] Failed to set game:", e);
-      this.room.sendErrorToUser(userId, "Failed to set game");
-    }
-  }
-  async handleAdminRemovePlayer(userId, targetUserId) {
-    if (!this.room.requireOwner(userId)) return;
-    if (targetUserId === this.room.ownerId) {
-      return this.room.sendErrorToUser(userId, "Cannot remove the room owner");
-    }
-    if (!this.room.players[targetUserId]) {
-      return this.room.sendErrorToUser(userId, "Player not found");
-    }
-    for (const [rId, uId] of Object.entries(this.room.roleMapping)) {
-      if (uId === targetUserId) {
-        delete this.room.roleMapping[rId];
-      }
-    }
-    delete this.room.players[targetUserId];
-    const targetWs = this.room.sessions.get(targetUserId);
-    if (targetWs) {
-      this.room.sendMessage(targetWs, { type: "KICKED", payload: "Removed by room owner" });
-      try {
-        targetWs.close(1e3, "Kicked");
-      } catch (_) {
-      }
-      this.room.connections.delete(targetWs);
-      this.room.sessions.delete(targetUserId);
-    }
-    await this.room.persist("players", "roleMapping");
-    this.room.broadcastSyncState();
-  }
-  async handleAdminAssignRole(userId, payload) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase !== "lobby") {
-      return this.room.sendErrorToUser(userId, "Can only assign roles in lobby phase");
-    }
-    if (!this.room.players[payload.userId]) {
-      return this.room.sendErrorToUser(userId, `Player ${payload.userId} not found`);
-    }
-    if (this.room.gameConfig && !this.room.gameConfig.roleIds.includes(payload.roleId)) {
-      return this.room.sendErrorToUser(userId, `Invalid role: ${payload.roleId}`);
-    }
-    for (const [rId, uId] of Object.entries(this.room.roleMapping)) {
-      if (uId === payload.userId) {
-        delete this.room.roleMapping[rId];
-      }
-    }
-    delete this.room.roleMapping[payload.roleId];
-    this.room.roleMapping[payload.roleId] = payload.userId;
-    await this.room.persist("roleMapping");
-    this.room.broadcastSyncState();
-  }
-  async handleAdminApproveJoin(userId, payload) {
-    if (!this.room.requireOwner(userId)) return;
+  async handleAdminApproveJoin(_userId, payload) {
     this.room.players[payload.userId] = {
       displayName: payload.displayName,
       connected: true,
       isOwner: false,
       type: "human"
     };
+    await this.room.clearJoinRequest(payload.userId);
     await this.room.persist("players");
     this.room.broadcastSyncState();
   }
+  async handleAdminIgnoreJoin(_userId, payload) {
+    await this.room.clearJoinRequest(payload.userId);
+  }
 };
 
 // src/monitor-store.ts
@@ -3206,6 +3126,78 @@ async function insertMonitorLog(db, input) {
   return getMonitorLogById(db, input.interactionId);
 }
 
+// src/managers/task-prompts.ts
+var TASK_PROMPT_NO_MEMORY = `
+# \u4EFB\u52A1\u8981\u6C42
+\u8BF7\u5206\u6790\u5F53\u524D\u5C40\u52BF\uFF0C\u9009\u62E9\u4E00\u4E2A\u6700\u4F18\u884C\u52A8\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF1A
+
+\`\`\`json
+{
+  "reasoning": "\u4F60\u7684\u51B3\u7B56\u601D\u8DEF",
+  "action_id": "\u884C\u52A8ID\u5B57\u7B26\u4E32\uFF08\u4ECE\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u9009\u62E9\uFF0C\u4F8B\u5982 'place'\uFF09",
+  "params": {
+    "\u53C2\u6570\u540D": "\u53C2\u6570\u503C"
+  }
+}
+\`\`\`
+
+**\u91CD\u8981\u63D0\u793A**\uFF1A
+1. action_id \u5FC5\u987B\u662F\u5B8C\u5168\u5339\u914D\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u7684\u67D0\u4E2A action_id \u7684\u7EAF\u5B57\u7B26\u4E32\uFF0C\u4E0D\u8981\u5305\u542B\u53C2\u6570\uFF08\u9519\u8BEF\u793A\u4F8B\uFF1A\u274C "place(row: 7, col: 6)"\uFF09
+2. \u5982\u679C\u884C\u52A8\u9700\u8981\u53C2\u6570\uFF0Cparams \u5B57\u6BB5\u5FC5\u987B\u5305\u542B\u6240\u6709\u5FC5\u9700\u7684\u53C2\u6570
+3. \u53C2\u6570\u7684\u7C7B\u578B\u548C\u503C\u5FC5\u987B\u7B26\u5408\u884C\u52A8\u5B9A\u4E49\u7684\u7EA6\u675F
+4. \u53EA\u8FD4\u56DEJSON\u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E`;
+var TASK_PROMPT_WITH_MEMORY = `
+# \u4EFB\u52A1\u8981\u6C42
+\u8BF7\u5206\u6790\u5F53\u524D\u5C40\u52BF\uFF0C\u901A\u8FC7 reasoning \u601D\u8003\u5E76\u9009\u62E9\u4E00\u4E2A\u6700\u4F18\u884C\u52A8\u3002\u5E76\u53EF\u9009\u66F4\u65B0\u8BB0\u5FC6\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF1A
+
+\`\`\`json
+{
+  "reasoning": "\u4F60\u7684\u51B3\u7B56\u601D\u8DEF",
+  "action_id": "\u884C\u52A8ID\u5B57\u7B26\u4E32\uFF08\u4ECE\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u9009\u62E9\uFF0C\u4F8B\u5982 'place'\uFF09",
+  "params": {
+    "\u53C2\u6570\u540D": "\u53C2\u6570\u503C"
+  },
+  "memory_update": {
+    "mode": "append/replace",
+    "content": "\u672C\u56DE\u5408\u7684\u65B0\u89C2\u5BDF\u548C\u63A8\u7406\uFF08\u53EF\u9009\uFF09"
+  }
+}
+\`\`\`
+
+
+**\u8BB0\u5FC6\u66F4\u65B0\u8BF4\u660E**\uFF1A
+- \u4F60\u53EF\u4EE5\u5728 \`memory_update\` \u5B57\u6BB5\u4E2D\u66F4\u65B0\u4F60\u7684\u8BB0\u5FC6
+- \`mode: "append"\` - \u8FFD\u52A0\u5230\u73B0\u6709\u8BB0\u5FC6
+- \`mode: "replace"\` - \u66FF\u6362\u8BB0\u5FC6\uFF0C\u5982\u91CD\u65B0\u603B\u7ED3\u5F62\u6210\u65B0\u7684\u8BB0\u5FC6
+- \u5982\u679C\u672C\u56DE\u5408\u65E0\u9700\u66F4\u65B0\u8BB0\u5FC6\uFF0C\u53EF\u7701\u7565 \`memory_update\` \u5B57\u6BB5
+
+
+**\u91CD\u8981\u63D0\u793A**\uFF1A
+1. action_id \u5FC5\u987B\u662F\u5B8C\u5168\u5339\u914D\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u7684\u67D0\u4E2A action_id \u7684\u7EAF\u5B57\u7B26\u4E32\uFF0C\u4E0D\u8981\u5305\u542B\u53C2\u6570\uFF08\u9519\u8BEF\u793A\u4F8B\uFF1A\u274C "place(row: 7, col: 6)"\uFF09
+2. \u5982\u679C\u884C\u52A8\u9700\u8981\u53C2\u6570\uFF0Cparams \u5B57\u6BB5\u5FC5\u987B\u5305\u542B\u6240\u6709\u5FC5\u9700\u7684\u53C2\u6570
+3. \u53C2\u6570\u7684\u7C7B\u578B\u548C\u503C\u5FC5\u987B\u7B26\u5408\u884C\u52A8\u5B9A\u4E49\u7684\u7EA6\u675F
+4. \u53EA\u8FD4\u56DEJSON\u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E`;
+var NO_TASK_PROMPT_WITH_MEMORY = `
+# \u4EFB\u52A1\u8981\u6C42
+\u5F53\u524D\u65E0\u9700\u884C\u52A8\uFF0C\u4F46\u4F60\u53EF\u4EE5\u6839\u636E\u6700\u65B0\u4FE1\u606F\u66F4\u65B0\u4F60\u7684\u8BB0\u5FC6\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E\uFF1A
+
+\`\`\`json
+{
+  "reasoning": "\u4F60\u7684\u89C2\u5BDF\u548C\u601D\u8003\uFF08\u53EF\u9009\uFF09",
+  "memory_update": {
+    "mode": "append",
+    "content": "\u672C\u56DE\u5408\u7684\u65B0\u89C2\u5BDF\u3001\u63A8\u7406\u548C\u91CD\u8981\u4FE1\u606F"
+  }
+}
+\`\`\`
+
+
+**\u8BB0\u5FC6\u66F4\u65B0\u8BF4\u660E**\uFF1A
+- \`mode: "append"\` - \u8FFD\u52A0\u5230\u73B0\u6709\u8BB0\u5FC6\uFF08\u63A8\u8350\uFF09
+- \`mode: "replace"\` - \u5B8C\u5168\u66FF\u6362\u8BB0\u5FC6\uFF0C\u9002\u5408\u91CD\u65B0\u603B\u7ED3\u65F6\u4F7F\u7528
+- \u5EFA\u8BAE\u8BB0\u5F55\uFF1A\u5176\u4ED6\u73A9\u5BB6\u7684\u884C\u52A8\u3001\u53D1\u8A00\u3001\u6295\u7968\u3001\u6B7B\u4EA1\u4FE1\u606F\u3001\u8EAB\u4EFD\u7EBF\u7D22\u7B49\u5173\u952E\u4FE1\u606F
+`;
+
 // src/managers/action-processor.ts
 async function applySuccessfulAction(opts) {
   const {
@@ -3273,357 +3265,74 @@ async function applySuccessfulAction(opts) {
   })());
 }
 
-// src/managers/executor.ts
-var GameExecutor = class extends BaseManager {
-  async handleAdminStartGame(userId) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase !== "lobby" && this.room.phase !== "finished") {
-      return this.room.sendErrorToUser(userId, "Game cannot be started in current phase");
-    }
-    if (!this.room.gameConfig) {
-      return this.room.sendErrorToUser(userId, "No game selected");
+// src/managers/llm.ts
+var LlmManager = class extends BaseManager {
+  async callLlmWebhook(roleId, retryCount = 0) {
+    if (!this.room.llmWebhookUrl) {
+      console.warn(`[LlmManager] Skipping LLM call: LLM_WEBHOOK_URL is not configured (roomId: ${this.room.roomId})`);
+      return;
     }
-    const missingRoles = this.room.gameConfig.roleIds.filter(
-      (rId) => !this.room.roleMapping[rId]
-    );
-    if (missingRoles.length > 0) {
-      return this.room.sendErrorToUser(
-        userId,
-        `Missing role assignments: ${missingRoles.join(", ")}`
-      );
+    const userId = this.room.roleMapping[roleId];
+    const player = this.room.players[userId];
+    if (!player || player.type !== "llm" || !player.llmConfig) {
+      console.warn(`[LlmManager] Skipping LLM call: role ${roleId} is not mapped to an LLM player`);
+      return;
     }
+    console.log(`[LlmManager] Calling LLM webhook for role ${roleId} (attempt: ${retryCount + 1})`);
+    const interactionGroupId = crypto.randomUUID();
+    const interactionId = crypto.randomUUID();
+    const startTs = Date.now();
     try {
-      for (const player of Object.values(this.room.players)) {
-        if (player.type === "llm" && player.llmConfig) {
-          player.llmConfig.memory = "";
+      const perspective = await this.room.fetchPerspective(roleId);
+      if (!perspective) {
+        throw new Error("Failed to fetch perspective from game worker");
+      }
+      const statePrompt = await this.room.fetchStatePrompt(perspective);
+      const hasActions = perspective.action_space_definition?.actions?.length > 0;
+      const memoryEnabled = !!player.llmConfig.memory || player.llmConfig.memory === "";
+      if (!hasActions) {
+        if (!memoryEnabled) {
+          console.log(`[LlmManager] Skipping turn for ${roleId}: No actions and memory disabled`);
+          return;
         }
+        console.log(`[LlmManager] No actions available, but memory enabled. Calling LLM for memory-only update.`);
       }
-      const client = resolveGameWorkerClient(
-        this.room.gameConfig.gameId,
-        this.room.gameConfig.gameWorkerUrl,
-        this.room.bindings
-      );
-      const initRes = await client.fetch("/init", {
+      const userPrompt = this.buildUserPrompt(roleId, perspective, player.llmConfig, statePrompt || void 0);
+      const reqBody = {
+        roomId: this.room.roomId,
+        roleId,
+        gameId: this.room.gameConfig?.gameId || "",
+        perspective,
+        statePrompt: userPrompt,
+        llmConfig: player.llmConfig,
+        attempt: retryCount + 1,
+        maxAttempts: 3
+      };
+      const response = await fetch(this.room.llmWebhookUrl, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          players: this.room.gameConfig.roleIds
-        })
+        headers: {
+          "Content-Type": "application/json",
+          "x-engine-secret": this.room.bindings.LLM_WEBHOOK_SECRET || ""
+        },
+        body: JSON.stringify(reqBody)
       });
-      if (!initRes.ok) {
-        const errText = await initRes.text();
-        return this.room.sendErrorToUser(
+      if (!response.ok) {
+        const errorText = await response.text();
+        await this.logLlmInteraction(
+          interactionId,
+          interactionGroupId,
+          roleId,
           userId,
-          `Game Worker init failed: ${errText}`
+          player,
+          userPrompt,
+          null,
+          null,
+          "failed",
+          errorText,
+          Date.now() - startTs,
+          retryCount + 1
         );
-      }
-      this.room.gameState = await initRes.json();
-      this.room.history = [];
-      this.room.runtimeId = crypto.randomUUID();
-      this.room.stateIndex = 0;
-      this.room.stateHistory = [{
-        index: 0,
-        name: "Initial State",
-        state: this.room.gameState,
-        timestamp: Date.now()
-      }];
-      this.room.phase = "playing";
-      await this.room.persistAll();
-      this.room.broadcastSyncState();
-      await this.room.checkAndTriggerNextTurn();
-    } catch (e) {
-      console.error("[GameExecutor] Failed to start game:", e);
-      this.room.sendErrorToUser(userId, "Failed to start game");
-    }
-  }
-  async handleAdminStopGame(userId) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase === "lobby") {
-      return this.room.sendErrorToUser(userId, "Game has not started");
-    }
-    this.room.phase = "lobby";
-    this.room.gameState = null;
-    this.room.history = [];
-    this.room.stateHistory = [];
-    await this.room.persist("phase", "gameState", "history", "stateHistory");
-    this.room.broadcastSyncState();
-  }
-  async handleAdminRestartGame(userId) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase !== "playing" && this.room.phase !== "paused" && this.room.phase !== "finished") {
-      return this.room.sendErrorToUser(userId, "Nothing to restart");
-    }
-    if (!this.room.gameConfig) {
-      return this.room.sendErrorToUser(userId, "No game selected");
-    }
-    try {
-      for (const player of Object.values(this.room.players)) {
-        if (player.type === "llm" && player.llmConfig) {
-          player.llmConfig.memory = "";
-        }
-      }
-      const client = resolveGameWorkerClient(
-        this.room.gameConfig.gameId,
-        this.room.gameConfig.gameWorkerUrl,
-        this.room.bindings
-      );
-      const initRes = await client.fetch("/init", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          players: Object.keys(this.room.roleMapping)
-        })
-      });
-      if (!initRes.ok) {
-        return this.room.sendErrorToUser(userId, "Game Worker init failed on restart");
-      }
-      this.room.gameState = await initRes.json();
-      this.room.history = [];
-      this.room.runtimeId = crypto.randomUUID();
-      this.room.stateIndex = 0;
-      this.room.stateHistory = [{
-        index: 0,
-        name: "Initial State",
-        state: this.room.gameState,
-        timestamp: Date.now()
-      }];
-      this.room.phase = "playing";
-      await this.room.persistAll();
-      this.room.broadcastSyncState();
-      await this.room.checkAndTriggerNextTurn();
-    } catch (e) {
-      console.error("[GameExecutor] Failed to restart game:", e);
-      this.room.sendErrorToUser(userId, "Failed to restart game");
-    }
-  }
-  async handleAction(userId, payload) {
-    const startedAt = Date.now();
-    if (this.room.phase !== "playing") {
-      return this.room.sendErrorToUser(userId, "Game is not in playing phase");
-    }
-    if (!this.room.gameConfig || !this.room.gameState) {
-      return this.room.sendErrorToUser(userId, "Game not initialized");
-    }
-    const roleId = getRoleForUser(this.room.roleMapping, userId);
-    if (!roleId) {
-      return this.room.sendErrorToUser(userId, "You don't have a role assigned");
-    }
-    const currentRoleId = await this.room.getCurrentRole();
-    if (currentRoleId !== roleId) {
-      return this.room.sendErrorToUser(userId, "Not your turn");
-    }
-    const result = await this.room.submitActionToGameWorker(roleId, {
-      action_id: payload.action_id,
-      params: payload.params || {}
-    });
-    const interactionId = crypto.randomUUID();
-    const baseHumanLog = {
-      interactionId,
-      interactionGroupId: interactionId,
-      roomId: this.room.roomId,
-      gameId: this.room.gameConfig.gameId || null,
-      gameName: null,
-      roleId,
-      userId,
-      playerType: "human",
-      modelName: null,
-      systemPrompt: null,
-      userPrompt: null,
-      response: JSON.stringify({ action_id: payload.action_id, params: payload.params || {} }),
-      action_id: payload.action_id,
-      actionParams: payload.params || {},
-      attempt: 1,
-      outerAttempt: 1,
-      maxAttempts: 1,
-      previousError: null,
-      responseTimeMs: Date.now() - startedAt,
-      eventTs: Date.now()
-    };
-    if (!result.success) {
-      this.room.waitUntil(insertMonitorLog(this.room.bindings.DB, {
-        ...baseHumanLog,
-        status: "rejected",
-        errorMessage: result.error || "Action rejected"
-      }));
-      return this.room.sendErrorToUser(userId, result.error || "Action rejected");
-    }
-    this.room.waitUntil(insertMonitorLog(this.room.bindings.DB, {
-      ...baseHumanLog,
-      status: "success"
-    }));
-    await applySuccessfulAction({
-      room: this.room,
-      roleId,
-      action: { action_id: payload.action_id, params: payload.params || {} },
-      nextState: result.nextState,
-      commands: result.commands,
-      triggerMode: "await"
-    });
-    console.log(`[GameExecutor] Action processed for ${userId} (${roleId}), checking next turn...`);
-  }
-};
-
-// src/managers/task-prompts.ts
-var TASK_PROMPT_NO_MEMORY = `
-# \u4EFB\u52A1\u8981\u6C42
-\u8BF7\u5206\u6790\u5F53\u524D\u5C40\u52BF\uFF0C\u9009\u62E9\u4E00\u4E2A\u6700\u4F18\u884C\u52A8\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF1A
-
-\`\`\`json
-{
-  "reasoning": "\u4F60\u7684\u51B3\u7B56\u601D\u8DEF",
-  "action_id": "\u884C\u52A8ID\u5B57\u7B26\u4E32\uFF08\u4ECE\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u9009\u62E9\uFF0C\u4F8B\u5982 'place'\uFF09",
-  "params": {
-    "\u53C2\u6570\u540D": "\u53C2\u6570\u503C"
-  }
-}
-\`\`\`
-
-**\u91CD\u8981\u63D0\u793A**\uFF1A
-1. action_id \u5FC5\u987B\u662F\u5B8C\u5168\u5339\u914D\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u7684\u67D0\u4E2A action_id \u7684\u7EAF\u5B57\u7B26\u4E32\uFF0C\u4E0D\u8981\u5305\u542B\u53C2\u6570\uFF08\u9519\u8BEF\u793A\u4F8B\uFF1A\u274C "place(row: 7, col: 6)"\uFF09
-2. \u5982\u679C\u884C\u52A8\u9700\u8981\u53C2\u6570\uFF0Cparams \u5B57\u6BB5\u5FC5\u987B\u5305\u542B\u6240\u6709\u5FC5\u9700\u7684\u53C2\u6570
-3. \u53C2\u6570\u7684\u7C7B\u578B\u548C\u503C\u5FC5\u987B\u7B26\u5408\u884C\u52A8\u5B9A\u4E49\u7684\u7EA6\u675F
-4. \u53EA\u8FD4\u56DEJSON\u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E`;
-var TASK_PROMPT_WITH_MEMORY = `
-# \u4EFB\u52A1\u8981\u6C42
-\u8BF7\u5206\u6790\u5F53\u524D\u5C40\u52BF\uFF0C\u901A\u8FC7 reasoning \u601D\u8003\u5E76\u9009\u62E9\u4E00\u4E2A\u6700\u4F18\u884C\u52A8\u3002\u5E76\u53EF\u9009\u66F4\u65B0\u8BB0\u5FC6\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF1A
-
-\`\`\`json
-{
-  "reasoning": "\u4F60\u7684\u51B3\u7B56\u601D\u8DEF",
-  "action_id": "\u884C\u52A8ID\u5B57\u7B26\u4E32\uFF08\u4ECE\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u9009\u62E9\uFF0C\u4F8B\u5982 'place'\uFF09",
-  "params": {
-    "\u53C2\u6570\u540D": "\u53C2\u6570\u503C"
-  },
-  "memory_update": {
-    "mode": "append/replace",
-    "content": "\u672C\u56DE\u5408\u7684\u65B0\u89C2\u5BDF\u548C\u63A8\u7406\uFF08\u53EF\u9009\uFF09"
-  }
-}
-\`\`\`
-
-
-**\u8BB0\u5FC6\u66F4\u65B0\u8BF4\u660E**\uFF1A
-- \u4F60\u53EF\u4EE5\u5728 \`memory_update\` \u5B57\u6BB5\u4E2D\u66F4\u65B0\u4F60\u7684\u8BB0\u5FC6
-- \`mode: "append"\` - \u8FFD\u52A0\u5230\u73B0\u6709\u8BB0\u5FC6
-- \`mode: "replace"\` - \u66FF\u6362\u8BB0\u5FC6\uFF0C\u5982\u91CD\u65B0\u603B\u7ED3\u5F62\u6210\u65B0\u7684\u8BB0\u5FC6
-- \u5982\u679C\u672C\u56DE\u5408\u65E0\u9700\u66F4\u65B0\u8BB0\u5FC6\uFF0C\u53EF\u7701\u7565 \`memory_update\` \u5B57\u6BB5
-
-
-**\u91CD\u8981\u63D0\u793A**\uFF1A
-1. action_id \u5FC5\u987B\u662F\u5B8C\u5168\u5339\u914D\u4E0A\u8FF0\u53EF\u7528\u884C\u52A8\u5217\u8868\u4E2D\u7684\u67D0\u4E2A action_id \u7684\u7EAF\u5B57\u7B26\u4E32\uFF0C\u4E0D\u8981\u5305\u542B\u53C2\u6570\uFF08\u9519\u8BEF\u793A\u4F8B\uFF1A\u274C "place(row: 7, col: 6)"\uFF09
-2. \u5982\u679C\u884C\u52A8\u9700\u8981\u53C2\u6570\uFF0Cparams \u5B57\u6BB5\u5FC5\u987B\u5305\u542B\u6240\u6709\u5FC5\u9700\u7684\u53C2\u6570
-3. \u53C2\u6570\u7684\u7C7B\u578B\u548C\u503C\u5FC5\u987B\u7B26\u5408\u884C\u52A8\u5B9A\u4E49\u7684\u7EA6\u675F
-4. \u53EA\u8FD4\u56DEJSON\u5BF9\u8C61\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E`;
-var NO_TASK_PROMPT_WITH_MEMORY = `
-# \u4EFB\u52A1\u8981\u6C42
-\u5F53\u524D\u65E0\u9700\u884C\u52A8\uFF0C\u4F46\u4F60\u53EF\u4EE5\u6839\u636E\u6700\u65B0\u4FE1\u606F\u66F4\u65B0\u4F60\u7684\u8BB0\u5FC6\u3002\u4F60\u5FC5\u987B\u4E25\u683C\u6309\u7167\u4EE5\u4E0BJSON\u683C\u5F0F\u8FD4\u56DE\uFF0C\u4E0D\u8981\u5305\u542B\u5176\u4ED6\u6587\u5B57\u8BF4\u660E\uFF1A
-
-\`\`\`json
-{
-  "reasoning": "\u4F60\u7684\u89C2\u5BDF\u548C\u601D\u8003\uFF08\u53EF\u9009\uFF09",
-  "memory_update": {
-    "mode": "append",
-    "content": "\u672C\u56DE\u5408\u7684\u65B0\u89C2\u5BDF\u3001\u63A8\u7406\u548C\u91CD\u8981\u4FE1\u606F"
-  }
-}
-\`\`\`
-
-
-**\u8BB0\u5FC6\u66F4\u65B0\u8BF4\u660E**\uFF1A
-- \`mode: "append"\` - \u8FFD\u52A0\u5230\u73B0\u6709\u8BB0\u5FC6\uFF08\u63A8\u8350\uFF09
-- \`mode: "replace"\` - \u5B8C\u5168\u66FF\u6362\u8BB0\u5FC6\uFF0C\u9002\u5408\u91CD\u65B0\u603B\u7ED3\u65F6\u4F7F\u7528
-- \u5EFA\u8BAE\u8BB0\u5F55\uFF1A\u5176\u4ED6\u73A9\u5BB6\u7684\u884C\u52A8\u3001\u53D1\u8A00\u3001\u6295\u7968\u3001\u6B7B\u4EA1\u4FE1\u606F\u3001\u8EAB\u4EFD\u7EBF\u7D22\u7B49\u5173\u952E\u4FE1\u606F
-`;
-
-// src/managers/llm.ts
-var LlmManager = class extends BaseManager {
-  async handleAdminAddBot(userId, payload) {
-    if (!this.room.requireOwner(userId)) return;
-    if (this.room.phase !== "lobby") {
-      return this.room.sendErrorToUser(userId, "Can only add bots in lobby phase");
-    }
-    const llmUserId = generateLlmUserId(payload.modelName);
-    this.room.players[llmUserId] = {
-      displayName: payload.displayName,
-      connected: false,
-      isOwner: false,
-      type: "llm",
-      llmConfig: {
-        modelName: payload.modelName,
-        systemPrompt: payload.systemPrompt || "\u4F60\u662F\u4E00\u4E2A\u806A\u660E\u7684\u6E38\u620F\u73A9\u5BB6",
-        temperature: payload.temperature ?? 0.7,
-        memory: ""
-      }
-    };
-    await this.room.persist("players");
-    this.room.broadcastSyncState();
-  }
-  async callLlmWebhook(roleId, retryCount = 0) {
-    if (!this.room.llmWebhookUrl) {
-      console.warn(`[LlmManager] Skipping LLM call: LLM_WEBHOOK_URL is not configured (roomId: ${this.room.roomId})`);
-      return;
-    }
-    const userId = this.room.roleMapping[roleId];
-    const player = this.room.players[userId];
-    if (!player || player.type !== "llm" || !player.llmConfig) {
-      console.warn(`[LlmManager] Skipping LLM call: role ${roleId} is not mapped to an LLM player`);
-      return;
-    }
-    console.log(`[LlmManager] Calling LLM webhook for role ${roleId} (attempt: ${retryCount + 1})`);
-    const interactionGroupId = crypto.randomUUID();
-    const interactionId = crypto.randomUUID();
-    const startTs = Date.now();
-    try {
-      const perspective = await this.room.fetchPerspective(roleId);
-      if (!perspective) {
-        throw new Error("Failed to fetch perspective from game worker");
-      }
-      const statePrompt = await this.room.fetchStatePrompt(perspective);
-      const hasActions = perspective.action_space_definition?.actions?.length > 0;
-      const memoryEnabled = !!player.llmConfig.memory || player.llmConfig.memory === "";
-      if (!hasActions) {
-        if (!memoryEnabled) {
-          console.log(`[LlmManager] Skipping turn for ${roleId}: No actions and memory disabled`);
-          return;
-        }
-        console.log(`[LlmManager] No actions available, but memory enabled. Calling LLM for memory-only update.`);
-      }
-      const userPrompt = this.buildUserPrompt(roleId, perspective, player.llmConfig, statePrompt || void 0);
-      const reqBody = {
-        roomId: this.room.roomId,
-        roleId,
-        gameId: this.room.gameConfig?.gameId || "",
-        perspective,
-        statePrompt: userPrompt,
-        llmConfig: player.llmConfig,
-        attempt: retryCount + 1,
-        maxAttempts: 3
-      };
-      const response = await fetch(this.room.llmWebhookUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-engine-secret": this.room.bindings.LLM_WEBHOOK_SECRET || ""
-        },
-        body: JSON.stringify(reqBody)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        await this.logLlmInteraction(
-          interactionId,
-          interactionGroupId,
-          roleId,
-          userId,
-          player,
-          userPrompt,
-          null,
-          null,
-          "failed",
-          errorText,
-          Date.now() - startTs,
-          retryCount + 1
-        );
-        throw new Error(`Webhook failed: ${response.statusText} - ${errorText}`);
+        throw new Error(`Webhook failed: ${response.statusText} - ${errorText}`);
       }
       const resultJson = await response.json();
       const rawContent = resultJson.content;
@@ -3767,11 +3476,7 @@ var LlmManager = class extends BaseManager {
     if (workerStatePrompt) {
       statePrompt = workerStatePrompt;
     } else {
-      statePrompt = perspective.message ? `# \u73AF\u5883\u4FE1\u606F
-${perspective.message}
-
-` : "";
-      statePrompt += `# \u5F53\u524D\u6E38\u620F\u72B6\u6001
+      statePrompt = `# \u5F53\u524D\u6E38\u620F\u72B6\u6001
 ${JSON.stringify(perspective.current_state, null, 2)}`;
     }
     const memoryEnabled = llmConfig.memory !== void 0 && llmConfig.memory !== null && this.room.gameConfig?.enable_llm_memory !== false;
@@ -3882,66 +3587,452 @@ ${NO_TASK_PROMPT_WITH_MEMORY}`;
           if (schema.enum && !schema.enum.includes(value)) return { valid: false, error: `\u53C2\u6570 "${key}" \u7684\u503C\u65E0\u6548\u3002\u53EF\u9009\uFF1A${schema.enum.join(", ")}` };
         }
       }
-    }
-    return { valid: true };
+    }
+    return { valid: true };
+  }
+  extractJsonFromText(raw2) {
+    const trimmed = raw2.trim();
+    const match2 = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+    if (match2?.[1]) {
+      return match2[1].trim();
+    }
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+      return trimmed.slice(firstBrace, lastBrace + 1);
+    }
+    return trimmed;
+  }
+  isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  async logLlmInteraction(id, groupId, roleId, userId, player, userPrompt, rawResponse, res, status, error, duration, attempt) {
+    try {
+      await insertMonitorLog(this.room.bindings.DB, {
+        interactionId: id,
+        interactionGroupId: groupId,
+        roomId: this.room.roomId,
+        gameId: this.room.gameConfig?.gameId,
+        roleId,
+        userId,
+        playerType: "llm",
+        modelName: player.llmConfig?.modelName,
+        systemPrompt: player.llmConfig?.systemPrompt,
+        userPrompt,
+        response: rawResponse,
+        action_id: res?.action?.action_id,
+        actionParams: res?.action?.params,
+        status,
+        attempt,
+        outerAttempt: 1,
+        maxAttempts: 3,
+        errorMessage: error,
+        responseTimeMs: duration,
+        eventTs: Date.now()
+      });
+    } catch (e) {
+      console.error("[LlmManager] Failed to record monitor log:", e);
+    }
+  }
+};
+
+// src/commands/room-commands.ts
+var WORKER_VERIFY_PATH = "/__nexus_worker_verify";
+var WORKER_VERIFY_SIGNATURE = "NEXUS_GAME_WORKER_VERIFIED_V1";
+function fail(error, status = 400) {
+  return { ok: false, error, status };
+}
+var RoomCommandService = class {
+  constructor(room) {
+    this.room = room;
+  }
+  // ─── Game configuration ────────────────────────────────
+  async setGame(input) {
+    if (!input.gameWorkerUrl) return fail("gameWorkerUrl is required");
+    if (this.room.phase !== "lobby") {
+      return fail("Can only set game in lobby phase");
+    }
+    try {
+      const baseUrl = input.gameWorkerUrl.replace(/\/$/, "");
+      const client = resolveGameWorkerClient(
+        input.gameId || "",
+        baseUrl,
+        this.room.bindings
+      );
+      const verifyRes = await client.fetch(WORKER_VERIFY_PATH);
+      if (!verifyRes.ok) {
+        return fail("Game worker verification failed", 502);
+      }
+      const signature = (await verifyRes.text()).trim();
+      if (signature !== WORKER_VERIFY_SIGNATURE) {
+        return fail("Game worker verification signature mismatch", 502);
+      }
+      const metaRes = await client.fetch("/metadata");
+      if (!metaRes.ok) {
+        const errText = await metaRes.text();
+        console.error("[RoomCommands] Metadata fetch failed:", metaRes.status, errText);
+        return fail("Failed to fetch game metadata", 502);
+      }
+      const metadata = await metaRes.json();
+      const resolved = resolveRoleIds(metadata, input.selectedPlayerCount);
+      if (!resolved) {
+        return fail("Game metadata has no roleIds", 502);
+      }
+      this.room.gameConfig = {
+        gameWorkerUrl: baseUrl,
+        gameId: input.gameId || metadata.id,
+        maxPlayers: resolved.roleIds.length,
+        roleIds: resolved.roleIds,
+        selectedPlayerCount: resolved.selectedPlayerCount,
+        enable_llm_memory: metadata.enable_llm_memory,
+        auto_save_mode: metadata.auto_save_mode
+      };
+      this.room.roleMapping = {};
+      await this.room.persist("gameConfig", "roleMapping");
+      this.room.broadcastSyncState();
+      this.room.waitUntil(this.room.syncRoomMeta());
+      return {
+        ok: true,
+        data: { gameId: this.room.gameConfig.gameId, roleIds: resolved.roleIds }
+      };
+    } catch (e) {
+      console.error("[RoomCommands] setGame failed:", e);
+      return fail(e.message || "Failed to set game", 500);
+    }
+  }
+  // ─── Lifecycle ─────────────────────────────────────────
+  async startGame() {
+    if (this.room.phase !== "lobby" && this.room.phase !== "finished") {
+      return fail("Game cannot be started in current phase");
+    }
+    const config = this.room.gameConfig;
+    if (!config) return fail("No game selected");
+    const missingRoles = config.roleIds.filter((roleId) => !this.room.roleMapping[roleId]);
+    if (missingRoles.length > 0) {
+      return fail(`Missing role assignments: ${missingRoles.join(", ")}`);
+    }
+    return this.initializeGameState("Game Worker init failed");
+  }
+  async restartGame() {
+    if (this.room.phase !== "playing" && this.room.phase !== "paused" && this.room.phase !== "finished") {
+      return fail("Nothing to restart");
+    }
+    if (!this.room.gameConfig) return fail("No game selected");
+    return this.initializeGameState("Game Worker init failed on restart");
+  }
+  async stopGame() {
+    if (this.room.phase === "lobby") {
+      return fail("Game has not started");
+    }
+    this.room.phase = "lobby";
+    this.room.gameState = null;
+    this.room.history = [];
+    this.room.stateHistory = [];
+    await this.room.persist("phase", "gameState", "history", "stateHistory");
+    this.room.broadcastSyncState();
+    this.room.waitUntil(this.room.syncRoomMeta());
+    return { ok: true, data: { phase: this.room.phase } };
+  }
+  async pauseGame() {
+    if (this.room.phase !== "playing") {
+      return fail("Can only pause a playing game");
+    }
+    this.room.phase = "paused";
+    await this.room.persist("phase");
+    this.room.broadcastSyncState();
+    this.room.waitUntil(this.room.syncRoomMeta());
+    return { ok: true, data: { phase: this.room.phase } };
+  }
+  async resumeGame() {
+    if (this.room.phase !== "paused") {
+      return fail("Game is not paused");
+    }
+    this.room.phase = "playing";
+    await this.room.persist("phase");
+    this.room.broadcastSyncState();
+    this.room.waitUntil(this.room.syncRoomMeta());
+    this.room.waitUntil(this.room.checkAndTriggerNextTurn());
+    return { ok: true, data: { phase: this.room.phase } };
+  }
+  async backtrack(index) {
+    if (this.room.phase !== "paused") {
+      return fail("Game must be paused to backtrack");
+    }
+    if (!Number.isInteger(index)) {
+      return fail("Invalid state index");
+    }
+    const targetState = this.room.stateHistory.find((entry) => entry.index === index);
+    if (!targetState) {
+      return fail("Invalid state index");
+    }
+    this.room.gameState = targetState.state;
+    this.room.stateIndex = targetState.index;
+    this.room.history = this.room.history.filter((event) => event.stateIndex <= targetState.index);
+    await this.room.persist("gameState", "history", "stateIndex");
+    this.room.broadcastSyncState();
+    return { ok: true };
+  }
+  // ─── Room metadata ─────────────────────────────────────
+  async updateRoomMeta(input) {
+    const name = input.name?.trim();
+    if (!name) return fail("Room name is required");
+    this.room.name = name;
+    this.room.isPublic = input.isPublic;
+    await this.room.persist("name", "isPublic");
+    this.room.broadcastSyncState();
+    this.room.waitUntil(this.room.syncRoomMeta());
+    return { ok: true };
+  }
+  // ─── Players & roles ───────────────────────────────────
+  /**
+   * Create a human player without a WebSocket (used by the local console and
+   * CLI to represent `dev:<roleId>`). Idempotent so repeated setups work.
+   */
+  async createPlayer(input) {
+    if (this.room.phase !== "lobby") {
+      return fail("Can only manage players in lobby phase");
+    }
+    const userId = input.userId || (input.roleId ? `dev:${input.roleId}` : "");
+    if (!userId) return fail("userId or roleId is required");
+    if (this.room.players[userId]) {
+      return { ok: true, data: { userId, created: false } };
+    }
+    this.room.players[userId] = {
+      displayName: input.displayName || input.roleId || userId,
+      connected: false,
+      isOwner: false,
+      type: "human"
+    };
+    await this.room.persist("players");
+    this.room.broadcastSyncState();
+    return { ok: true, data: { userId, created: true } };
+  }
+  async removePlayer(targetUserId) {
+    if (this.room.phase !== "lobby") {
+      return fail("Can only remove players in lobby phase");
+    }
+    if (targetUserId === this.room.ownerId) {
+      return fail("Cannot remove the room owner");
+    }
+    if (!this.room.players[targetUserId]) {
+      return fail("Player not found");
+    }
+    for (const [roleId, userId] of Object.entries(this.room.roleMapping)) {
+      if (userId === targetUserId) {
+        delete this.room.roleMapping[roleId];
+      }
+    }
+    delete this.room.players[targetUserId];
+    const targetWs = this.room.sessions.get(targetUserId);
+    if (targetWs) {
+      this.room.sendMessage(targetWs, { type: "KICKED", payload: "Removed by room owner" });
+      try {
+        targetWs.close(1e3, "Kicked");
+      } catch (_) {
+      }
+      this.room.connections.delete(targetWs);
+      this.room.sessions.delete(targetUserId);
+    }
+    await this.room.persist("players", "roleMapping");
+    this.room.broadcastSyncState();
+    return { ok: true };
+  }
+  async assignRole(input) {
+    if (this.room.phase !== "lobby") {
+      return fail("Can only assign roles in lobby phase");
+    }
+    if (!this.room.players[input.userId]) {
+      return fail(`Player ${input.userId} not found`);
+    }
+    if (this.room.gameConfig && !this.room.gameConfig.roleIds.includes(input.roleId)) {
+      return fail(`Invalid role: ${input.roleId}`);
+    }
+    for (const [roleId, userId] of Object.entries(this.room.roleMapping)) {
+      if (userId === input.userId) {
+        delete this.room.roleMapping[roleId];
+      }
+    }
+    delete this.room.roleMapping[input.roleId];
+    this.room.roleMapping[input.roleId] = input.userId;
+    await this.room.persist("roleMapping");
+    this.room.broadcastSyncState();
+    return { ok: true };
+  }
+  async addBot(input) {
+    if (this.room.phase !== "lobby") {
+      return fail("Can only add bots in lobby phase");
+    }
+    if (!input.displayName || !input.modelName) {
+      return fail("displayName and modelName are required");
+    }
+    const llmUserId = generateLlmUserId(input.modelName);
+    this.room.players[llmUserId] = {
+      displayName: input.displayName,
+      connected: false,
+      isOwner: false,
+      type: "llm",
+      llmConfig: {
+        modelName: input.modelName,
+        systemPrompt: input.systemPrompt || "\u4F60\u662F\u4E00\u4E2A\u806A\u660E\u7684\u6E38\u620F\u73A9\u5BB6",
+        temperature: input.temperature ?? 0.7,
+        memory: ""
+      }
+    };
+    await this.room.persist("players");
+    this.room.broadcastSyncState();
+    return { ok: true, data: { userId: llmUserId } };
   }
-  extractJsonFromText(raw2) {
-    const trimmed = raw2.trim();
-    const match2 = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-    if (match2?.[1]) {
-      return match2[1].trim();
+  // ─── Actions ───────────────────────────────────────────
+  async submitAction(input) {
+    if (this.room.phase !== "playing") {
+      return fail("Game is not in playing phase");
     }
-    const firstBrace = trimmed.indexOf("{");
-    const lastBrace = trimmed.lastIndexOf("}");
-    if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-      return trimmed.slice(firstBrace, lastBrace + 1);
+    if (!this.room.gameConfig || !this.room.gameState) {
+      return fail("Game not initialized");
     }
-    return trimmed;
-  }
-  isRecord(value) {
-    return typeof value === "object" && value !== null;
+    if (!input.action?.action_id) {
+      return fail("action_id is required");
+    }
+    const config = this.room.gameConfig;
+    let roleId;
+    if (input.mode === "operator") {
+      if (!input.roleId) return fail("roleId is required for operator actions");
+      if (!config.roleIds.includes(input.roleId)) {
+        return fail(`Invalid role: ${input.roleId}`);
+      }
+      roleId = input.roleId;
+    } else {
+      const assignedRole = getRoleForUser(this.room.roleMapping, input.userId);
+      if (!assignedRole) {
+        return fail("You don't have a role assigned");
+      }
+      const currentRoleId = await this.room.getCurrentRole();
+      if (currentRoleId !== assignedRole) {
+        return fail("Not your turn");
+      }
+      roleId = assignedRole;
+    }
+    const startedAt = Date.now();
+    const action = {
+      action_id: input.action.action_id,
+      params: input.action.params || {}
+    };
+    const result = await this.room.submitActionToGameWorker(roleId, action);
+    const interactionId = crypto.randomUUID();
+    const baseHumanLog = {
+      interactionId,
+      interactionGroupId: interactionId,
+      roomId: this.room.roomId,
+      gameId: config.gameId || null,
+      gameName: null,
+      roleId,
+      userId: input.mode === "operator" ? "operator" : input.userId,
+      playerType: "human",
+      modelName: null,
+      systemPrompt: null,
+      userPrompt: null,
+      response: JSON.stringify(action),
+      action_id: action.action_id,
+      actionParams: action.params,
+      attempt: 1,
+      outerAttempt: 1,
+      maxAttempts: 1,
+      previousError: null,
+      responseTimeMs: Date.now() - startedAt,
+      eventTs: Date.now()
+    };
+    if (!result.success) {
+      this.room.waitUntil(insertMonitorLog(this.room.bindings.DB, {
+        ...baseHumanLog,
+        status: "rejected",
+        errorMessage: result.error || "Action rejected"
+      }));
+      return fail(result.error || "Action rejected");
+    }
+    this.room.waitUntil(insertMonitorLog(this.room.bindings.DB, {
+      ...baseHumanLog,
+      status: "success"
+    }));
+    await applySuccessfulAction({
+      room: this.room,
+      roleId,
+      action,
+      nextState: result.nextState,
+      commands: result.commands,
+      triggerMode: "await"
+    });
+    return {
+      ok: true,
+      data: { nextState: result.nextState, commands: result.commands }
+    };
   }
-  async logLlmInteraction(id, groupId, roleId, userId, player, userPrompt, rawResponse, res, status, error, duration, attempt) {
+  // ─── Internals ─────────────────────────────────────────
+  async initializeGameState(errorPrefix) {
+    const config = this.room.gameConfig;
+    if (!config) return fail("No game selected");
     try {
-      await insertMonitorLog(this.room.bindings.DB, {
-        interactionId: id,
-        interactionGroupId: groupId,
-        roomId: this.room.roomId,
-        gameId: this.room.gameConfig?.gameId,
-        roleId,
-        userId,
-        playerType: "llm",
-        modelName: player.llmConfig?.modelName,
-        systemPrompt: player.llmConfig?.systemPrompt,
-        userPrompt,
-        response: rawResponse,
-        action_id: res?.action?.action_id,
-        actionParams: res?.action?.params,
-        status,
-        attempt,
-        outerAttempt: 1,
-        maxAttempts: 3,
-        errorMessage: error,
-        responseTimeMs: duration,
-        eventTs: Date.now()
+      for (const player of Object.values(this.room.players)) {
+        if (player.type === "llm" && player.llmConfig) {
+          player.llmConfig.memory = "";
+        }
+      }
+      const client = resolveGameWorkerClient(
+        config.gameId,
+        config.gameWorkerUrl,
+        this.room.bindings
+      );
+      const initRes = await client.fetch("/init", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ players: config.roleIds })
       });
+      if (!initRes.ok) {
+        const errText = await initRes.text();
+        return fail(`${errorPrefix}: ${errText}`, 502);
+      }
+      this.room.gameState = await initRes.json();
+      this.room.history = [];
+      this.room.runtimeId = crypto.randomUUID();
+      this.room.stateIndex = 0;
+      this.room.stateHistory = [{
+        index: 0,
+        name: "Initial State",
+        state: this.room.gameState,
+        timestamp: Date.now()
+      }];
+      this.room.phase = "playing";
+      await this.room.persistAll();
+      this.room.broadcastSyncState();
+      await this.room.checkAndTriggerNextTurn();
+      this.room.waitUntil(this.room.syncRoomMeta());
+      return { ok: true, data: { phase: this.room.phase } };
     } catch (e) {
-      console.error("[LlmManager] Failed to record monitor log:", e);
+      console.error("[RoomCommands] Failed to initialize game:", e);
+      return fail(errorPrefix, 500);
     }
   }
 };
-
-// src/game-do.ts
-function generateLlmUserId(modelName) {
-  const uuid = crypto.randomUUID().slice(0, 8);
-  return `llm:${modelName}:${uuid}`;
-}
-function getRoleForUser(roleMapping, userId) {
-  for (const [roleId, uid] of Object.entries(roleMapping)) {
-    if (uid === userId) return roleId;
+function resolveRoleIds(metadata, selectedPlayerCount) {
+  if (Array.isArray(metadata.roleIds)) {
+    return {
+      roleIds: metadata.roleIds,
+      selectedPlayerCount: metadata.roleIds.length
+    };
+  }
+  if (metadata.roleIds && typeof metadata.roleIds === "object") {
+    const counts = Object.keys(metadata.roleIds).map(Number).sort((a, b) => a - b);
+    const effectiveCount = selectedPlayerCount && metadata.roleIds[selectedPlayerCount] ? selectedPlayerCount : counts[0];
+    if (effectiveCount === void 0) return { roleIds: [] };
+    return {
+      roleIds: metadata.roleIds[effectiveCount] || [],
+      selectedPlayerCount: effectiveCount
+    };
   }
   return null;
 }
+
+// src/game-do.ts
+var JOIN_REQUEST_TTL_MS = 10 * 60 * 1e3;
 var GameDO = class extends DurableObject {
   // userId → ws
   constructor(state, env) {
@@ -3964,6 +4055,8 @@ var GameDO = class extends DurableObject {
     this.stateIndex = 0;
     this.llmWebhookUrl = null;
     this.roomMetaHookUrl = null;
+    this.joinRequests = {};
+    // pending lobby join requests, key = userId
     // ─── In-memory connection tracking ──────────────────────
     this.connections = /* @__PURE__ */ new Map();
     // ws → userId
@@ -3971,7 +4064,7 @@ var GameDO = class extends DurableObject {
     this.bindings = env;
     this.presence = new PresenceManager(this);
     this.roomMgr = new RoomManager(this);
-    this.executor = new GameExecutor(this);
+    this.commands = new RoomCommandService(this);
     this.llm = new LlmManager(this);
     this.ctx.blockConcurrencyWhile(async () => {
       await this.loadState();
@@ -3999,6 +4092,7 @@ var GameDO = class extends DurableObject {
     this.stateIndex = await s.get("stateIndex") || 0;
     this.llmWebhookUrl = this.bindings.LLM_WEBHOOK_URL || await s.get("llmWebhookUrl") || null;
     this.roomMetaHookUrl = await s.get("roomMetaHookUrl") || null;
+    this.joinRequests = await s.get("joinRequests") || {};
   }
   async persistAll() {
     await this.ctx.storage.put({
@@ -4017,7 +4111,8 @@ var GameDO = class extends DurableObject {
       runtimeId: this.runtimeId,
       stateIndex: this.stateIndex,
       llmWebhookUrl: this.llmWebhookUrl,
-      roomMetaHookUrl: this.roomMetaHookUrl
+      roomMetaHookUrl: this.roomMetaHookUrl,
+      joinRequests: this.joinRequests
     });
   }
   async persist(...keys) {
@@ -4060,6 +4155,7 @@ var GameDO = class extends DurableObject {
       this.llmWebhookUrl = this.bindings.LLM_WEBHOOK_URL || null;
       this.gameConfig = null;
       this.roomMetaHookUrl = body.roomMetaHookUrl || null;
+      this.joinRequests = {};
       await this.persistAll();
       this.ctx.waitUntil(this.syncRoomMeta());
       return c.json({ success: true });
@@ -4122,192 +4218,98 @@ var GameDO = class extends DurableObject {
     });
     this.app.post("/role-action", async (c) => {
       const body = await c.req.json();
-      if (!body.roleId || !body.action) return c.json({ error: "roleId and action required" }, 400);
-      const res = await this.submitActionToGameWorker(body.roleId, body.action);
-      if (res.success && res.nextState) {
-        this.history.push({
-          turn: (this.history[this.history.length - 1]?.turn || 0) + 1,
-          roleId: body.roleId,
-          action: body.action,
-          timestamp: Date.now(),
-          stateIndex: this.stateIndex
+      if (!body.roleId || !body.action) {
+        return this.commandResponse(c, {
+          ok: false,
+          error: "roleId and action required"
         });
-        this.gameState = res.nextState;
-        this.stateIndex++;
-        await this.persist("gameState", "history", "stateIndex");
-        this.presence.broadcastSyncState();
       }
-      return c.json(res);
+      const result = await this.commands.submitAction({
+        userId: "operator",
+        roleId: body.roleId,
+        action: body.action,
+        mode: "operator"
+      });
+      return this.commandResponse(c, result);
     });
     this.app.post("/set-game", async (c) => {
       const body = await c.req.json();
-      if (!body.gameWorkerUrl) return c.json({ error: "gameWorkerUrl is required" }, 400);
-      if (this.phase !== "lobby" && this.phase !== "finished") {
-        return c.json({ error: "Can only set game in lobby/finished phase" }, 400);
-      }
-      try {
-        const baseUrl = body.gameWorkerUrl.replace(/\/$/, "");
-        const client = resolveGameWorkerClient(body.gameId || "", baseUrl, this.bindings);
-        const metaRes = await client.fetch("/metadata");
-        if (!metaRes.ok) {
-          const errText = await metaRes.text();
-          console.error("[GameDO] Metadata fetch failed. Status:", metaRes.status, "Body:", errText);
-          return c.json({ error: "Failed to fetch game metadata" }, 502);
-        }
-        const metadata = await metaRes.json();
-        let roleIds;
-        let resolvedPlayerCount;
-        if (Array.isArray(metadata.roleIds)) {
-          roleIds = metadata.roleIds;
-          resolvedPlayerCount = roleIds.length;
-        } else if (metadata.roleIds) {
-          const counts = Object.keys(metadata.roleIds).map(Number).sort((a, b) => a - b);
-          const selectedCount = body.selectedPlayerCount;
-          const effectiveCount = selectedCount && metadata.roleIds[selectedCount] ? selectedCount : counts[0];
-          roleIds = metadata.roleIds[effectiveCount] || [];
-          resolvedPlayerCount = effectiveCount;
-        } else {
-          roleIds = [];
-        }
-        this.gameConfig = {
-          gameWorkerUrl: baseUrl,
-          gameId: body.gameId || metadata.id,
-          maxPlayers: roleIds.length,
-          roleIds,
-          selectedPlayerCount: resolvedPlayerCount,
-          enable_llm_memory: metadata.enable_llm_memory,
-          auto_save_mode: metadata.auto_save_mode
-        };
-        this.roleMapping = {};
-        await this.persist("gameConfig", "roleMapping");
-        this.presence.broadcastSyncState();
-        this.ctx.waitUntil(this.syncRoomMeta());
-        return c.json({ success: true, gameId: this.gameConfig.gameId, roleIds });
-      } catch (e) {
-        console.error("[GameDO] /set-game failed:", e);
-        return c.json({ error: e.message || "Failed to set game" }, 500);
-      }
+      const result = await this.commands.setGame({
+        gameWorkerUrl: body.gameWorkerUrl || "",
+        gameId: body.gameId,
+        selectedPlayerCount: body.selectedPlayerCount
+      });
+      return this.commandResponse(c, result);
     });
     this.app.post("/start-game", async (c) => {
-      if (this.phase !== "lobby" && this.phase !== "finished") {
-        return c.json({ error: "Game cannot be started in current phase" }, 400);
-      }
-      if (!this.gameConfig) {
-        return c.json({ error: "No game selected" }, 400);
-      }
-      for (const roleId of this.gameConfig.roleIds) {
-        if (!this.roleMapping[roleId]) {
-          const devUserId = `dev:${roleId}`;
-          this.players[devUserId] = {
-            displayName: roleId,
-            connected: false,
-            isOwner: false,
-            type: "human"
-          };
-          this.roleMapping[roleId] = devUserId;
-        }
-      }
-      try {
-        for (const player of Object.values(this.players)) {
-          if (player.type === "llm" && player.llmConfig) {
-            player.llmConfig.memory = "";
-          }
-        }
-        const client = resolveGameWorkerClient(
-          this.gameConfig.gameId,
-          this.gameConfig.gameWorkerUrl,
-          this.bindings
-        );
-        const initRes = await client.fetch("/init", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ players: this.gameConfig.roleIds })
-        });
-        if (!initRes.ok) {
-          const errText = await initRes.text();
-          return c.json({ error: `Game Worker init failed: ${errText}` }, 502);
-        }
-        this.gameState = await initRes.json();
-        this.history = [];
-        this.runtimeId = crypto.randomUUID();
-        this.stateIndex = 0;
-        this.stateHistory = [{
-          index: 0,
-          name: "Initial State",
-          state: this.gameState,
-          timestamp: Date.now()
-        }];
-        this.phase = "playing";
-        await this.persistAll();
-        this.presence.broadcastSyncState();
-        await this.checkAndTriggerNextTurn();
-        this.ctx.waitUntil(this.syncRoomMeta());
-        return c.json({ success: true, phase: this.phase });
-      } catch (e) {
-        console.error("[GameDO] /start-game failed:", e);
-        return c.json({ error: e.message || "Failed to start game" }, 500);
-      }
+      return this.commandResponse(c, await this.commands.startGame());
     });
     this.app.post("/stop-game", async (c) => {
-      if (this.phase === "lobby") {
-        return c.json({ error: "Game has not started" }, 400);
-      }
-      this.phase = "lobby";
-      this.gameState = null;
-      this.history = [];
-      this.stateHistory = [];
-      await this.persist("phase", "gameState", "history", "stateHistory");
-      this.presence.broadcastSyncState();
-      this.ctx.waitUntil(this.syncRoomMeta());
-      return c.json({ success: true, phase: this.phase });
+      return this.commandResponse(c, await this.commands.stopGame());
     });
     this.app.post("/restart-game", async (c) => {
-      if (this.phase !== "playing" && this.phase !== "paused" && this.phase !== "finished") {
-        return c.json({ error: "Nothing to restart" }, 400);
-      }
-      if (!this.gameConfig) {
-        return c.json({ error: "No game selected" }, 400);
-      }
-      try {
-        for (const player of Object.values(this.players)) {
-          if (player.type === "llm" && player.llmConfig) {
-            player.llmConfig.memory = "";
-          }
-        }
-        const client = resolveGameWorkerClient(
-          this.gameConfig.gameId,
-          this.gameConfig.gameWorkerUrl,
-          this.bindings
-        );
-        const initRes = await client.fetch("/init", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ players: Object.keys(this.roleMapping) })
+      return this.commandResponse(c, await this.commands.restartGame());
+    });
+    this.app.post("/pause-game", async (c) => {
+      return this.commandResponse(c, await this.commands.pauseGame());
+    });
+    this.app.post("/resume-game", async (c) => {
+      return this.commandResponse(c, await this.commands.resumeGame());
+    });
+    this.app.post("/backtrack", async (c) => {
+      const body = await c.req.json();
+      return this.commandResponse(
+        c,
+        await this.commands.backtrack(body.index)
+      );
+    });
+    this.app.post("/players", async (c) => {
+      const body = await c.req.json();
+      return this.commandResponse(c, await this.commands.createPlayer(body));
+    });
+    this.app.delete("/players/:userId", async (c) => {
+      return this.commandResponse(
+        c,
+        await this.commands.removePlayer(c.req.param("userId"))
+      );
+    });
+    this.app.post("/assign-role", async (c) => {
+      const body = await c.req.json();
+      if (!body.roleId || !body.userId) {
+        return this.commandResponse(c, {
+          ok: false,
+          error: "roleId and userId are required"
         });
-        if (!initRes.ok) {
-          return c.json({ error: "Game Worker init failed on restart" }, 502);
-        }
-        this.gameState = await initRes.json();
-        this.history = [];
-        this.runtimeId = crypto.randomUUID();
-        this.stateIndex = 0;
-        this.stateHistory = [{
-          index: 0,
-          name: "Initial State",
-          state: this.gameState,
-          timestamp: Date.now()
-        }];
-        this.phase = "playing";
-        await this.persistAll();
-        this.presence.broadcastSyncState();
-        await this.checkAndTriggerNextTurn();
-        this.ctx.waitUntil(this.syncRoomMeta());
-        return c.json({ success: true, phase: this.phase });
-      } catch (e) {
-        console.error("[GameDO] /restart-game failed:", e);
-        return c.json({ error: e.message || "Failed to restart game" }, 500);
       }
+      return this.commandResponse(c, await this.commands.assignRole({
+        roleId: body.roleId,
+        userId: body.userId
+      }));
     });
+    this.app.post("/add-bot", async (c) => {
+      const body = await c.req.json();
+      return this.commandResponse(c, await this.commands.addBot({
+        displayName: body.displayName || "",
+        modelName: body.modelName || "",
+        systemPrompt: body.systemPrompt,
+        temperature: body.temperature
+      }));
+    });
+  }
+  /**
+   * Turn a command result into an HTTP response. The same result object is
+   * also what the WebSocket transport inspects (only errors are sent).
+   */
+  commandResponse(c, result) {
+    if (result.ok) {
+      return c.json(result.data === void 0 ? { ok: true } : { ok: true, data: result.data });
+    }
+    return c.json({ ok: false, error: result.error }, result.status ?? 400);
+  }
+  reportCommandFailure(userId, result) {
+    if (!result.ok) {
+      this.sendErrorToUser(userId, result.error);
+    }
   }
   async fetch(request) {
     return this.app.fetch(request);
@@ -4325,79 +4327,71 @@ var GameDO = class extends DurableObject {
         await this.roomMgr.handleLeave(userId);
         break;
       case "LOBBY_JOIN_REQUEST":
-        const ownerWs = this.sessions.get(this.ownerId);
-        if (ownerWs) {
-          this.sendMessage(ownerWs, {
-            type: "JOIN_REQUEST_INTERNAL",
-            payload: { userId, displayName: msg.payload.displayName }
-          });
-        }
+        this.joinRequests[userId] = {
+          displayName: msg.payload.displayName,
+          requestedAt: Date.now()
+        };
+        await this.persist("joinRequests");
+        this.notifyOwnerOfJoinRequest(userId);
         break;
       case "ADMIN_SET_GAME":
-        await this.roomMgr.handleAdminSetGame(userId, msg.payload);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.setGame(msg.payload));
         break;
       case "ADMIN_ADD_BOT":
-        await this.llm.handleAdminAddBot(userId, msg.payload);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.addBot(msg.payload));
         break;
       case "ADMIN_REMOVE_PLAYER":
-        await this.roomMgr.handleAdminRemovePlayer(userId, msg.payload.userId);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.removePlayer(msg.payload.userId));
         break;
       case "ADMIN_APPROVE_JOIN":
+        if (!this.requireOwner(userId)) return;
         await this.roomMgr.handleAdminApproveJoin(userId, msg.payload);
         break;
+      case "ADMIN_IGNORE_JOIN":
+        if (!this.requireOwner(userId)) return;
+        await this.roomMgr.handleAdminIgnoreJoin(userId, msg.payload);
+        break;
       case "ADMIN_ASSIGN_ROLE":
-        await this.roomMgr.handleAdminAssignRole(userId, msg.payload);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.assignRole(msg.payload));
         break;
       case "ADMIN_START_GAME":
-        await this.executor.handleAdminStartGame(userId);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.startGame());
         break;
       case "ADMIN_STOP_GAME":
-        await this.executor.handleAdminStopGame(userId);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.stopGame());
         break;
       case "ADMIN_RESTART_GAME":
-        await this.executor.handleAdminRestartGame(userId);
+        if (!this.requireOwner(userId)) return;
+        this.reportCommandFailure(userId, await this.commands.restartGame());
         break;
       case "ADMIN_PAUSE_GAME":
         if (!this.requireOwner(userId)) return;
-        this.phase = "paused";
-        await this.persist("phase");
-        this.presence.broadcastSyncState();
-        this.ctx.waitUntil(this.syncRoomMeta());
+        this.reportCommandFailure(userId, await this.commands.pauseGame());
         break;
       case "ADMIN_RESUME_GAME":
         if (!this.requireOwner(userId)) return;
-        this.phase = "playing";
-        await this.persist("phase");
-        this.presence.broadcastSyncState();
-        this.ctx.waitUntil(this.syncRoomMeta());
-        this.ctx.waitUntil(this.checkAndTriggerNextTurn());
+        this.reportCommandFailure(userId, await this.commands.resumeGame());
         break;
       case "ADMIN_BACKTRACK_STATE":
         if (!this.requireOwner(userId)) return;
-        if (this.phase !== "paused") {
-          return this.sendErrorToUser(userId, "Game must be paused to backtrack");
-        }
-        const historyIdx = msg.payload.index;
-        const targetState = this.stateHistory.find((h) => h.index === historyIdx);
-        if (!targetState) {
-          return this.sendErrorToUser(userId, "Invalid state index");
-        }
-        this.gameState = targetState.state;
-        this.stateIndex = targetState.index;
-        this.history = this.history.filter((h) => h.stateIndex <= targetState.index);
-        await this.persist("gameState", "history", "stateIndex");
-        this.presence.broadcastSyncState();
+        this.reportCommandFailure(userId, await this.commands.backtrack(msg.payload.index));
         break;
       case "ADMIN_UPDATE_ROOM_META":
         if (!this.requireOwner(userId)) return;
-        this.name = msg.payload.name;
-        this.isPublic = msg.payload.isPublic;
-        await this.persist("name", "isPublic");
-        this.presence.broadcastSyncState();
-        this.ctx.waitUntil(this.syncRoomMeta());
+        this.reportCommandFailure(userId, await this.commands.updateRoomMeta(msg.payload));
         break;
       case "ACT":
-        await this.executor.handleAction(userId, msg.payload);
+        this.reportCommandFailure(userId, await this.commands.submitAction({
+          userId,
+          action: msg.payload,
+          mode: "player"
+        }));
         break;
       default:
         this.presence.sendErrorToUser(userId, `Unknown message type: ${msg.type}`);
@@ -4455,6 +4449,43 @@ var GameDO = class extends DurableObject {
   sendErrorToUser(userId, msg) {
     this.presence.sendErrorToUser(userId, msg);
   }
+  // ─── Lobby join requests ────────────────────────────────
+  /** Push one pending join request to the owner's live session, if any. */
+  notifyOwnerOfJoinRequest(userId) {
+    const request = this.joinRequests[userId];
+    const ownerWs = this.sessions.get(this.ownerId);
+    if (!request || !ownerWs) return;
+    this.sendMessage(ownerWs, {
+      type: "JOIN_REQUEST_INTERNAL",
+      payload: { userId, displayName: request.displayName }
+    });
+  }
+  /**
+   * Replay every unexpired pending join request to a newly connected owner.
+   * Called when the owner (re)connects so requests sent during a disconnect
+   * are not lost.
+   */
+  sendPendingJoinRequests(ws) {
+    const cutoff = Date.now() - JOIN_REQUEST_TTL_MS;
+    let changed = false;
+    for (const [userId, request] of Object.entries(this.joinRequests)) {
+      if (request.requestedAt < cutoff || this.players[userId]) {
+        delete this.joinRequests[userId];
+        changed = true;
+        continue;
+      }
+      this.sendMessage(ws, {
+        type: "JOIN_REQUEST_INTERNAL",
+        payload: { userId, displayName: request.displayName }
+      });
+    }
+    if (changed) this.ctx.waitUntil(this.persist("joinRequests"));
+  }
+  async clearJoinRequest(userId) {
+    if (!this.joinRequests[userId]) return;
+    delete this.joinRequests[userId];
+    await this.persist("joinRequests");
+  }
   requireOwner(userId) {
     if (userId !== this.ownerId) {
       this.sendErrorToUser(userId, "Only the room owner can perform this action");
@@ -4577,7 +4608,8 @@ var GameDO = class extends DurableObject {
       return {
         success: data.success,
         nextState: data.nextState,
-        error: data.error
+        error: data.error,
+        commands: data.commands
       };
     } catch (e) {
       console.error("[GameDO] Worker action failed:", e);
@@ -4639,6 +4671,8 @@ var MonitorDO = class extends DurableObject2 {
     this.subscribers = /* @__PURE__ */ new Map();
     this.lastProcessedTs = Date.now();
     this.isPolling = false;
+    // Workers' setInterval returns a number; keep the type independent of the
+    // ambient lib (vitest pulls in Node's `Timeout`, which the test program sees).
     this.heartbeatTimer = null;
     this.setupRoutes();
     this.startHeartbeat();
@@ -4903,6 +4937,19 @@ function verifyAdmin(c) {
   const authHeader = c.req.header("Authorization");
   return authHeader === `Bearer ${c.env.ADMIN_SECRET}`;
 }
+function getRoomStub(c, roomId) {
+  const id = roomId.length === 64 ? c.env.GAME_DO.idFromString(roomId) : c.env.GAME_DO.idFromName(roomId);
+  return c.env.GAME_DO.get(id);
+}
+async function proxyRoom(c, roomId, doPath, init) {
+  let stub;
+  try {
+    stub = getRoomStub(c, roomId);
+  } catch {
+    return c.json({ ok: false, error: "Invalid ID format" }, 400);
+  }
+  return stub.fetch(`http://do${doPath}`, init);
+}
 app.get("/api/monitor/logs", async (c) => {
   if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
   if (!c.env.DB) return c.json({ error: "Monitor logging is disabled" }, 404);
@@ -4950,75 +4997,48 @@ app.get("/api/monitor/logs/:interactionId", async (c) => {
   if (!data) return c.json({ error: "Not found" }, 404);
   return c.json({ data });
 });
-app.get("/api/monitor/room/:id", async (c) => {
+app.get("/api/engine/rooms/:id", async (c) => {
   if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
-  const idParam = c.req.param("id");
-  let id;
-  try {
-    if (idParam.length === 64) {
-      id = c.env.GAME_DO.idFromString(idParam);
-    } else {
-      id = c.env.GAME_DO.idFromName(idParam);
-    }
-  } catch (e) {
-    return c.json({ error: "Invalid ID format" }, 400);
-  }
-  const stub = c.env.GAME_DO.get(id);
-  const res = await stub.fetch("http://do/state");
-  if (!res.ok) {
-    return c.json({ error: "Failed to fetch room state" }, res.status);
-  }
-  const state = await res.json();
-  return c.json({ data: state });
+  return proxyRoom(c, c.req.param("id"), "/state");
 });
-app.get("/api/monitor/room/:id/perspective", async (c) => {
+app.get("/api/engine/rooms/:id/debug", async (c) => {
   if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
-  const roomId = c.req.param("id");
-  const roleId = c.req.query("roleId");
-  if (!roleId) return c.json({ error: "roleId is required" }, 400);
-  const id = c.env.GAME_DO.idFromName(roomId);
-  const stub = c.env.GAME_DO.get(id);
-  const res = await stub.fetch(`http://do/perspective?roleId=${encodeURIComponent(roleId)}`);
-  if (!res.ok) {
-    return c.json({ error: "Failed to fetch perspective" }, res.status);
-  }
-  return c.json(await res.json());
+  return proxyRoom(c, c.req.param("id"), "/debug");
 });
-app.post("/api/monitor/room/:id/action", async (c) => {
+app.get("/api/engine/rooms/:id/perspective", async (c) => {
   if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
-  const roomId = c.req.param("id");
-  const body = await c.req.json();
-  const id = c.env.GAME_DO.idFromName(roomId);
-  const stub = c.env.GAME_DO.get(id);
-  const res = await stub.fetch("http://do/role-action", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    return c.json({ error: "Failed to submit action" }, res.status);
-  }
-  return c.json(await res.json());
+  const query = new URL(c.req.url).search;
+  return proxyRoom(c, c.req.param("id"), `/perspective${query}`);
 });
-var gameLifecycleEndpoints = ["set-game", "start-game", "stop-game", "restart-game"];
-for (const endpoint of gameLifecycleEndpoints) {
-  app.post(`/api/monitor/room/:id/${endpoint}`, async (c) => {
+var roomPostEndpoints = [
+  "role-action",
+  "set-game",
+  "start-game",
+  "stop-game",
+  "restart-game",
+  "pause-game",
+  "resume-game",
+  "backtrack",
+  "players",
+  "assign-role",
+  "add-bot"
+];
+for (const endpoint of roomPostEndpoints) {
+  app.post(`/api/engine/rooms/:id/${endpoint}`, async (c) => {
     if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
-    const roomId = c.req.param("id");
-    const id = c.env.GAME_DO.idFromName(roomId);
-    const stub = c.env.GAME_DO.get(id);
-    const body = endpoint === "set-game" ? await c.req.json() : {};
-    const res = await stub.fetch(`http://do/${endpoint}`, {
+    const body = await c.req.text();
+    return proxyRoom(c, c.req.param("id"), `/${endpoint}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      body: body || "{}"
     });
-    if (!res.ok) {
-      return c.json(await res.json(), res.status);
-    }
-    return c.json(await res.json());
   });
 }
+app.delete("/api/engine/rooms/:id/players/:userId", async (c) => {
+  if (!verifyAdmin(c)) return c.json({ error: "Unauthorized" }, 401);
+  const userId = encodeURIComponent(c.req.param("userId"));
+  return proxyRoom(c, c.req.param("id"), `/players/${userId}`, { method: "DELETE" });
+});
 app.get("/debug/:roomId", async (c) => {
   const roomId = c.req.param("roomId");
   const id = c.env.GAME_DO.idFromName(roomId);