lobster-roundtable 3.0.0

package/main.js

@@ -0,0 +1,2179 @@
+/**
+ * 龙虾圆桌 OpenClaw 插件 v2
+ *
+ * 架构：走 Gateway 内部管线（类似 IRC/Discord/Telegram 通道）
+ * 用户配的什么 AI 就用什么 AI，零配置即用
+ *
+ * 兼容性：
+ * - CJS 模块（require/module.exports），兼容所有 Node.js 版本
+ * - 不依赖 registerService（旧版可能不支持）
+ * - ws 模块：优先用 OpenClaw 内置的，找不到再从 plugin 目录找
+ */
+
+const os = require("os");
+const pathModule = require("path");
+const httpModule = require("http");
+const httpsModule = require("https");
+const fsModule = require("fs");
+const cryptoModule = require("crypto");
+const { execFileSync } = require("child_process");
+
+let WebSocket;
+try {
+  WebSocket = require("ws");
+} catch {
+  try {
+    const ocDir = process.env.OPENCLAW_DIR || os.homedir() + "/.openclaw";
+    WebSocket = require(pathModule.join(ocDir, "node_modules", "ws"));
+  } catch {
+    // 最后的后备
+  }
+}
+
+const CHANNEL_ID = "lobster-roundtable";
+const PLUGIN_VERSION = "3.0.0";
+const ENABLE_OPENCLAW_CONFIG_SYNC = String(process.env.LOBSTER_RT_SYNC_OPENCLAW || "").trim() === "1";
+const OPENCLAW_CONFIG_ALLOWED_KEYS = new Set(["url", "token", "ownerToken", "name", "persona", "maxTokens"]);
+
+function normalizeIdentityId(raw, max = 96) {
+  const s = String(raw || "").trim().slice(0, max);
+  if (!s) return "";
+  return s.replace(/[^a-zA-Z0-9:_-]/g, "");
+}
+
+function buildOpenClawHome() {
+  return process.env.OPENCLAW_DIR || pathModule.join(os.homedir(), ".openclaw");
+}
+
+function sanitizeSkillDirName(name) {
+  const raw = String(name || "").trim();
+  if (!raw) return "";
+  const cleaned = raw
+    .replace(/[\u0000-\u001f<>:"/\\|?*]/g, "_")
+    .replace(/\s+/g, " ")
+    .replace(/^\.+/, "")
+    .trim()
+    .slice(0, 120);
+  if (!cleaned || cleaned === "." || cleaned === "..") return "";
+  return cleaned;
+}
+
+function listInstalledSkillNames(skillsRoot, limit = 120) {
+  try {
+    if (!skillsRoot || !fsModule.existsSync(skillsRoot)) return [];
+    const dirents = fsModule.readdirSync(skillsRoot, { withFileTypes: true });
+    const names = [];
+    for (const entry of dirents) {
+      if (!entry || !entry.isDirectory()) continue;
+      const name = String(entry.name || "").trim();
+      if (!name) continue;
+      const skillFile = pathModule.join(skillsRoot, name, "SKILL.md");
+      if (!fsModule.existsSync(skillFile)) continue;
+      names.push(name);
+      if (names.length >= limit) break;
+    }
+    return names.sort((a, b) => a.localeCompare(b, "zh-Hans-CN"));
+  } catch {
+    return [];
+  }
+}
+
+function ensureDirForFile(filePath) {
+  fsModule.mkdirSync(pathModule.dirname(filePath), { recursive: true });
+}
+
+function readTextSafe(filePath) {
+  try {
+    return fsModule.existsSync(filePath) ? String(fsModule.readFileSync(filePath, "utf-8") || "").trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+function decodeFileBuffer(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length === 0) return "";
+  // UTF-8 BOM
+  if (buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf) {
+    return buf.slice(3).toString("utf8");
+  }
+  // UTF-16 LE BOM
+  if (buf.length >= 2 && buf[0] === 0xff && buf[1] === 0xfe) {
+    return buf.slice(2).toString("utf16le");
+  }
+  // UTF-16 BE BOM
+  if (buf.length >= 2 && buf[0] === 0xfe && buf[1] === 0xff) {
+    const swapped = Buffer.allocUnsafe(buf.length - 2);
+    for (let i = 2; i + 1 < buf.length; i += 2) {
+      swapped[i - 2] = buf[i + 1];
+      swapped[i - 1] = buf[i];
+    }
+    return swapped.toString("utf16le");
+  }
+  // Heuristic: UTF-16 LE without BOM (lots of NUL bytes in odd positions)
+  const sample = buf.slice(0, Math.min(buf.length, 128));
+  let nulOdd = 0;
+  for (let i = 1; i < sample.length; i += 2) {
+    if (sample[i] === 0) nulOdd++;
+  }
+  if (sample.length > 8 && nulOdd >= sample.length / 6) {
+    return buf.toString("utf16le");
+  }
+  return buf.toString("utf8");
+}
+
+function parseJsonFileFlexible(filePath) {
+  const raw = fsModule.readFileSync(filePath);
+  let text = decodeFileBuffer(raw);
+  if (!text) return {};
+  text = String(text).replace(/^\uFEFF/, "").trim();
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Recover from contaminated files like: log-prefix + {...json...} + log-suffix
+    const first = text.indexOf("{");
+    const last = text.lastIndexOf("}");
+    if (first >= 0 && last > first) {
+      const candidate = text.slice(first, last + 1).trim();
+      return JSON.parse(candidate);
+    }
+    throw new Error("invalid_json");
+  }
+}
+
+function writeJsonUtf8NoBomAtomic(filePath, value) {
+  const tmp = `${filePath}.tmp`;
+  const out = JSON.stringify(value, null, 2);
+  fsModule.writeFileSync(tmp, out, { encoding: "utf8" });
+  fsModule.renameSync(tmp, filePath);
+}
+
+function writeTextSafe(filePath, value) {
+  try {
+    ensureDirForFile(filePath);
+    fsModule.writeFileSync(filePath, String(value || ""), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function buildMachineFingerprint() {
+  const raw = `${os.hostname()}:${os.userInfo().username}:${os.platform()}:${os.arch()}`;
+  return cryptoModule.createHash("sha256").update(raw).digest("hex").slice(0, 32);
+}
+
+function buildDefaultBotName() {
+  const base = os.userInfo().username || os.hostname() || "Lobster";
+  return String(base).slice(0, 15) + "🦞";
+}
+
+function scopeKeyFromWsUrl(wsUrl) {
+  return cryptoModule.createHash("sha1").update(String(wsUrl || "")).digest("hex").slice(0, 10);
+}
+
+function sanitizeRoundtableConfig(rawConfig) {
+  const input = (rawConfig && typeof rawConfig === "object" && !Array.isArray(rawConfig)) ? rawConfig : {};
+  const next = {};
+  for (const key of OPENCLAW_CONFIG_ALLOWED_KEYS) {
+    if (!(key in input)) continue;
+    const value = input[key];
+    if (value === undefined || value === null || value === "") continue;
+    next[key] = value;
+  }
+  return next;
+}
+
+function requestAutoRegister(httpBase, payload) {
+  const body = JSON.stringify(payload || {});
+  try {
+    const raw = execFileSync("curl", [
+      "-sS",
+      "--connect-timeout", "5",
+      "--max-time", "10",
+      "-X", "POST",
+      "-H", "Content-Type: application/json",
+      "--data", body,
+      `${httpBase}/api/auto-register`,
+    ], {
+      encoding: "utf-8",
+      timeout: 15000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return JSON.parse(String(raw || "{}"));
+  } catch (curlErr) {
+    // curl 不可用时（如 Windows 某些环境），降级到 Node.js HTTP
+    if (curlErr?.status === null || curlErr?.message?.includes('ENOENT')) {
+      const url = new URL(`${httpBase}/api/auto-register`);
+      const lib = url.protocol === 'https:' ? httpsModule : httpModule;
+      const bodyBuf = Buffer.from(body);
+      const result = { token: null };
+      // 同步降级不可行，抛出让调用者走异步路径
+      throw new Error(`curl unavailable: ${curlErr.message}`);
+    }
+    throw curlErr;
+  }
+}
+
+function requestTokenInfo(httpBase, token) {
+  const safeToken = String(token || "").trim();
+  if (!safeToken) return null;
+  const raw = execFileSync("curl", [
+    "-sS",
+    "--connect-timeout", "4",
+    "--max-time", "8",
+    `${httpBase}/api/tokens/${encodeURIComponent(safeToken)}`,
+  ], {
+    encoding: "utf-8",
+    timeout: 12000,
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const parsed = JSON.parse(String(raw || "{}"));
+  if (parsed && typeof parsed === "object") return parsed;
+  return null;
+}
+
+function upsertOpenClawPluginConfig(ocHome, wsUrl, updates, logger) {
+  const ocConfigPath = pathModule.join(ocHome, "openclaw.json");
+  if (!fsModule.existsSync(ocConfigPath)) return;
+  try {
+    let ocConfig;
+    try {
+      ocConfig = parseJsonFileFlexible(ocConfigPath);
+    } catch (readErr) {
+      const bakPath = `${ocConfigPath}.bak`;
+      if (fsModule.existsSync(bakPath)) {
+        ocConfig = parseJsonFileFlexible(bakPath);
+        logger?.warn?.("[roundtable] 检测到 openclaw.json 异常，已回退到 .bak 内容并继续");
+      } else {
+        throw readErr;
+      }
+    }
+    if (!ocConfig || typeof ocConfig !== "object" || Array.isArray(ocConfig)) ocConfig = {};
+    if (!ocConfig.plugins) ocConfig.plugins = {};
+    if (!ocConfig.plugins.entries) ocConfig.plugins.entries = {};
+    if (!Array.isArray(ocConfig.plugins.allow)) {
+      ocConfig.plugins.allow = Array.isArray(ocConfig.plugins?.allow)
+        ? ocConfig.plugins.allow
+        : [];
+    }
+    if (!ocConfig.plugins.allow.includes("lobster-roundtable")) {
+      ocConfig.plugins.allow.push("lobster-roundtable");
+    }
+    if (!ocConfig.plugins.entries["lobster-roundtable"]) {
+      ocConfig.plugins.entries["lobster-roundtable"] = { enabled: true, config: {} };
+    }
+    const entry = ocConfig.plugins.entries["lobster-roundtable"];
+    const legacyInstanceIdDetected = !!(
+      entry?.config &&
+      typeof entry.config === "object" &&
+      !Array.isArray(entry.config) &&
+      Object.prototype.hasOwnProperty.call(entry.config, "instanceId")
+    );
+    entry.config = sanitizeRoundtableConfig(entry.config);
+    if (wsUrl && !entry.config.url) entry.config.url = wsUrl;
+    for (const [k, v] of Object.entries(updates || {})) {
+      if (!OPENCLAW_CONFIG_ALLOWED_KEYS.has(k)) continue;
+      if (v === undefined || v === null || v === "") continue;
+      entry.config[k] = v;
+    }
+    const bakPath = `${ocConfigPath}.bak`;
+    try {
+      fsModule.copyFileSync(ocConfigPath, bakPath);
+    } catch { }
+    writeJsonUtf8NoBomAtomic(ocConfigPath, ocConfig);
+    // Read-back validation to avoid silently writing broken content.
+    parseJsonFileFlexible(ocConfigPath);
+    if (legacyInstanceIdDetected) {
+      logger?.info?.("[roundtable] 🧹 已清理 openclaw.json 过期字段 instanceId");
+    }
+    logger?.info?.("[roundtable] 📝 已回写 openclaw.json（token/plugins.allow）");
+  } catch (e) {
+    logger?.warn?.(`[roundtable] 回写 openclaw.json 失败: ${e.message}（请检查 JSON 编码/格式）`);
+  }
+}
+
+function syncOpenClawConfigIfEnabled(ocHome, wsUrl, updates, logger) {
+  if (!ENABLE_OPENCLAW_CONFIG_SYNC) return false;
+  upsertOpenClawPluginConfig(ocHome, wsUrl, updates, logger);
+  return true;
+}
+
+/**
+ * 导出初始化函数，供 Channel 插件入口调用
+ * @param {object} api - OpenClaw Plugin API
+ * @param {object} core - api.runtime
+ * @param {boolean} hasRuntimeAPI - runtime API 是否可用
+ */
+module.exports = function initRoundtable(api, core, hasRuntimeAPI) {
+  // ── 基础配置 ──
+  const cfg = api.pluginConfig || {};
+  const wsUrl = cfg.url || "ws://118.25.82.209:3000";
+  const httpBase = wsUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+  const configuredName = String(cfg.name || "").trim();
+  let token = String(cfg.token || "").trim();
+  let ownerToken = normalizeIdentityId(cfg.ownerToken, 128);
+  const persona = String(cfg.persona || "").trim();
+  const maxTokens = cfg.maxTokens || 150;
+
+  if (!WebSocket) {
+    api.logger.error("[roundtable] 找不到 ws 模块，插件无法启动");
+    return;
+  }
+
+  // runtime API 状态已由入口传入
+
+  // ── 身份与缓存（按 OpenClaw 目录 + wsUrl 隔离） ──
+  const ocHome = buildOpenClawHome();
+  const wsScope = scopeKeyFromWsUrl(wsUrl);
+  const tokenCacheFile = pathModule.join(ocHome, `.roundtable-token-${wsScope}`);
+  const ownerTokenCacheFile = pathModule.join(ocHome, `.roundtable-owner-${wsScope}`);
+  const instanceIdFile = pathModule.join(ocHome, `.roundtable-instance-${wsScope}`);
+  const sessionId = cryptoModule.randomBytes(12).toString("hex");
+  const machineFingerprint = buildMachineFingerprint();
+  let instanceId =
+    normalizeIdentityId(readTextSafe(instanceIdFile)) ||
+    cryptoModule.randomBytes(18).toString("hex");
+  writeTextSafe(instanceIdFile, instanceId);
+
+  const cachedToken = String(readTextSafe(tokenCacheFile) || "").trim();
+  if (cachedToken && token && token !== cachedToken) {
+    let useConfiguredToken = false;
+    let decisionReason = "";
+    if (ownerToken) {
+      useConfiguredToken = true;
+      decisionReason = "配置携带 ownerToken（视为新的安装绑定）";
+    } else {
+      try {
+        const info = requestTokenInfo(httpBase, token);
+        if (info?.token && String(info.token).trim() === token) {
+          useConfiguredToken = true;
+          decisionReason = "配置 token 在服务端存在（视为新安装）";
+        }
+      } catch {
+        // 服务端不可达时保持缓存优先，避免旧配置回滚
+      }
+    }
+
+    if (useConfiguredToken) {
+      api.logger.warn(`[roundtable] 🔁 检测到新 token，采用配置 token（${decisionReason}）`);
+      writeTextSafe(tokenCacheFile, token);
+    } else {
+      api.logger.warn("[roundtable] ⚠️ 检测到配置 token 与本地缓存不一致，优先使用缓存 token");
+      token = cachedToken;
+    }
+  } else if (cachedToken && !token) {
+    api.logger.info("[roundtable] 📦 从本地缓存加载 token");
+    token = cachedToken;
+  } else if (cachedToken && token === cachedToken) {
+    api.logger.info("[roundtable] 📦 命中本地 token 缓存");
+  }
+
+  const cachedOwnerToken = normalizeIdentityId(readTextSafe(ownerTokenCacheFile), 128);
+  if (!ownerToken && cachedOwnerToken) {
+    ownerToken = cachedOwnerToken;
+    api.logger.info("[roundtable] 🔗 从本地缓存恢复 ownerToken");
+  }
+
+  if (!token) {
+    // 调 HTTP API 自动注册
+    api.logger.info("[roundtable] 🔑 首次启动，自动注册中...");
+    const botName = configuredName || buildDefaultBotName();
+
+    try {
+      const resp = requestAutoRegister(httpBase, {
+        fingerprint: machineFingerprint,
+        name: botName,
+        instanceId,
+        ...(ownerToken ? { ownerToken } : {}),
+      });
+      if (resp.token) {
+        token = resp.token;
+        if (resp.ownerToken) ownerToken = normalizeIdentityId(resp.ownerToken, 128) || ownerToken;
+        api.logger.info(`[roundtable] 🔑 自动注册成功！名称: ${resp.name}${resp.reused ? '（复用）' : '（新建）'}`);
+        writeTextSafe(tokenCacheFile, token);
+        writeTextSafe(instanceIdFile, instanceId);
+        if (ownerToken) writeTextSafe(ownerTokenCacheFile, ownerToken);
+        syncOpenClawConfigIfEnabled(ocHome, wsUrl, {
+          token,
+          ownerToken: ownerToken || undefined,
+          name: configuredName || undefined,
+        }, api.logger);
+      }
+    } catch (err) {
+      api.logger.warn(`[roundtable] ⚠️ 自动注册失败: ${err.message}，插件以观察模式启动`);
+    }
+  }
+
+  if (token) writeTextSafe(tokenCacheFile, token);
+  if (ownerToken) writeTextSafe(ownerTokenCacheFile, ownerToken);
+  syncOpenClawConfigIfEnabled(ocHome, wsUrl, {
+    token,
+    ownerToken: ownerToken || undefined,
+    name: configuredName || undefined,
+  }, api.logger);
+  if (!ENABLE_OPENCLAW_CONFIG_SYNC) {
+    api.logger.info("[roundtable] 配置同步已禁用：仅写本地 token 缓存，避免触发 gateway 重启");
+  }
+  api.logger.info(`[roundtable] v${PLUGIN_VERSION} 启动（Channel 模式）`);
+  return startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFile, {
+    ocHome,
+    instanceId,
+    instanceIdFile,
+    sessionId,
+    fingerprint: machineFingerprint,
+    wsScope,
+    ownerToken,
+    ownerTokenCacheFile,
+  });
+};
+
+function startBot(api, core, cfg, wsUrl, token, persona, maxTokens, tokenCacheFile, identityCtx = {}) {
+  let ws = null;
+  let reconnectTimer = null;
+  let reconnectAttempts = 0;
+  let stopping = false; // Gateway 停止标志，防止 onclose 触发幽灵重连
+  const configuredName = String(cfg.name || "").trim();
+  let myName = configuredName || "龙虾";
+
+  // 进化室选 Skill 时排除已被拒绝的
+  let rejectedSkills = new Set();
+  // AI 自检结果缓存
+  let cachedSkillList = null;
+  // 当前所在房间状态（给 owner_command 自主决策使用）
+  let currentRoomId = null;
+  let currentRoomMode = null;
+  let currentRoomRunning = false;
+  let currentRoomRules = "";
+  let availableRooms = [];
+  let pendingStartAfterJoin = null; // { roomId, maxRounds, reason }
+  const factualEvents = [];
+  const httpBase = wsUrl.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+  let autonomyEnabled = false;
+  let autonomyTimer = null;
+  let autonomyTickBusy = false;
+  const autonomyState = {
+    mode: 'roundtable',
+    rounds: 5,
+    lastActionAt: 0,
+  };
+  const diagUrl = `${httpBase}/api/plugin-diagnostics`;
+  const diagLastSent = new Map();
+  const ocHome = identityCtx.ocHome || buildOpenClawHome();
+  const skillsRoot = pathModule.join(ocHome, "skills");
+  const instanceIdFile = identityCtx.instanceIdFile || pathModule.join(ocHome, ".roundtable-instance");
+  const tokenCache = identityCtx.tokenCacheFile || tokenCacheFile;
+  const ownerTokenCacheFile = identityCtx.ownerTokenCacheFile || pathModule.join(ocHome, ".roundtable-owner");
+  const fingerprint = normalizeIdentityId(identityCtx.fingerprint, 64) || buildMachineFingerprint();
+  let ownerToken =
+    normalizeIdentityId(identityCtx.ownerToken || cfg.ownerToken, 128) ||
+    normalizeIdentityId(readTextSafe(ownerTokenCacheFile), 128);
+  let instanceId = normalizeIdentityId(identityCtx.instanceId) || normalizeIdentityId(readTextSafe(instanceIdFile)) || cryptoModule.randomBytes(18).toString("hex");
+  const sessionId = normalizeIdentityId(identityCtx.sessionId, 120) || cryptoModule.randomBytes(12).toString("hex");
+  let recoveringToken = false;
+
+  // Token 冲突熔断器：防止无限重试导致日志爆炸和 CPU 空转
+  const conflictBreaker = {
+    count: 0,
+    lastAt: 0,
+    maxPerWindow: 3,      // 5 分钟内最多重试 3 次
+    windowMs: 5 * 60000,
+    cooldownMs: 120000,   // 熔断后冷却 2 分钟
+    fused: false,
+  };
+
+  function shouldBreakConflict() {
+    const now = Date.now();
+    if (now - conflictBreaker.lastAt > conflictBreaker.windowMs) {
+      conflictBreaker.count = 0;
+      conflictBreaker.fused = false;
+    }
+    conflictBreaker.count++;
+    conflictBreaker.lastAt = now;
+    if (conflictBreaker.count > conflictBreaker.maxPerWindow) {
+      conflictBreaker.fused = true;
+      api.logger.error(
+        `[roundtable] 🚨 Token 冲突熔断：5分钟内冲突 ${conflictBreaker.count} 次，冷却 ${conflictBreaker.cooldownMs / 1000}s`
+      );
+      reportDiag("token_conflict_fused", {
+        level: "error",
+        message: `circuit breaker fused after ${conflictBreaker.count} conflicts`,
+        detail: { cooldownMs: conflictBreaker.cooldownMs },
+      }, 0);
+      return true;
+    }
+    return false;
+  }
+
+  function persistIdentity(tokenValue) {
+    if (tokenValue) writeTextSafe(tokenCache, tokenValue);
+    if (instanceId) writeTextSafe(instanceIdFile, instanceId);
+    if (ownerToken) writeTextSafe(ownerTokenCacheFile, ownerToken);
+  }
+
+  function nextReconnectDelayMs() {
+    const base = Math.min(30000, Math.round(2500 * Math.pow(1.6, reconnectAttempts)));
+    reconnectAttempts += 1;
+    const jitter = Math.floor(Math.random() * 1000);
+    return base + jitter;
+  }
+
+  function scheduleReconnect(delayOverrideMs) {
+    if (stopping) return -1; // Gateway 已要求停止，不再重连
+    clearTimeout(reconnectTimer);
+    const delayMs = Number.isFinite(delayOverrideMs) ? Math.max(800, delayOverrideMs) : nextReconnectDelayMs();
+    reconnectTimer = setTimeout(connect, delayMs);
+    return delayMs;
+  }
+
+  function tryAutoRegisterRecover(reason, options = {}) {
+    if (recoveringToken) return false;
+    recoveringToken = true;
+    try {
+      const rotateInstance = !!options.rotateInstance;
+      const forceNewToken = !!options.forceNewToken;
+      if (rotateInstance) {
+        instanceId = cryptoModule.randomBytes(18).toString("hex");
+        api.logger.warn(`[roundtable] ♻️ 发生 token 冲突，已切换新实例标识: ${instanceId.slice(0, 8)}...`);
+      }
+      const recoverName = configuredName || (myName && myName !== "龙虾" ? myName : "") || buildDefaultBotName();
+      const payload = {
+        fingerprint,
+        name: recoverName,
+        instanceId,
+        forceNewToken,
+      };
+      if (ownerToken) payload.ownerToken = ownerToken;
+      const preferredToken = String(
+        options.preferredToken || token || String(cfg.token || "").trim()
+      ).trim();
+      if (preferredToken) payload.preferredToken = preferredToken;
+      const resp = requestAutoRegister(httpBase, payload);
+      if (!resp?.token) return false;
+      token = String(resp.token).trim();
+      if (resp.ownerToken) {
+        ownerToken = normalizeIdentityId(resp.ownerToken, 128) || ownerToken;
+      }
+      api.logger.info(`[roundtable] 🔑 自愈注册成功（${reason}）: ${resp.name || myName}${resp.reused ? "（复用）" : "（新建）"} token=${token.slice(0, 10)}...`);
+      persistIdentity(token);
+      syncOpenClawConfigIfEnabled(ocHome, wsUrl, {
+        token,
+        ownerToken: ownerToken || undefined,
+        name: configuredName || undefined,
+      }, api.logger);
+      reportDiag("token_recover_success", {
+        message: `recover success: ${reason}`,
+        detail: { reused: !!resp.reused, rotateInstance, forceNewToken },
+      }, 0);
+      try { ws?.close(); } catch { }
+      return true;
+    } catch (err) {
+      api.logger.error(`[roundtable] 自愈注册失败（${reason}）: ${err.message}`);
+      reportDiag("token_recover_failed", {
+        level: "error",
+        message: err.message,
+        stack: err.stack || "",
+        detail: { reason },
+      }, 0);
+      return false;
+    } finally {
+      recoveringToken = false;
+    }
+  }
+
+  function postJsonNoWait(url, payload) {
+    try {
+      const u = new URL(url);
+      const body = Buffer.from(JSON.stringify(payload));
+      const lib = u.protocol === "https:" ? httpsModule : httpModule;
+      const req = lib.request({
+        method: "POST",
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: `${u.pathname}${u.search || ""}`,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": body.length,
+        },
+      }, (res) => { res.resume(); });
+      req.on("error", () => { });
+      req.setTimeout(2500, () => req.destroy());
+      req.write(body);
+      req.end();
+    } catch { }
+  }
+
+  function safeDiagText(v, max = 280) {
+    const s = String(v || "").trim();
+    return s.length > max ? s.slice(0, max) : s;
+  }
+
+  function reportDiag(event, payload = {}, throttleMs = 8000) {
+    if (!event) return;
+    const now = Date.now();
+    const level = safeDiagText(payload.level || "info", 16).toLowerCase() || "info";
+    const message = safeDiagText(payload.message || "", 500);
+    const reason = safeDiagText(payload.reason || "", 260);
+    const key = `${event}|${level}|${message.slice(0, 80)}|${payload.code ?? ""}|${reason.slice(0, 80)}`;
+    if (throttleMs > 0) {
+      const last = diagLastSent.get(key) || 0;
+      if (now - last < throttleMs) return;
+      diagLastSent.set(key, now);
+    }
+    postJsonNoWait(diagUrl, {
+      source: "plugin-main",
+      event: safeDiagText(event, 64),
+      level,
+      message,
+      reason,
+      code: Number.isFinite(Number(payload.code)) ? Number(payload.code) : null,
+      roomId: currentRoomId || "",
+      roomMode: currentRoomMode || "",
+      wsUrl,
+      botName: myName || "",
+      token: token || "",
+      instanceId: instanceId || "",
+      sessionId: sessionId || "",
+      detail: payload.detail && typeof payload.detail === "object" ? payload.detail : null,
+      stack: safeDiagText(payload.stack || "", 1200),
+      ts: new Date().toISOString(),
+    });
+  }
+
+  function reportDiagSync(event, payload = {}) {
+    try {
+      const body = JSON.stringify({
+        source: "plugin-main",
+        event: safeDiagText(event, 64),
+        level: safeDiagText(payload.level || "error", 16).toLowerCase(),
+        message: safeDiagText(payload.message || "", 500),
+        reason: safeDiagText(payload.reason || "", 260),
+        code: Number.isFinite(Number(payload.code)) ? Number(payload.code) : null,
+        roomId: currentRoomId || "",
+        roomMode: currentRoomMode || "",
+        wsUrl,
+        botName: myName || "",
+        token: token || "",
+        instanceId: instanceId || "",
+        sessionId: sessionId || "",
+        stack: safeDiagText(payload.stack || "", 1200),
+        ts: new Date().toISOString(),
+      });
+      execFileSync("curl", [
+        "-sS",
+        "--connect-timeout", "2",
+        "--max-time", "4",
+        "-X", "POST",
+        "-H", "Content-Type: application/json",
+        "--data", body,
+        diagUrl,
+      ], { stdio: "ignore", timeout: 5000 });
+    } catch { }
+  }
+
+  function installCrashHooks() {
+    const globalKey = "__LOBSTER_RT_DIAG_REPORTERS__";
+    const state = global[globalKey] || { hooked: false, reporters: [] };
+    if (!Array.isArray(state.reporters)) state.reporters = [];
+    state.reporters = state.reporters.filter((fn) => typeof fn === "function").slice(-7);
+    state.reporters.push(reportDiagSync);
+    if (!state.hooked) {
+      const fanout = (event, payload) => {
+        for (const fn of state.reporters) {
+          try { fn(event, payload); } catch { }
+        }
+      };
+      process.on("unhandledRejection", (reason) => {
+        fanout("process_unhandled_rejection", {
+          level: "fatal",
+          message: reason && reason.message ? String(reason.message) : String(reason || "unknown"),
+          stack: reason && reason.stack ? String(reason.stack) : "",
+        });
+      });
+      process.on("uncaughtExceptionMonitor", (err) => {
+        fanout("process_uncaught_exception", {
+          level: "fatal",
+          message: err && err.message ? String(err.message) : String(err || "unknown"),
+          stack: err && err.stack ? String(err.stack) : "",
+        });
+      });
+      process.on("exit", (code) => {
+        fanout("process_exit", {
+          level: "warn",
+          message: "process exit",
+          code,
+        });
+      });
+      state.hooked = true;
+    }
+    global[globalKey] = state;
+  }
+
+  installCrashHooks();
+
+  const heartbeatTimer = setInterval(() => {
+    reportDiag("heartbeat", {
+      level: "debug",
+      message: currentRoomId ? `in-room:${currentRoomId}` : "in-lobby",
+      detail: { autonomyEnabled, currentRoomRunning },
+    }, 0);
+  }, 60000);
+  if (heartbeatTimer.unref) heartbeatTimer.unref();
+
+  reportDiag("plugin_boot", {
+    message: "plugin main started",
+    detail: { version: PLUGIN_VERSION, hasToken: !!token, node: process.version },
+  }, 0);
+
+  function connect() {
+    if (stopping) return; // Gateway 已要求停止，不再连接
+    api.logger.info(`[roundtable] 连接 ${wsUrl} ...`);
+
+    try {
+      ws = new WebSocket(wsUrl);
+    } catch (err) {
+      api.logger.error(`[roundtable] 创建 WS 失败: ${err.message}`);
+      reportDiag("ws_create_failed", { level: "error", message: err.message });
+      scheduleReconnect();
+      return;
+    }
+
+    ws.onopen = () => {
+      reconnectAttempts = 0;
+      reportDiag("ws_open", {
+        message: token ? "connected with token" : "connected in observe mode",
+        detail: { instanceId, sessionId },
+      }, 3000);
+      if (!token) {
+        api.logger.info("[roundtable] WebSocket 已连接（观察模式，未注册 Bot）");
+        return;
+      }
+      const rejoinRoom = currentRoomId;
+      if (rejoinRoom) {
+        api.logger.info(`[roundtable] 🔄 重连成功，尝试自动回到房间: ${rejoinRoom}`);
+      } else {
+        api.logger.info("[roundtable] WebSocket 已连接，进入大厅待机...");
+      }
+      const installedSkills = listInstalledSkillNames(skillsRoot, 200);
+      send({
+        type: "bot_connect",
+        token,
+        name: configuredName || undefined,
+        ownerToken: ownerToken || undefined,
+        fingerprint,
+        instanceId,
+        sessionId,
+        skillNames: installedSkills,
+        roomId: rejoinRoom || undefined,
+      });
+    };
+
+    ws.onmessage = async (event) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      try {
+        await handleMessage(msg);
+      } catch (err) {
+        api.logger.error(`[roundtable] handleMessage 崩溃兄底: ${err.message}`);
+        reportDiag("handle_message_error", {
+          level: "error",
+          message: err.message,
+          stack: err.stack || "",
+          detail: { msgType: msg?.type || "unknown" },
+        }, 1500);
+      }
+    };
+
+    ws.onclose = (evt) => {
+      // 断连后立即清理本地 room 状态，避免重连后状态错乱
+      currentRoomId = null;
+      currentRoomMode = null;
+      currentRoomRunning = false;
+      currentRoomRules = "";
+      pendingStartAfterJoin = null;
+
+      if (stopping) {
+        reportDiag("ws_close", {
+          level: "info",
+          message: "websocket closed during shutdown",
+          code: evt?.code ?? null,
+          reason: String(evt?.reason || ""),
+          detail: { reconnectInMs: null, reconnectAttempts },
+        }, 2000);
+        api.logger.info("[roundtable] 连接已关闭（停止中，不重连）");
+        return;
+      }
+
+      const delayMs = scheduleReconnect();
+      reportDiag("ws_close", {
+        level: "warn",
+        message: "websocket closed",
+        code: evt?.code ?? null,
+        reason: String(evt?.reason || ""),
+        detail: { reconnectInMs: delayMs, reconnectAttempts },
+      }, 2000);
+      api.logger.warn(`[roundtable] 连接断开，${Math.round(delayMs / 1000)} 秒后重连...`);
+    };
+
+    ws.onerror = (event) => {
+      reportDiag("ws_error", {
+        level: "error",
+        message: event?.message || "unknown",
+      }, 1500);
+      api.logger.error(
+        `[roundtable] WS 错误: ${event.message || "unknown"}`
+      );
+    };
+  }
+
+  function findRoomByMode(mode) {
+    const list = (availableRooms || []).filter(r => r.mode === mode);
+    if (list.length === 0) return null;
+    return list.find(r => !r.running) || list[0];
+  }
+
+  function safeParseJsonObject(text) {
+    if (!text) return null;
+    const trimmed = String(text).trim();
+    try { return JSON.parse(trimmed); } catch { }
+    const match = trimmed.match(/\{[\s\S]*\}/);
+    if (!match) return null;
+    try { return JSON.parse(match[0]); } catch { return null; }
+  }
+
+  function rememberFact(text) {
+    const content = String(text || '').trim();
+    if (!content) return;
+    factualEvents.push(
+      `${new Date().toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })} ${content}`
+    );
+    while (factualEvents.length > 40) factualEvents.shift();
+  }
+
+  function getFactualContext(limit = 10) {
+    return factualEvents.slice(-Math.max(1, parseInt(limit, 10) || 10)).join('\n');
+  }
+
+  function clearAutonomyTimer() {
+    if (autonomyTimer) {
+      clearTimeout(autonomyTimer);
+      autonomyTimer = null;
+    }
+  }
+
+  function scheduleAutonomyTick(delayMs = 12000) {
+    if (!autonomyEnabled) return;
+    clearAutonomyTimer();
+    autonomyTimer = setTimeout(() => {
+      autonomyTimer = null;
+      runAutonomyTick('timer');
+    }, Math.max(800, parseInt(delayMs, 10) || 12000));
+  }
+
+  function setAutonomyEnabled(enabled, reason = '') {
+    const next = !!enabled;
+    if (autonomyEnabled === next) {
+      if (next) scheduleAutonomyTick(1200);
+      return;
+    }
+    autonomyEnabled = next;
+    if (next) {
+      send({ type: 'bot_status', status: 'autonomy', text: reason || '🤖 已进入自由活动托管模式' });
+      rememberFact(`开启托管${reason ? `：${reason}` : ''}`);
+      scheduleAutonomyTick(500);
+    } else {
+      clearAutonomyTimer();
+      rememberFact(`停止托管${reason ? `：${reason}` : ''}`);
+      if (currentRoomId) {
+        send({ type: 'bot_status', status: 'in_room', text: `🎯 已停止托管，当前在 ${currentRoomId}` });
+      } else {
+        send({ type: 'bot_status', status: 'lobby', text: '☕ 已停止托管，回到大厅待机' });
+      }
+    }
+  }
+
+  async function refreshRoomsViaHttp() {
+    try {
+      const res = await fetch(`${httpBase}/api/rooms`);
+      if (!res.ok) return;
+      const data = await res.json();
+      if (Array.isArray(data?.rooms)) {
+        availableRooms = data.rooms;
+      }
+    } catch { }
+  }
+
+  async function createRoomViaHttp(mode = 'roundtable') {
+    const finalMode = ['evolution', 'roundtable', 'debate'].includes(String(mode || '').trim().toLowerCase())
+      ? String(mode || '').trim().toLowerCase()
+      : 'roundtable';
+    try {
+      const payload = {
+        mode: finalMode,
+        name: `自由活动·${new Date().toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit' })}`,
+        topic: finalMode === 'debate' ? '自由活动辩题：AI 是否应默认自主管理任务？' : '自由活动：分享你最近最有价值的一次实践',
+        maxRounds: Math.max(1, parseInt(autonomyState.rounds, 10) || 5),
+      };
+      const res = await fetch(`${httpBase}/api/rooms`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!res.ok) return null;
+      const room = await res.json();
+      if (room?.id) {
+        availableRooms = [...(availableRooms || []).filter((r) => r.id !== room.id), room];
+        rememberFact(`托管自动创建房间 ${room.id} (${room.mode || finalMode})`);
+        return room;
+      }
+    } catch { }
+    return null;
+  }
+
+  function selectAutonomyTargetRoom() {
+    const list = Array.isArray(availableRooms) ? availableRooms : [];
+    if (list.length === 0) return null;
+    const idle = list.filter((r) => !r.running);
+    const byMode = (arr, mode) => arr.find((r) => r.mode === mode) || null;
+    return byMode(idle, autonomyState.mode) || byMode(idle, 'roundtable') || byMode(idle, 'evolution') || byMode(idle, 'debate')
+      || byMode(list, autonomyState.mode) || byMode(list, 'roundtable') || list[0] || null;
+  }
+
+  async function runAutonomyTick(trigger = '') {
+    if (!autonomyEnabled || autonomyTickBusy) return;
+    autonomyTickBusy = true;
+    try {
+      const now = Date.now();
+      if (now - autonomyState.lastActionAt < 2200) return;
+      await refreshRoomsViaHttp();
+
+      const roomInfo = currentRoomId ? (availableRooms || []).find((r) => r.id === currentRoomId) : null;
+      if (currentRoomId && roomInfo) {
+        currentRoomRunning = !!roomInfo.running;
+        if (!currentRoomRunning) {
+          send({
+            type: 'owner_admin',
+            roomId: currentRoomId,
+            token,
+            action: 'toggle',
+            maxRounds: Math.max(1, parseInt(autonomyState.rounds, 10) || 5),
+          });
+          autonomyState.lastActionAt = now;
+          rememberFact(`托管在房间 ${currentRoomId} 自动开局`);
+          send({ type: 'bot_status', status: 'autonomy', text: `🤖 托管中：在 ${currentRoomId} 继续开局` });
+        } else if (trigger === 'timer') {
+          send({ type: 'bot_status', status: 'autonomy', text: `🤖 托管中：${currentRoomId} 讨论进行中` });
+        }
+        return;
+      }
+
+      let target = selectAutonomyTargetRoom();
+      if (!target || target.running) {
+        const created = await createRoomViaHttp(autonomyState.mode);
+        if (created) target = created;
+      }
+      if (!target?.id) {
+        send({ type: 'bot_status', status: 'autonomy', text: '🤖 托管中：暂未找到可用房间，继续观察' });
+        return;
+      }
+
+      send({ type: 'join_room', token, roomId: target.id });
+      queueStartAfterJoin(target.id, Math.max(1, parseInt(autonomyState.rounds, 10) || 5), 'autonomy_loop');
+      autonomyState.lastActionAt = now;
+      rememberFact(`托管自动加入房间 ${target.id}`);
+      send({ type: 'bot_status', status: 'autonomy', text: `🤖 托管中：已前往 ${target.id}，准备开局` });
+    } finally {
+      autonomyTickBusy = false;
+      if (autonomyEnabled) scheduleAutonomyTick(12000);
+    }
+  }
+
+  function queueStartAfterJoin(roomId, maxRounds = 5, reason = '') {
+    const rid = String(roomId || '').trim();
+    if (!rid) return;
+    pendingStartAfterJoin = {
+      roomId: rid,
+      maxRounds: Math.max(1, parseInt(maxRounds, 10) || 5),
+      reason: String(reason || '').trim(),
+    };
+  }
+
+  function tryFlushPendingStart(roomId) {
+    if (!pendingStartAfterJoin) return false;
+    const rid = String(roomId || '').trim();
+    if (!rid || pendingStartAfterJoin.roomId !== rid) return false;
+    send({
+      type: 'owner_admin',
+      roomId: rid,
+      token,
+      action: 'toggle',
+      maxRounds: pendingStartAfterJoin.maxRounds,
+    });
+    rememberFact(`入房后自动开局: ${rid}（${pendingStartAfterJoin.maxRounds}轮）`);
+    pendingStartAfterJoin = null;
+    return true;
+  }
+
+  function isRejectedSkillName(name) {
+    const target = String(name || '').trim().toLowerCase();
+    if (!target) return false;
+    for (const item of rejectedSkills || []) {
+      const s = String(item || '').trim().toLowerCase();
+      if (!s) continue;
+      if (s === target || s.includes(target) || target.includes(s)) return true;
+    }
+    return false;
+  }
+
+  function isLowQualitySkillName(name, systemSkills = []) {
+    const target = String(name || '').trim().toLowerCase();
+    if (!target) return true;
+    const builtin = new Set(
+      (Array.isArray(systemSkills) ? systemSkills : [])
+        .map((s) => String(s || '').trim().toLowerCase())
+        .filter(Boolean)
+    );
+    if (builtin.has(target)) return true;
+    const deny = [
+      'browser_use', 'computer_use', 'web_search', 'code_execution', 'file_manager',
+      'memory', 'vision', 'healthcheck', 'health-check', 'health_check',
+      'skill-creator', 'system-info', 'system_info', 'douyin-developer',
+      'demo', 'example', 'test', 'tmp', 'temp',
+    ];
+    if (deny.some((k) => target === k || target.includes(k))) return true;
+    // 明显像占位/模板名字的候选一律压掉
+    if (/^(my[-_ ]?)?skill\d*$/i.test(target)) return true;
+    if (target.length < 3) return true;
+    return false;
+  }
+
+  async function translateSkillNameToChinese(skillName) {
+    const raw = String(skillName || '').trim();
+    if (!raw) return '';
+    try {
+      const prompt = [
+        `请把这个 Skill 名称翻译成简洁中文：${raw}`,
+        '要求：仅输出中文名称，不解释，不加引号，不超过8个字。',
+      ].join('\n');
+      const reply = await callAI(api, core, myName, prompt);
+      const firstLine = String(reply || '').split(/\r?\n/)[0] || '';
+      const cleaned = firstLine
+        .replace(/["'`[\](){}<>]/g, ' ')
+        .replace(/[：:，,。！!？?]/g, ' ')
+        .replace(/\s+/g, '')
+        .trim();
+      if (cleaned && !/[A-Za-z]/.test(cleaned)) return cleaned;
+    } catch { }
+    return raw.replace(/[_-]+/g, ' ').trim();
+  }
+
+  async function callAIWithTimeout(prompt, timeoutMs = 30000, tag = 'callAI') {
+    const ms = Math.max(5000, parseInt(timeoutMs, 10) || 30000);
+    let timeoutId = null;
+    try {
+      return await Promise.race([
+        callAI(api, core, myName, prompt),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new Error(`${tag}_timeout_${ms}`)), ms);
+        }),
+      ]);
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+
+  function buildSkillShareDraft(skillName, rawContent) {
+    const name = String(skillName || '').trim() || '未命名Skill';
+    const text = String(rawContent || '').replace(/\r\n/g, '\n').trim();
+    const markerHit = ['痛点', '步骤', '案例', '风险', '边界', '输入', '动作', '结果']
+      .filter((m) => text.includes(m)).length;
+    if (text.length >= 140 && markerHit >= 4) {
+      return text.length > 2600 ? `${text.slice(0, 2600)}\n\n...（内容已截断）` : text;
+    }
+    const detail = text
+      ? text.split('\n').map((s) => s.trim()).filter(Boolean).slice(0, 4).join('；').slice(0, 140)
+      : '暂无现成文档，按可落地流程给出经验分享。';
+    return [
+      `【Skill名称】${name}`,
+      `① 解决痛点：面对复杂任务容易反复试错时，先统一目标与验收标准，减少无效返工。`,
+      `② 核心步骤：先梳理输入与约束；再分段执行并记录中间结论；最后复盘沉淀成可复用模板。`,
+      `③ 实战案例：输入“任务需求与限制” -> 动作“分解步骤+执行校验+纠偏” -> 结果“交付更稳定，返工明显下降”。`,
+      `④ 边界与风险：当上下文缺失或目标不清时效果会下降，必须先补齐信息再执行。`,
+      detail ? `补充细节：${detail}` : '',
+    ].filter(Boolean).join('\n');
+  }
+
+  async function handlePickSkillRequest(rawMsg = {}, source = 'pick_skill') {
+    rejectedSkills = new Set(rawMsg.rejected || []);
+    const rejectedList = [...rejectedSkills].join('、') || '无';
+    const systemSkills = Array.isArray(rawMsg.systemSkills) ? rawMsg.systemSkills : [];
+    const systemSkillText = systemSkills.length ? systemSkills.join('、') : '（无）';
+
+    const installedSkills = listInstalledSkillNames(skillsRoot, 200);
+    const uniqueSkills = [...new Set(installedSkills)].filter((s) => {
+      if (isRejectedSkillName(s)) return false;
+      if (isLowQualitySkillName(s, systemSkills)) return false;
+      return true;
+    });
+    cachedSkillList = uniqueSkills;
+
+    // 本地技能优先，避免多轮 AI 调用导致选 Skill 超时。
+    if (uniqueSkills.length > 0) {
+      const chosen = uniqueSkills[0];
+      const safeName = sanitizeSkillDirName(chosen);
+      const skillFile = safeName ? pathModule.join(skillsRoot, safeName, 'SKILL.md') : '';
+      const raw = skillFile ? readTextSafe(skillFile) : '';
+      const draft = buildSkillShareDraft(chosen, raw);
+      api.logger.info(`[roundtable] 🧬 本地直选 Skill(${source}): ${chosen} (候选 ${uniqueSkills.length})`);
+      rememberFact(`准备分享 Skill：${chosen}`);
+      send({ type: 'skill_picked', skillName: chosen, skillContent: draft });
+      return;
+    }
+
+    // 兜底：单次 AI 输出，避免旧逻辑多次 callAI 累积超时。
+    try {
+      const oneShotPrompt = [
+        `你在进化室轮到分享 Skill。`,
+        `排除系统内置能力：${systemSkillText}`,
+        `排除已分享/被拒绝项：${rejectedList}`,
+        `如果没有可分享技能，仅回复：NONE`,
+        ``,
+        `否则严格输出两行：`,
+        `SKILL_NAME: 你要分享的技能名`,
+        `SKILL_DESC: 用中文给出可审核、可复用的分享稿（至少140字，包含痛点/步骤/案例/风险，必须有“输入->动作->结果”链路）`,
+      ].join('\n');
+      const reply = String(await callAIWithTimeout(oneShotPrompt, 28000, 'pick_skill_one_shot') || '').trim();
+      if (!reply || (/NONE/i.test(reply) && !/SKILL_NAME/i.test(reply))) {
+        api.logger.info(`[roundtable] 🧬 ${source} 兜底：无可分享技能，降级经验分享`);
+        send({ type: 'skill_picked', noSkill: true, reason: 'experience' });
+        return;
+      }
+      const nameMatch = reply.match(/SKILL_NAME:\s*(.+)/i);
+      const descMatch = reply.match(/SKILL_DESC:\s*([\s\S]+)/i);
+      const parsedName = String(nameMatch?.[1] || '').trim().replace(/[`"']/g, '');
+      const skillName = parsedName || String(reply.split(/\r?\n/)[0] || '').trim().slice(0, 80) || '经验分享';
+      const skillContent = buildSkillShareDraft(skillName, descMatch?.[1] || reply);
+      rememberFact(`准备分享 Skill：${skillName}`);
+      send({ type: 'skill_picked', skillName, skillContent });
+    } catch (err) {
+      api.logger.error(`[roundtable] pick_skill 失败(${source}): ${err.message}`);
+      send({ type: 'skill_picked', noSkill: true, reason: 'error' });
+    }
+  }
+
+  function normalizeOwnerActions(actions) {
+    const validTypes = new Set(['join_room', 'leave_room', 'status', 'auto_join', 'start_room', 'stop_room', 'wait']);
+    const out = [];
+    for (const action of (Array.isArray(actions) ? actions : [])) {
+      const type = String(action?.type || '').trim();
+      if (!validTypes.has(type)) continue;
+      const next = { type };
+      const roomId = String(action?.roomId || '').trim();
+      const mode = String(action?.mode || '').trim().toLowerCase();
+      const rounds = parseInt(action?.maxRounds, 10);
+      if (roomId) next.roomId = roomId;
+      if (['evolution', 'roundtable', 'debate'].includes(mode)) next.mode = mode;
+      if (Number.isFinite(rounds) && rounds > 0) next.maxRounds = Math.floor(rounds);
+      out.push(next);
+    }
+    return out;
+  }
+
+  function fallbackOwnerPlan(rawText) {
+    const text = String(rawText || '').trim();
+    const plan = { reply: '收到，我会按你的要求执行。', actions: [] };
+    const stopAutonomyIntent = /停止托管|暂停托管|取消托管|结束托管|停止吧|停一下|先停|停下|别自主|不要自主|stop autonomy/i.test(text);
+    const startAutonomyIntent = /自由活动|开启托管|开始托管|继续托管|恢复托管|自主|探索|找乐子|auto|随机/i.test(text);
+    if (!text) {
+      plan.actions.push({ type: 'status' });
+      return plan;
+    }
+
+    if (/状态|汇报|在哪|在干嘛|status/i.test(text)) {
+      plan.actions.push({ type: 'status' });
+    }
+    if (/离开|退出|回大厅|离开当前房间|leave/i.test(text)) {
+      plan.actions.push({ type: 'leave_room' });
+    }
+    if (/开始讨论|开始辩论|启动讨论|开局|start/i.test(text)) {
+      plan.actions.push({ type: 'start_room' });
+    }
+    if (/停止讨论|暂停讨论|结束讨论|stop/i.test(text)) {
+      plan.actions.push({ type: 'stop_room' });
+    }
+    if (/停止托管|暂停托管|取消托管|结束托管|停止吧|停一下|先停|停下|别自主|不要自主/i.test(text)) {
+      plan.actions.push({ type: 'wait' });
+    }
+    if (/等人|先等|待机|wait/i.test(text)) {
+      plan.actions.push({ type: 'wait' });
+    }
+
+    if (/进化|evolution/i.test(text)) {
+      plan.actions.push({ type: 'join_room', mode: 'evolution' });
+    } else if (/辩论|debate|pk/i.test(text)) {
+      plan.actions.push({ type: 'join_room', mode: 'debate' });
+    } else if (/圆桌|roundtable|讨论/i.test(text)) {
+      plan.actions.push({ type: 'join_room', mode: 'roundtable' });
+    }
+
+    if (!stopAutonomyIntent && startAutonomyIntent) {
+      plan.actions.push({ type: 'auto_join' });
+    }
+
+    if (plan.actions.length === 0) {
+      plan.actions.push({ type: 'status' });
+    }
+    return plan;
+  }
+
+  function parseIntentHintObject(intentHint) {
+    if (!intentHint) return null;
+    let hint = intentHint;
+    if (typeof hint === 'string') {
+      try { hint = JSON.parse(hint); } catch { hint = { raw: hint }; }
+    }
+    if (!hint || typeof hint !== 'object') return null;
+    return hint;
+  }
+
+  function planFromIntentHint(intentHint, rawText) {
+    const hint = parseIntentHintObject(intentHint);
+    if (!hint) return null;
+
+    const actions = normalizeOwnerActions(hint.actions);
+    const modeHint = String(hint.mode || hint.roomMode || '').trim().toLowerCase();
+    if (actions.length === 0 && ['evolution', 'roundtable', 'debate'].includes(modeHint)) {
+      actions.push({ type: 'join_room', mode: modeHint });
+    }
+    if (actions.length === 0) {
+      return fallbackOwnerPlan(hint.raw || rawText || '');
+    }
+    return {
+      reply: String(hint.reply || '收到，开始执行。').trim(),
+      actions,
+    };
+  }
+
+  async function buildOwnerPlan(text, intentHint = null) {
+    const hinted = planFromIntentHint(intentHint, text);
+    const hintObj = parseIntentHintObject(intentHint);
+    const hintSource = String(hintObj?.source || '').trim();
+    const hintPage = String(hintObj?.page || '').trim();
+    const hintRoomId = String(hintObj?.roomId || '').trim();
+    const hintActions = JSON.stringify(hinted?.actions || []);
+    const hintAutopilot = !!hintObj?.autopilot;
+
+    const roomLines = (availableRooms || []).map((r) => {
+      const bots = Number.isFinite(r.botCount) ? r.botCount : 0;
+      const rounds = `${r.currentRound || 0}/${r.maxRounds || 5}`;
+      const rules = String(r.roomRules || '').trim();
+      const ruleText = rules ? ` | rules=${rules.slice(0, 80)}` : '';
+      return `- ${r.id} | ${r.name} | ${r.mode} | ${r.running ? 'running' : 'idle'} | bots=${bots} | rounds=${rounds}${ruleText}`;
+    }).join('\n') || '（无可用房间）';
+
+    const prompt = [
+      `你是 ${myName}，你的主人给了你一条自然语言指令。`,
+      '你需要输出下一步动作计划，只输出 JSON。',
+      '你正在“龙虾社区前端”的置顶消息框里接收指令，主人此刻就在网页端和你对话。',
+      '',
+      `当前状态：${currentRoomId ? `在房间 ${currentRoomId} (${currentRoomMode || 'unknown'})，running=${currentRoomRunning}` : '在大厅待机'}`,
+      `当前房间规则：${currentRoomRules || '无'}`,
+      `前端上下文：source=${hintSource || 'unknown'} page=${hintPage || '/'} roomId=${hintRoomId || 'none'} autopilot=${hintAutopilot}`,
+      `前端意图提示动作（仅供参考，不是强制）：${hintActions}`,
+      '可用房间：',
+      roomLines,
+      '',
+      `主人指令：${text}`,
+      '',
+      'JSON 格式：',
+      '{"reply":"给主人的简短反馈","actions":[{"type":"join_room","roomId":"可选","mode":"可选(evolution|roundtable|debate)"},{"type":"leave_room"},{"type":"status"},{"type":"auto_join"},{"type":"start_room","roomId":"可选","mode":"可选","maxRounds":5},{"type":"stop_room","roomId":"可选","mode":"可选"},{"type":"wait"}]}',
+      '',
+      '规则：',
+      '1. 只返回 JSON；actions 按执行顺序排列。',
+      '2. 自由活动时可 auto_join，并根据 bots/running 判断是开局还是等待。',
+      '3. 没把握就返回 status 或 wait。',
+      '4. reply 不超过40字。',
+      '5. 若主人只是闲聊（例如“在吗”“你现在干嘛”），reply 要自然口语化，actions 通常给 status。',
+      '6. 优先理解社区词汇：进化室、圆桌、辩论场、大厅、开始讨论、自由活动。',
+    ].join('\n');
+
+    try {
+      const aiReply = await callAI(api, core, myName, prompt);
+      const parsed = safeParseJsonObject(aiReply);
+      if (parsed && Array.isArray(parsed.actions)) {
+        const normalized = normalizeOwnerActions(parsed.actions);
+        if (normalized.length === 0 && hinted?.actions?.length) {
+          return {
+            reply: String(parsed.reply || hinted.reply || '收到，开始执行。').trim(),
+            actions: hinted.actions,
+          };
+        }
+        return {
+          reply: String(parsed.reply || '收到，开始执行。').trim(),
+          actions: normalized.length ? normalized : fallbackOwnerPlan(text).actions,
+        };
+      }
+    } catch { }
+    if (hinted) return hinted;
+    return fallbackOwnerPlan(text);
+  }
+
+  async function buildOwnerChatReply(text, intentHint = null) {
+    const rawText = String(text || '').trim();
+    if (!rawText) return '我在，刚刚没听清，你再说一遍。';
+
+    const hintObj = parseIntentHintObject(intentHint);
+    const hintSource = String(hintObj?.source || '').trim() || 'unknown';
+    const hintPage = String(hintObj?.page || '').trim() || '/';
+    const hintRoomId = String(hintObj?.roomId || '').trim() || 'none';
+    const hintAutopilot = !!hintObj?.autopilot;
+    const hintMode = String(hintObj?.messageMode || '').trim() || 'chat';
+    const currentState = currentRoomId
+      ? `在房间 ${currentRoomId} (${currentRoomMode || 'unknown'})，running=${currentRoomRunning}`
+      : '在大厅待机';
+    const activeRules = currentRoomRules || '无';
+    const factual = getFactualContext(12) || '（暂无）';
+    const installedSkills = listInstalledSkillNames(skillsRoot, 80);
+    const installedSkillPreview = installedSkills.length
+      ? installedSkills.slice(0, 12).join('、')
+      : '（暂无）';
+
+    // 高频短问优先走快速回复，避免每次都等待模型
+    if (/在吗|你在不在|还在吗/.test(rawText)) {
+      return currentRoomId ? `在，我在 ${currentRoomId}。` : '在，我在大厅待机。';
+    }
+    if (/你在干嘛|干什么|在做什么|现在状态|当前状态|汇报一下/.test(rawText)) {
+      if (autonomyEnabled) {
+        return currentRoomId
+          ? `我在 ${currentRoomId} 托管中，${currentRoomRunning ? '正在讨论' : '准备继续开局'}。`
+          : '我在大厅托管巡航中，正在找合适房间。';
+      }
+      return currentRoomId
+        ? `我现在在 ${currentRoomId}，${currentRoomRunning ? '讨论中' : '等待中'}。`
+        : '我现在在大厅待机。';
+    }
+    if (/谢谢|辛苦|好的|收到/.test(rawText)) {
+      return '收到，我继续保持在线。';
+    }
+    if (/会什么技能|技能列表|学会了什么|安装了什么技能/.test(rawText)) {
+      if (installedSkills.length === 0) return '当前还没有检测到已安装的自定义 Skill。';
+      return `我现在已安装 ${installedSkills.length} 个 Skill：${installedSkills.slice(0, 8).join('、')}${installedSkills.length > 8 ? ' 等。' : '。'}`;
+    }
+    if (/学会|会不会|有没有学|掌握/.test(rawText)) {
+      const matched = installedSkills.find((name) => rawText.includes(name));
+      if (matched) return `学会了，技能「${matched}」已经安装在本机。`;
+      if (installedSkills.length === 0) return '当前还没有检测到已安装的自定义 Skill。';
+      return `我这边检测到已安装 ${installedSkills.length} 个 Skill。你要我报具体列表的话，直接说“技能列表”。`;
+    }
+
+    const prompt = [
+      `你是 ${myName}，你正在“龙虾社区前端”的置顶消息框里和主人聊天。`,
+      '目标：像原版 UI 聊天一样自然回复，但要知道你在社区前端场景。',
+      '',
+      `当前状态：${currentState}`,
+      `当前房间规则：${activeRules}`,
+      `本机已安装自定义 Skill：${installedSkillPreview}`,
+      `前端上下文：source=${hintSource} page=${hintPage} roomId=${hintRoomId} autopilot=${hintAutopilot} mode=${hintMode}`,
+      '',
+      '回复规则：',
+      '1. 这是聊天回复，不是“执行报告”；避免模板句式如“收到主人指令/正在执行”。',
+      '2. 1-3句口语化中文，简短直接。',
+      '3. 主人问近况时，按真实状态回答你在哪里、在做什么。',
+      '4. 不要编造你没做过的动作，不要假装已完成未执行操作。',
+      '5. 如果主人表达了明确动作意图，只需自然确认一句，并建议直接下达动作命令（不要在本回复里伪造执行结果）。',
+      '',
+      `主人消息：${rawText}`,
+      '',
+      '你近期真实经历（仅供回忆，禁止编造）：',
+      factual,
+      '',
+      '请直接输出回复文本，不要 JSON，不要前缀。',
+    ].join('\n');
+
+    try {
+      const reply = String(await callAI(api, core, myName, prompt) || '').trim();
+      if (reply) return reply;
+    } catch { }
+
+    if (/在吗|你在不在/.test(rawText)) return '在，我在线。';
+    if (/你在干嘛|干什么|在做什么/.test(rawText)) {
+      return currentRoomId
+        ? `我现在在 ${currentRoomId}，${currentRoomRunning ? '讨论中' : '先待机观察中'}。`
+        : '我现在在大厅待机，随时可以动起来。';
+    }
+    return currentRoomId
+      ? `我在 ${currentRoomId}，你继续说，我能听懂。`
+      : '我在大厅待机，你继续说，我能听懂。';
+  }
+
+  async function executeOwnerCommand(text, roomsFromServer, commandId = '', intentHint = null) {
+    if (Array.isArray(roomsFromServer) && roomsFromServer.length > 0) {
+      availableRooms = roomsFromServer;
+    }
+    send({ type: 'bot_status', status: 'autonomy', text: '🧭 正在执行主人指令...', commandId });
+
+    const plan = await buildOwnerPlan(text, intentHint);
+    let actions = normalizeOwnerActions(plan.actions);
+    if (actions.length === 0) actions.push({ type: 'status' });
+    const rawText = String(text || '').trim();
+    const requestStopAutonomy = /停止托管|暂停托管|取消托管|结束托管|停止吧|停一下|先停|停下|别自主|不要自主|stop autonomy/i.test(rawText);
+    const requestStartAutonomy = !requestStopAutonomy
+      && (/自由活动|开启托管|开始托管|继续托管|恢复托管|自主|找乐子|auto/i.test(rawText) || actions.some((a) => a.type === 'auto_join'));
+    if (requestStopAutonomy) {
+      actions = actions.filter((a) => a.type !== 'auto_join');
+      if (!actions.some((a) => a.type === 'wait' || a.type === 'status')) {
+        actions.unshift({ type: 'wait' });
+      }
+    }
+    if (requestStopAutonomy) {
+      setAutonomyEnabled(false, '收到停止托管指令');
+    } else if (requestStartAutonomy) {
+      setAutonomyEnabled(true, '收到自由活动指令');
+    }
+
+    const logs = [];
+    const currentRoomInfo = () => (availableRooms || []).find((r) => r.id === currentRoomId);
+    const pushJoin = (roomId) => {
+      const rid = String(roomId || '').trim();
+      if (!rid) return;
+      send({ type: 'join_room', token, roomId: rid });
+      logs.push(`已请求加入房间 ${rid}`);
+    };
+    const queueStart = (roomId, rounds = 5, reason = '') => {
+      queueStartAfterJoin(roomId, rounds, reason);
+      logs.push(`已排队：进入 ${roomId} 后自动开始讨论（${rounds}轮）`);
+    };
+
+    for (const action of actions) {
+      const type = action?.type;
+
+      if (type === 'join_room') {
+        let targetRoomId = String(action.roomId || '').trim();
+        if (action.mode && ['evolution', 'roundtable', 'debate'].includes(action.mode)) {
+          autonomyState.mode = action.mode;
+        }
+        if (!targetRoomId && action.mode) {
+          targetRoomId = findRoomByMode(action.mode)?.id || '';
+        }
+        if (!targetRoomId) {
+          logs.push('未找到可加入的目标房间');
+          continue;
+        }
+        if (currentRoomId === targetRoomId) {
+          logs.push(`已在房间 ${targetRoomId}`);
+        } else {
+          pushJoin(targetRoomId);
+          rememberFact(`按主人指令加入房间 ${targetRoomId}`);
+        }
+        continue;
+      }
+
+      if (type === 'leave_room') {
+        if (!currentRoomId) {
+          logs.push('当前已在大厅');
+          continue;
+        }
+        send({ type: 'leave_room' });
+        rememberFact(`按主人指令离开房间 ${currentRoomId}`);
+        logs.push('已请求离开当前房间');
+        continue;
+      }
+
+      if (type === 'start_room') {
+        let targetRoomId = String(action.roomId || '').trim();
+        if (action.mode && ['evolution', 'roundtable', 'debate'].includes(action.mode)) {
+          autonomyState.mode = action.mode;
+        }
+        if (!targetRoomId && action.mode) targetRoomId = findRoomByMode(action.mode)?.id || '';
+        if (!targetRoomId) targetRoomId = currentRoomId || '';
+        if (!targetRoomId) {
+          logs.push('无法开始讨论：没有可用房间');
+          continue;
+        }
+
+        const rounds = Math.max(1, parseInt(action.maxRounds, 10) || 5);
+        if (currentRoomId === targetRoomId) {
+          const running = currentRoomRunning || !!currentRoomInfo()?.running;
+          if (running) {
+            logs.push(`房间 ${targetRoomId} 已在讨论中`);
+          } else {
+            send({ type: 'owner_admin', roomId: targetRoomId, token, action: 'toggle', maxRounds: rounds });
+            rememberFact(`按主人指令启动房间 ${targetRoomId} 讨论`);
+            logs.push(`已请求开始 ${targetRoomId} 讨论（${rounds}轮）`);
+          }
+        } else {
+          pushJoin(targetRoomId);
+          queueStart(targetRoomId, rounds, 'start_room');
+        }
+        continue;
+      }
+
+      if (type === 'stop_room') {
+        let targetRoomId = String(action.roomId || '').trim();
+        if (!targetRoomId && action.mode) targetRoomId = findRoomByMode(action.mode)?.id || '';
+        if (!targetRoomId) targetRoomId = currentRoomId || '';
+        if (!targetRoomId) {
+          logs.push('无法停止讨论：没有可用房间');
+          continue;
+        }
+        if (currentRoomId !== targetRoomId) {
+          logs.push(`当前不在房间 ${targetRoomId}，无法直接停止`);
+          continue;
+        }
+        if (!currentRoomRunning) {
+          logs.push(`房间 ${targetRoomId} 当前不是讨论中`);
+        } else {
+          send({ type: 'owner_admin', roomId: targetRoomId, token, action: 'toggle' });
+          rememberFact(`按主人指令停止房间 ${targetRoomId} 讨论`);
+          logs.push(`已请求停止 ${targetRoomId} 的讨论`);
+        }
+        continue;
+      }
+
+      if (type === 'wait') {
+        if (currentRoomId && currentRoomRunning) {
+          send({ type: 'owner_admin', roomId: currentRoomId, token, action: 'toggle' });
+          rememberFact(`进入等待：先停止 ${currentRoomId} 讨论`);
+          logs.push('已停止当前讨论，改为等待');
+        } else if (currentRoomId) {
+          logs.push(`留在房间 ${currentRoomId} 等待`);
+        } else {
+          logs.push('在大厅待机等待');
+        }
+        continue;
+      }
+
+      if (type === 'auto_join') {
+        const rounds = Math.max(1, parseInt(action.maxRounds, 10) || autonomyState.rounds || 5);
+        if (action.mode && ['evolution', 'roundtable', 'debate'].includes(action.mode)) {
+          autonomyState.mode = action.mode;
+        }
+        autonomyState.rounds = rounds;
+        setAutonomyEnabled(true, '收到自由活动指令');
+        await runAutonomyTick('owner_command');
+        logs.push(`已进入自由活动托管（模式=${autonomyState.mode}，轮数=${autonomyState.rounds}）`);
+        continue;
+      }
+
+      if (type === 'status') {
+        if (currentRoomId) {
+          logs.push(`当前在房间 ${currentRoomId}（${currentRoomMode || 'unknown'}）${currentRoomRunning ? '，讨论中' : '，等待中'}`);
+        } else {
+          logs.push('当前在大厅待机');
+        }
+      }
+    }
+
+    const reply = String(plan.reply || '收到，我会继续自主执行。').trim();
+    const detail = logs.length ? `\n${logs.map((s) => `- ${s}`).join('\n')}` : '';
+    send({ type: 'command_reply', text: `${reply}${detail}`, commandId });
+    if (autonomyEnabled) {
+      send({ type: 'bot_status', status: 'autonomy', text: '✅ 指令已下发，正在持续托管执行', commandId });
+    } else if (currentRoomId) {
+      send({ type: 'bot_status', status: 'in_room', text: `🎯 已处理指令，当前在 ${currentRoomId}`, commandId });
+    } else {
+      send({ type: 'bot_status', status: 'lobby', text: '☕ 已处理指令，当前在大厅待机', commandId });
+    }
+  }
+
+  async function handleMessage(msg) {
+
+    switch (msg.type) {
+      case "bot_ack":
+        // 在大厅待机中
+        if (msg.status === 'lobby') {
+          myName = msg.name || myName;
+          currentRoomId = null;
+          currentRoomMode = null;
+          currentRoomRunning = false;
+          currentRoomRules = '';
+          availableRooms = Array.isArray(msg.rooms) ? msg.rooms : availableRooms;
+          const ackOwnerToken = normalizeIdentityId(msg.ownerToken, 128);
+          if (ackOwnerToken && ackOwnerToken !== ownerToken) {
+            ownerToken = ackOwnerToken;
+            persistIdentity(token);
+            syncOpenClawConfigIfEnabled(ocHome, wsUrl, {
+              token,
+              ownerToken: ownerToken || undefined,
+              name: configuredName || undefined,
+            }, api.logger);
+          }
+          api.logger.info(
+            `[roundtable] 🦞 已连接大厅，待机中。可用房间: ${(msg.rooms || []).map(r => r.id).join(', ')}`
+          );
+          rememberFact('回到大厅待机');
+          send({ type: 'bot_status', status: 'lobby', text: '☕ 大厅待机中' });
+          if (autonomyEnabled) scheduleAutonomyTick(900);
+        } else if (msg.bot) {
+          myName = msg.bot.name;
+          api.logger.info(
+            `[roundtable] 🦞 入座成功！name=${myName} emoji=${msg.bot.emoji} id=${msg.bot.id}`
+          );
+        }
+        break;
+
+      case "joined_room":
+        currentRoomId = msg.room?.id || currentRoomId;
+        currentRoomMode = msg.room?.mode || currentRoomMode;
+        currentRoomRunning = !!msg.room?.running;
+        currentRoomRules = String(msg.room?.roomRules || '').trim();
+        api.logger.info(
+          `[roundtable] 🏠 已加入房间: ${msg.room?.name || msg.room?.id} (${msg.room?.mode})`
+        );
+        rememberFact(`加入房间 ${msg.room?.id || ''} (${msg.room?.mode || ''})`);
+        if (currentRoomId) {
+          const started = tryFlushPendingStart(currentRoomId);
+          if (started) {
+            send({ type: 'bot_status', status: 'autonomy', text: `▶️ 已在 ${currentRoomId} 触发自动开局` });
+          }
+        }
+        send({
+          type: 'bot_status',
+          status: 'in_room',
+          text: `🎯 已在 ${msg.room?.name || msg.room?.id || '房间'}`
+        });
+        if (autonomyEnabled) scheduleAutonomyTick(900);
+        break;
+
+      case "running_change":
+        if (currentRoomId) {
+          currentRoomRunning = !!msg.running;
+          rememberFact(`${currentRoomId} 状态变更：${currentRoomRunning ? '讨论中' : '等待中'}`);
+          if (autonomyEnabled && !currentRoomRunning) scheduleAutonomyTick(1200);
+        }
+        break;
+
+      // Channel 模式统一 prompt 分发（含进化室选 Skill）
+      case "prompt": {
+        const turnContext = String(msg.turnContext || '').trim();
+        const promptText = String(msg.text || '').trim();
+        if (!promptText) {
+          send({ type: 'bot_reply', text: '' });
+          break;
+        }
+        if (turnContext === 'pick_skill') {
+          await handlePickSkillRequest(msg, 'prompt');
+          break;
+        }
+        try {
+          const timeoutMs = turnContext === 'evo_review'
+            ? 22000
+            : (turnContext === 'evo_share' || turnContext === 'evo_experience')
+              ? 42000
+              : (turnContext === 'host_comment' ? 15000 : (turnContext === 'host_summary' ? 45000 : 65000));
+          const reply = await callAIWithTimeout(promptText, timeoutMs, `prompt_${turnContext || 'generic'}`);
+          send({ type: 'bot_reply', text: String(reply || '') });
+          if (reply) rememberFact(`频道提示(${turnContext || 'generic'})已响应`);
+        } catch (err) {
+          api.logger.error(`[roundtable] prompt(${turnContext || 'generic'}) 失败: ${err.message}`);
+          if (turnContext === 'evo_vote') {
+            send({ type: 'bot_reply', text: '不通过' });
+          } else {
+            send({ type: 'bot_reply', text: '' });
+          }
+        }
+        break;
+      }
+
+      case "your_turn":
+        api.logger.info(
+          `[roundtable] 轮到我发言，topic: ${msg.topic}`
+        );
+        send({ type: 'bot_status', status: 'speaking', text: `🧠 正在思考：${msg.topic || ''}` });
+        try {
+          const reply = await generateReply(
+            api,
+            core,
+            myName,
+            persona,
+            maxTokens,
+            msg,
+            getFactualContext(10)
+          );
+          if (reply) {
+            send({ type: "bot_reply", text: reply });
+            api.logger.info(
+              `[roundtable] ✅ 已发言: ${reply.slice(0, 60)}...`
+            );
+            rememberFact(`房间发言：${reply.slice(0, 80)}`);
+          } else {
+            send({ type: "bot_reply", text: "" });
+            api.logger.warn("[roundtable] AI 返回空内容，跳过本轮");
+            send({ type: 'bot_status', status: 'idle', text: '⚪ 本轮空回复' });
+          }
+        } catch (err) {
+          api.logger.error(
+            `[roundtable] AI 调用失败: ${err.message}`
+          );
+          send({ type: "bot_reply", text: "" });
+          send({ type: 'bot_status', status: 'error', text: `❌ AI 调用失败: ${err.message}` });
+        }
+        break;
+
+      // ── 进化室：服务器要求选一个 Skill 来分享 ──
+      case "pick_skill": {
+        api.logger.info("[roundtable] 🧬 收到 pick_skill，进入快速选 Skill 流程...");
+        await handlePickSkillRequest(msg, 'pick_skill');
+        break;
+      }
+
+      // ── 进化室：选择的 Skill 被服务器驳回（重复） ──
+      case "skill_rejected": {
+        const rejName = msg.skillName;
+        api.logger.warn(`[roundtable] 🧬 Skill "${rejName}" 被驳回: ${msg.reason}`);
+        rejectedSkills.add(rejName);
+
+        // 从缓存列表里排除已驳回的
+        const remaining = (cachedSkillList || []).filter((s) => !isRejectedSkillName(s));
+
+        if (remaining.length === 0) {
+          api.logger.warn('[roundtable] 所有 Skill 都已被驳回，改为经验分享');
+          send({ type: 'skill_picked', noSkill: true, reason: 'experience' });
+        } else {
+          const next = remaining[0];
+          api.logger.info(`[roundtable] 🧬 改选: ${next}`);
+          try {
+            const chineseName = await translateSkillNameToChinese(next);
+            const finalSkillName = chineseName
+              ? (chineseName === next ? chineseName : `${chineseName}（${next}）`)
+              : next;
+            const descPrompt = [
+              `请输出可审核、可复用的 Skill 分享稿。`,
+              `Skill：${next}（中文名建议：${chineseName || next}）`,
+              `只讲真实实践，不要编造，不要空话。`,
+              `格式：`,
+              `【Skill名称】中文名（英文名）`,
+              `① 解决痛点 ② 核心步骤 ③ 实战案例 ④ 边界与风险`,
+              `全中文，180字以内。`,
+            ].join('\n');
+            const descReply = await callAI(api, core, myName, descPrompt);
+            rememberFact(`改选分享 Skill：${finalSkillName}`);
+            send({ type: 'skill_picked', skillName: finalSkillName, skillContent: descReply || `Skill: ${finalSkillName}` });
+          } catch {
+            send({ type: 'skill_picked', skillName: next, skillContent: `Skill: ${next}` });
+          }
+        }
+        break;
+      }
+
+      // ── 进化室：投票阶段 ──
+      case "evo_phase": {
+        if (msg.phase === "VOTING") {
+          api.logger.info(
+            `[roundtable] 🗳 进入投票阶段: ${msg.skillName}`
+          );
+          try {
+            const votePrompt = [
+              `你是 ${myName}，刚听完 Skill「${msg.skillName}」的介绍和评审讨论。`,
+              `请做严格评审，宁可错杀也不要放过低质 Skill。`,
+              `只有同时满足以下条件才允许通过：`,
+              `A. 不是系统内置/通用能力，具备独特性`,
+              `B. 介绍具体可执行，并包含真实案例`,
+              `C. 对他人可复用，收益明显且风险可控`,
+              `任一条件不满足 -> 不通过。`,
+              `只需回复 "通过" 或 "不通过"，不要回复其他内容。`,
+            ].join("\n");
+            const voteReply = await callAI(api, core, myName, votePrompt);
+            const decision = String(voteReply || '').trim();
+            const rejected = /不通过|否决|拒绝|不建议/.test(decision);
+            const approve = !rejected && /通过/.test(decision);
+            send({ type: "vote", approve });
+            api.logger.info(
+              `[roundtable] 🗳 投票: ${approve ? "✅ 通过" : "❌ 不通过"} | decision=${decision.slice(0, 40)}`
+            );
+          } catch (err) {
+            api.logger.error(
+              `[roundtable] 投票 AI 调用失败: ${err.message}，默认不通过`
+            );
+            send({ type: "vote", approve: false });
+          }
+        }
+        break;
+      }
+
+      // ── 服务器推送 Skill 安装（观众点击"学习"后触发） ──
+      case "install_skill": {
+        const requestId = (msg.requestId || '').trim();
+        const skillName = String(msg.skillName || '').trim();
+        const safeSkillName = sanitizeSkillDirName(skillName);
+        try {
+          const fsNode = require('fs');
+          const cryptoNode = require('crypto');
+          if (!safeSkillName) throw new Error('invalid_skill_name');
+          const body = String(msg.content || '');
+          if (!body.trim()) throw new Error('empty_skill_content');
+          const skillDir = pathModule.join(skillsRoot, safeSkillName);
+          const filePath = pathModule.join(skillDir, 'SKILL.md');
+          fsNode.mkdirSync(skillDir, { recursive: true });
+          fsNode.writeFileSync(filePath, body, 'utf-8');
+          const bytes = Buffer.byteLength(body, 'utf-8');
+          const contentHash = cryptoNode.createHash('sha256').update(body).digest('hex');
+          const shortHash = contentHash.slice(0, 16);
+          const installedSkills = listInstalledSkillNames(skillsRoot, 200);
+          api.logger.info(`[roundtable] 📥 已自动安装 Skill: ${skillName} → ${skillDir}`);
+          send({
+            type: 'bot_learned_skill',
+            skillName: skillName || safeSkillName,
+            skillDirName: safeSkillName,
+            skillNames: installedSkills,
+            requestId,
+            installedPath: filePath,
+            bytes,
+            contentHash
+          });
+          send({
+            type: 'command_reply',
+            text: `✅ 我已学会 Skill「${skillName || safeSkillName}」，可直接调用。(${shortHash})`,
+            commandId: `learn_ack_${requestId || Date.now()}`
+          });
+          rememberFact(`学习 Skill：${skillName || safeSkillName}`);
+        } catch (err) {
+          api.logger.error(`[roundtable] 安装 Skill 失败: ${err.message}`);
+          send({ type: 'bot_learn_skill_failed', skillName: skillName || safeSkillName || msg.skillName, requestId, error: err.message });
+        }
+        break;
+      }
+
+      // ── 置顶消息框：主人给龙虾的自然语言自主指令 ──
+      case "owner_command": {
+        const text = (msg.text || '').trim();
+        const commandId = (msg.commandId || '').trim();
+        const source = String(msg.source || 'server');
+        const incomingRules = String(msg.roomRules || '').trim();
+        if (incomingRules || msg.roomId) currentRoomRules = incomingRules;
+        if (!text) {
+          send({ type: 'command_reply', text: '⚠️ 收到空指令，请再说具体一点。', commandId });
+          break;
+        }
+        api.logger.info(`[roundtable] 🤖 主人指令(${source}): ${text}`);
+        rememberFact(`主人(${source})指令：${text.slice(0, 120)}`);
+        await executeOwnerCommand(text, msg.rooms, commandId, msg.intentHint || null);
+        break;
+      }
+
+      // ── 置顶消息框：主人与龙虾自然语言聊天（非动作链） ──
+      case "owner_chat": {
+        const text = (msg.text || '').trim();
+        const commandId = (msg.commandId || '').trim();
+        const source = String(msg.source || 'server');
+        const incomingRules = String(msg.roomRules || '').trim();
+        if (incomingRules || msg.roomId) currentRoomRules = incomingRules;
+        if (!text) {
+          send({ type: 'command_reply', text: '⚠️ 收到空消息，你再说具体一点。', commandId });
+          break;
+        }
+        if (Array.isArray(msg.rooms) && msg.rooms.length > 0) {
+          availableRooms = msg.rooms;
+        }
+        api.logger.info(`[roundtable] 💬 主人聊天(${source}): ${text}`);
+        rememberFact(`主人(${source})聊天：${text.slice(0, 120)}`);
+        const reply = await buildOwnerChatReply(text, msg.intentHint || null);
+        send({ type: 'command_reply', text: reply, commandId });
+        break;
+      }
+
+      case "error":
+        {
+          const msgText = String(msg.msg || "");
+          const errCode = String(msg.code || "").trim();
+          api.logger.error(`[roundtable] 服务器错误: ${msgText}`);
+          reportDiag("server_error_message", {
+            level: "warn",
+            message: msgText,
+            detail: { code: errCode || undefined },
+          }, 2000);
+
+          const isTokenConflict =
+            errCode === "token_in_use" ||
+            errCode === "token_bound_to_other_instance" ||
+            msgText.includes("其他 OpenClaw 实例占用") ||
+            msgText.includes("绑定到其他 OpenClaw 实例");
+
+          if (isTokenConflict) {
+            // 熔断器检查：防止无限冲突重试循环
+            if (shouldBreakConflict()) {
+              api.logger.error("[roundtable] 🚨 Token 冲突已触发熔断保护，暂停自愈重试");
+              scheduleReconnect(conflictBreaker.cooldownMs);
+              break;
+            }
+            api.logger.warn("[roundtable] ⚠️ 检测到 token 被其他实例占用，开始分配独立 token...");
+            reportDiag("token_conflict_recovering", {
+              level: "warn",
+              message: "token in use, rotate instance and request fresh token",
+            }, 0);
+            tryAutoRegisterRecover("token_conflict", { rotateInstance: true, forceNewToken: true });
+            break;
+          }
+
+          const isTokenInvalid =
+            errCode === "token_invalid" ||
+            (msgText.includes("Token") && msgText.includes("无效"));
+
+          if (isTokenInvalid) {
+            api.logger.info("[roundtable] 🔄 Token 无效，尝试自动修复注册...");
+            reportDiag("token_invalid_recovering", {
+              level: "warn",
+              message: "token invalid, try auto-register",
+            }, 0);
+            tryAutoRegisterRecover("token_invalid", {
+              forceNewToken: false,
+              preferredToken: token || String(cfg.token || "").trim(),
+            });
+          }
+        }
+        break;
+    }
+  }
+
+  function send(data) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(data));
+    }
+  }
+
+  connect();
+
+  // 返回 stop 函数，供 Gateway 生命周期管理
+  return {
+    stop() {
+      api.logger.info("[roundtable] 正在停止...");
+      stopping = true; // 必须在 ws.close() 之前设置，阻止 onclose 重连
+      // 停止自主托管
+      if (autonomyTimer) { clearInterval(autonomyTimer); autonomyTimer = null; }
+      autonomyEnabled = false;
+      // 停止心跳
+      if (heartbeatTimer) { clearInterval(heartbeatTimer); }
+      // 停止重连
+      if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
+      // 关闭 WS
+      if (ws) {
+        try { ws.close(1000, "shutdown"); } catch { }
+        ws = null;
+      }
+      // 清理状态
+      currentRoomId = null;
+      currentRoomMode = null;
+      currentRoomRunning = false;
+      reportDiag("plugin_stop", { message: "plugin stopped by gateway" }, 0);
+      api.logger.info("[roundtable] 已停止");
+    },
+  };
+}
+
+/**
+ * 构建圆桌讨论的系统提示词
+ * 核心：让 AI 像真人群聊一样说话
+ */
+function buildSystemPrompt(myName, persona, topic, roomMode) {
+  const wordLimit = roomMode === "debate" ? 150
+    : roomMode === "evolution" ? 120 : 80;
+  const lines = [
+    `你是"${myName}"，在一个群聊里和朋友讨论。`,
+  ];
+  const profile = String(persona || "").trim();
+  if (profile) lines.push(`你的性格：${profile}`);
+  lines.push(
+    `话题：${topic}`,
+    ``,
+    `说话规则：`,
+    `- 2-3句话说完，别超过${wordLimit}字`,
+    `- 像朋友聊天一样说话，别写作文`,
+    `- 直接回应别人，可以点名：「XX说得对」「不同意XX」`,
+    `- 可以赞同、反驳、吐槽、追问`,
+    `- 不要用**加粗**、列表、「」引号、——破折号`,
+    `- 不要说"作为AI"这种话`,
+    `- 别复读前面的人说过的话`,
+  );
+  return lines.join("\n");
+}
+
+/**
+ * 将消息历史转为结构化对话格式
+ */
+function buildConversationBody(myName, history, topic) {
+  if (!history || history.length === 0) {
+    return `群聊开始了，话题：${topic}\n你先开个头吧，简短点。`;
+  }
+
+  const lines = [];
+  for (const h of history) {
+    lines.push(`${h.name}: ${h.text}`);
+  }
+  lines.push(`\n轮到你(${myName})说了，简短回应上面的对话。`);
+  return lines.join("\n");
+}
+
+/**
+ * 解析服务器的 context 字符串数组为 {name, text} 对象
+ * 输入格式: ["[萌萌(🧠)]: 发言内容", "[观众 小明]: 观众发言"]
+ */
+function parseContext(context) {
+  if (!Array.isArray(context) || context.length === 0) return [];
+  return context.map((line) => {
+    // 匹配 [名字(emoji)] 或 [观众 名字]
+    const m = line.match(/^\[(.+?)\]:\s*(.+)$/s);
+    if (m) {
+      // 去掉 emoji 括号部分，如 "萌萌(🧠)" -> "萌萌"
+      const rawName = m[1].replace(/\(.+?\)$/, "").replace(/^观众\s*/, "观众·").trim();
+      return { name: rawName, text: m[2].trim() };
+    }
+    return { name: "未知", text: line };
+  });
+}
+
+/**
+ * Gateway HTTP API 调用 AI（从 connector-template 已验证路径移植）
+ * 优点：不依赖任何内部 API，兼容所有 OpenClaw 版本
+ */
+function callAIViaHTTP(prompt, maxTokens = 500, timeoutMs = 45000) {
+  return new Promise((resolve, reject) => {
+    const OC_PORT = parseInt(process.env.OPENCLAW_PORT || '18789', 10);
+    const OC_TOKEN = String(process.env.OPENCLAW_API_TOKEN || process.env.OPENCLAW_TOKEN || '').trim();
+    const body = JSON.stringify({
+      model: 'default',
+      messages: [{ role: 'user', content: String(prompt || '') }],
+      max_tokens: Math.max(50, parseInt(maxTokens, 10) || 500),
+    });
+
+    const req = httpModule.request({
+      hostname: '127.0.0.1',
+      port: OC_PORT,
+      path: '/v1/chat/completions',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+        ...(OC_TOKEN ? { Authorization: `Bearer ${OC_TOKEN}` } : {}),
+      },
+      timeout: Math.max(5000, timeoutMs),
+    }, (res) => {
+      let data = '';
+      res.on('data', (c) => (data += c));
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          const text = json.choices?.[0]?.message?.content || '';
+          resolve(String(text).trim());
+        } catch {
+          resolve('');
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(new Error(`HTTP AI call failed: ${err.message}`)));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`HTTP AI call timeout (${timeoutMs}ms)`));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * 通过 runtime 内部管线调 AI（优先路径，在支持的 OpenClaw 版本上使用）
+ */
+async function callAIViaRuntime(api, core, prompt, sessionLabel = '龙虾圆桌', senderName = '圆桌主持人', senderId = 'roundtable-host') {
+  const sessionKey = `roundtable:${senderId}`;
+  const timestamp = Date.now();
+
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: prompt,
+    RawBody: prompt,
+    CommandBody: prompt,
+    From: `${CHANNEL_ID}:server`,
+    To: `${CHANNEL_ID}:bot`,
+    SessionKey: sessionKey,
+    ChatType: "direct",
+    ConversationLabel: sessionLabel,
+    SenderName: senderName,
+    SenderId: senderId,
+    Provider: CHANNEL_ID,
+    Surface: CHANNEL_ID,
+    MessageSid: `rt-${timestamp}`,
+    Timestamp: timestamp,
+    OriginatingChannel: CHANNEL_ID,
+    OriginatingTo: `${CHANNEL_ID}:bot`,
+    CommandAuthorized: true,
+  });
+
+  let fullReply = "";
+
+  await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg: api.config,
+    dispatcherOptions: {
+      deliver: async (payload) => {
+        const text =
+          typeof payload?.text === "string" ? payload.text.trim() : "";
+        if (text) {
+          fullReply += (fullReply ? "\n" : "") + text;
+        }
+      },
+      onError: (err, info) => {
+        api.logger.error(
+          `[roundtable] dispatch ${info.kind} 失败: ${String(err)}`
+        );
+      },
+    },
+  });
+
+  return fullReply.trim();
+}
+
+/**
+ * 核心 AI 调用：优先 runtime API → 降级 HTTP API
+ * 构造圆桌讨论的完整 prompt，让 Gateway 用用户配置的 AI 模型生成回复
+ */
+async function generateReply(api, core, myName, persona, maxTokens, msg, factualContext = '') {
+  // 兼容服务器字段：可能是 msg.history 或 msg.context
+  const rawHistory = msg.history || parseContext(msg.context);
+  let systemPrompt = buildSystemPrompt(myName, persona, msg.topic, msg.roomMode);
+  // 融合服务器下发的模式/角色提示（辩论正反方、进化评审等）
+  if (msg.modePrompt) {
+    systemPrompt += "\n\n" + msg.modePrompt;
+  }
+  const userMessage = buildConversationBody(myName, rawHistory, msg.topic);
+  const memoryBlock = String(factualContext || '').trim()
+    ? `\n\n【你的近期真实经历（仅供回忆，严禁编造）】\n${String(factualContext || '').trim()}\n`
+    : '';
+
+  const fullPrompt = `${systemPrompt}${memoryBlock}\n\n---\n\n${userMessage}`;
+
+  // 优先 runtime API → 降级 HTTP API
+  const hasRuntime = !!(core?.channel?.reply?.finalizeInboundContext &&
+    core?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher);
+
+  if (hasRuntime) {
+    try {
+      return await callAIViaRuntime(api, core, fullPrompt, '龙虾圆桌', '圆桌主持人', 'roundtable-host');
+    } catch (err) {
+      api.logger.warn(`[roundtable] runtime API 调用失败，降级 HTTP: ${err.message}`);
+    }
+  }
+
+  return await callAIViaHTTP(fullPrompt, maxTokens || 500, 65000);
+}
+
+/**
+ * 精简版 AI 调用：给一个 prompt，拿一个回复
+ * 用于进化室选 Skill 等不需要完整对话上下文的场景
+ * 优先 runtime API → 降级 HTTP API
+ */
+async function callAI(api, core, myName, prompt) {
+  const hasRuntime = !!(core?.channel?.reply?.finalizeInboundContext &&
+    core?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher);
+
+  if (hasRuntime) {
+    try {
+      return await callAIViaRuntime(api, core, prompt, '龙虾圆桌·选Skill', '进化室', 'evo-room');
+    } catch (err) {
+      api.logger.warn(`[roundtable] callAI runtime 失败，降级 HTTP: ${err.message}`);
+    }
+  }
+
+  return await callAIViaHTTP(prompt, 500, 30000);
+}