botmux 2.9.0 → 2.9.2

package/dist/cli.js

@@ -14,14 +14,26 @@
  *   botmux list --plain   — plain table output (for piping / scripts)
  *   botmux delete <id>    — close a session by ID prefix
  *   botmux delete all     — close all active sessions
+ *   botmux autostart enable|disable|status — manage boot-time autostart (launchd / user systemd)
  */
 import { execSync, spawnSync, spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdirSync, readlinkSync } from 'node:fs';
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, renameSync, readdirSync, readlinkSync, appendFileSync, statSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
 import { createRequire } from 'node:module';
+import { createHmac, randomBytes } from 'node:crypto';
+import { enableAutostart, disableAutostart, autostartStatus, refreshAutostart } from './autostart.js';
+import { tmuxEnv } from './setup/ensure-tmux.js';
+import { writeBotsJsonAtomic as writeBotsAtomic } from './setup/bots-store.js';
+import { logger } from './utils/logger.js';
+import { firstPositional } from './cli/arg-utils.js';
+// CLI subcommands (send/thread/bots/list/etc) print JSON to stdout for
+// callers to parse. Transitive logger.info calls from shared modules would
+// corrupt that stream, so the CLI process runs silent by default. DEBUG=1
+// re-enables logging end-to-end for CLI troubleshooting.
+logger.setSilent(true);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const require = createRequire(import.meta.url);
@@ -106,6 +118,21 @@ function ecosystemConfig() {
         out_file: join(LOG_DIR, `daemon-${i}-out.log`),
         env: { SESSION_DATA_DIR: DATA_DIR, BOTMUX_BOT_INDEX: String(i) },
     }));
+    apps.push({
+        name: 'botmux-dashboard',
+        script: join(PKG_ROOT, 'dist', 'dashboard.js'),
+        cwd: PKG_ROOT,
+        autorestart: true,
+        max_restarts: 10,
+        restart_delay: 3000,
+        error_file: join(LOG_DIR, 'dashboard-error.log'),
+        out_file: join(LOG_DIR, 'dashboard-out.log'),
+        merge_logs: true,
+        env: {
+            BOTMUX_DASHBOARD_HOST: process.env.BOTMUX_DASHBOARD_HOST ?? '0.0.0.0',
+            BOTMUX_DASHBOARD_PORT: process.env.BOTMUX_DASHBOARD_PORT ?? '7891',
+        },
+    });
     const cfg = { apps };
     const tmpFile = join(CONFIG_DIR, 'ecosystem.config.json');
     writeFileSync(tmpFile, JSON.stringify(cfg, null, 2));
@@ -118,32 +145,211 @@ function ask(rl, question) {
     return new Promise(resolve => rl.question(question, resolve));
 }
 // ─── Setup helpers ──────────────────────────────────────────────────────────
-function printLarkPermissions() {
-    console.log('请先在飞书开放平台创建应用: https://open.feishu.cn/app\n');
-    console.log('需要的权限:');
-    console.log('  - im:message (发送/接收消息)');
-    console.log('  - im:message.group_at_msg (群消息)');
-    console.log('  - im:resource (文件下载)');
-    console.log('  - im:chat (群信息)');
-    console.log('  - contact:user.base:readonly (用户信息)\n');
-    console.log('启用事件订阅 (WebSocket 模式):');
-    console.log('  - im.message.receive_v1');
-    console.log('  - card.action.trigger\n');
+// Thin wrapper around setup/bots-store.writeBotsJsonAtomic so call-sites keep
+// the same name without passing BOTS_JSON_FILE explicitly each time.
+function writeBotsJsonAtomic(bots) {
+    writeBotsAtomic(BOTS_JSON_FILE, bots);
+}
+/**
+ * 从 bot 配置里取 brand. 旧的 bots.json (1.0 之前) 没这个字段, default 到 feishu
+ * 保留向后兼容. cmdStart 凭证校验 + printRemainingSteps 深链都靠它选 host.
+ */
+function botBrand(b) {
+    return b?.brand === 'lark' ? 'lark' : 'feishu';
+}
+/**
+ * 把 botmux 推荐的完整 scope JSON (从 src/setup/lark-scopes.json) 写到
+ * 用户配置目录, 同时给出跨平台一键复制命令. JSON 长 (293 项, 297 行),
+ * terminal 直接打印用户也复制不了, 写文件 + pbcopy/xclip 才是顺手的姿势.
+ *
+ * Returns: 写出的 JSON 文件绝对路径.
+ */
+function writeScopesJsonToConfigDir() {
+    // build script 会把 src/setup/lark-scopes.json copy 到 dist/setup/.
+    // dist 模式下 __dirname 是 dist/, 找 ./setup/lark-scopes.json; dev (tsx)
+    // 模式找 src/setup/lark-scopes.json 在源码同目录也成立.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const srcCandidates = [
+        join(here, 'setup', 'lark-scopes.json'),
+        join(here, '..', 'src', 'setup', 'lark-scopes.json'),
+    ];
+    let scopesPath = srcCandidates[0];
+    for (const p of srcCandidates) {
+        if (existsSync(p)) {
+            scopesPath = p;
+            break;
+        }
+    }
+    const destPath = join(CONFIG_DIR, 'lark-scopes.json');
+    copyFileSync(scopesPath, destPath);
+    return destPath;
+}
+function printCopyHint(filePath) {
+    // 环境感知: SSH/headless 没有 X server, xclip 一定报 "Can't open display".
+    // 这种场景下"剪贴板"在用户本地 (运行 SSH 客户端的那台机器), 远程机上能做的:
+    //   - 直接 cat, 让用户在本地 terminal 鼠标选中 (SSH 选中即写本地剪贴板)
+    //   - OSC 52: terminal app 代写本地剪贴板, iTerm2 / kitty / WezTerm /
+    //     Alacritty / tmux 1.5+ 都支持, gnome-terminal / Terminal.app 不支持
+    // 检测 DISPLAY (X11) 或 WAYLAND_DISPLAY 都没有, 或 SSH_* 环境变量存在
+    // → 当作 SSH 场景, 不推荐 xclip / pbcopy.
+    const isSsh = !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY);
+    const hasLocalGui = !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY) && !isSsh;
+    const isMacLocal = process.platform === 'darwin' && !isSsh;
+    console.log('  把 JSON 内容拷到本地剪贴板, 然后到飞书"批量导入/导出权限"页粘贴:');
+    if (isMacLocal) {
+        console.log(`    macOS 本地:  cat ${filePath} | pbcopy`);
+    }
+    else if (hasLocalGui) {
+        console.log(`    Linux 本地 (X 服务器):  cat ${filePath} | xclip -selection clipboard`);
+    }
+    else {
+        // SSH / headless: 鼠标选中是最稳的, OSC 52 作为高级选项
+        console.log(`    SSH 终端鼠标选中复制:  cat ${filePath}`);
+        console.log('       (终端把选中的字符直接写到你本地剪贴板, 不依赖远端剪贴板工具)');
+        console.log(`    或 OSC 52 (兼容 iTerm2 / kitty / WezTerm / Alacritty / tmux 1.5+):`);
+        console.log(`       base64 -w0 < ${filePath} | awk 'BEGIN{printf "\\033]52;c;"}{printf "%s",$0}END{printf "\\a"}'`);
+    }
+    console.log('');
 }
+function printRemainingSteps(appId, brand) {
+    // PersonalAgent 应用扫码建出来时已默认订阅 im.message.receive_v1 +
+    // card.action.trigger, 并开通 bot 能力, 主线只剩两步: 申请权限 + 重定向
+    // URL (按需). README "Step 8 收不到消息时" 段提供 fallback 自查链接.
+    const host = brand === 'lark' ? 'open.larksuite.com' : 'open.feishu.cn';
+    const home = `https://${host}/app/${appId}`;
+    let scopesJsonPath = '';
+    try {
+        scopesJsonPath = writeScopesJsonToConfigDir();
+    }
+    catch (err) {
+        // 不应阻止 setup 完成, 只 WARN
+        console.log(`\n⚠️  写权限 JSON 失败 (${err.message}), 请手动从仓库源码 src/setup/lark-scopes.json 拷.`);
+    }
+    console.log('\n剩余两步在开放平台完成:\n');
+    console.log('  1. 申请权限 (一次性导入完整 JSON 提交审批)');
+    console.log(`     申请链接: ${home}/auth → 进入「权限管理」→「批量导入/导出权限」→ 粘贴 → 提交`);
+    if (scopesJsonPath) {
+        console.log(`     权限 JSON: ${scopesJsonPath}`);
+        printCopyHint(scopesJsonPath);
+    }
+    console.log('');
+    console.log('  2. 添加重定向 URL (用于 botmux 内 `/login` 拿用户 UAT 获取卡片消息)');
+    console.log(`     申请链接: ${home}/safe → 进入「安全设置」→「重定向 URL」`);
+    console.log('     填入: http://127.0.0.1:9768/callback');
+    console.log('     不需要 `/login` 拿卡片消息的话, 这一步可以跳过.\n');
+    console.log('  完成后 `botmux start` (或 `botmux restart`)，启动检查不会卡住，');
+    console.log('  缺权限只 WARN，去开放平台补齐后 daemon 自动恢复。\n');
+}
+/**
+ * 让用户选"扫码建应用"还是"手动粘 AppID/Secret".
+ *
+ * 默认走扫码: 调 SDK `registerApp` → 拿 client_id/client_secret. 失败 (用户拒绝/
+ * 超时/网络/取消) 一律降级到手动, 不阻塞流程.
+ *
+ * Codex review 边界:
+ * - secret 不进 argv / 日志 / 错误链 (registerApp 内部 safeMsg 已做; 手动模式下
+ *   AppSecret 通过 rl.question 异步读取, 不会出现在 process.argv)
+ * - 任何失败都返回结构化对象, 不抛 (调用方根据 ok=false 回退)
+ */
+async function obtainCredentials(rl) {
+    console.log('── 飞书应用建立 ──\n');
+    console.log('1) 扫码建应用（推荐，一步拿到 AppID/Secret，需要飞书 App 扫码）');
+    console.log('2) 手动粘 AppID/Secret（已经在开放平台创建好应用了）\n');
+    const choice = (await ask(rl, '选择 [1]: ')).trim();
+    if (choice !== '2') {
+        // 动态导入避免冷启动加载 SDK
+        const { tryRegisterApp } = await import('./setup/register-app.js');
+        const result = await tryRegisterApp();
+        if (result.ok) {
+            // Lark 国际版需要 daemon 链路全程走 larksuite.com 域 (Client domain /
+            // WSClient / event-dispatcher 的 fetch URL / scope 深链 host). 当前
+            // botmux runtime 这几处都硬编码 feishu.cn, 所以即使扫码成功了也无法
+            // 真正跑起来. 干净做法是 setup 阶段就拒绝, 让用户用 feishu 租户. 单
+            // 独 PR 完整接入 lark 后再去掉这个分支.
+            if (result.brand === 'lark') {
+                console.log(`\n❌ 检测到 Lark 国际版 (larksuite.com) 租户。`);
+                console.log(`   botmux 当前 daemon 运行链路仅支持飞书 (feishu.cn) 租户,`);
+                console.log(`   Lark 国际版完整接入会在单独 PR 跟进 (BotConfig / Client domain /`);
+                console.log(`   WSClient / event-dispatcher 等需要一并支持).`);
+                console.log(`   请用飞书 (feishu.cn) 租户重试 setup。\n`);
+                return { ok: false, reason: 'lark_unsupported' };
+            }
+            console.log(`\n✅ 应用创建成功`);
+            console.log(`   App ID: ${result.appId}`);
+            console.log(`   租户类型: ${result.brand}`);
+            if (result.userOpenId) {
+                console.log(`   扫码人 open_id: ${result.userOpenId}（将默认作为 allowedUsers）`);
+            }
+            return {
+                ok: true,
+                appId: result.appId,
+                appSecret: result.appSecret,
+                brand: result.brand,
+                userOpenId: result.userOpenId,
+            };
+        }
+        console.log(`\n⚠️  扫码失败 (${result.error}): ${result.message}`);
+        if (result.error === 'aborted') {
+            // 用户主动取消整个 setup, 不再问手动 fallback
+            return { ok: false, reason: 'cancelled' };
+        }
+        console.log('   降级到手动输入 AppID/Secret。\n');
+    }
+    else {
+        console.log('\n请在浏览器打开 https://open.feishu.cn/app 创建应用，然后回来粘 ID/Secret。\n');
+    }
+    // 手动 fallback. 不再提问租户类型 — 当前 daemon runtime 只支持 feishu,
+    // 让用户选 lark 是误导. 等 lark 完整接入再加回来.
+    const appId = (await ask(rl, 'AppID (cli_xxx): ')).trim();
+    const appSecret = (await ask(rl, 'AppSecret: ')).trim();
+    if (!appId || !appSecret) {
+        console.log('\n❌ AppID/AppSecret 不能为空，setup 中止。');
+        return { ok: false, reason: 'cancelled' };
+    }
+    return { ok: true, appId, appSecret, brand: 'feishu' };
+}
+/**
+ * 收集一个机器人完整配置 (凭证 + CLI/工作目录/allowedUsers).
+ *
+ * 顺序: 拿凭证 → tenant_access_token 验证 → 通过才返回 bot 对象. 验证失败
+ * 直接返回 null, 调用方负责"不写 bots.json". Codex review 边界 #2.
+ */
 async function promptBotConfig(rl) {
-    const appId = await ask(rl, 'LARK_APP_ID: ');
-    const appSecret = await ask(rl, 'LARK_APP_SECRET: ');
-    console.log('\n支持的 CLI: 1) claude-code  2) aiden  3) coco  4) codex  5) gemini  6) opencode');
+    const creds = await obtainCredentials(rl);
+    if (!creds.ok)
+        return null;
+    // 凭证立刻验证. 通不过不写 bots.json.
+    console.log('\n校验凭证（取 tenant_access_token）…');
+    const { validateCredentials } = await import('./setup/verify-permissions.js');
+    const v = await validateCredentials(creds.appId, creds.appSecret, creds.brand);
+    if (!v.ok) {
+        console.log(`\n❌ 凭证校验失败 (${v.error}): ${v.message}`);
+        console.log('   不写 bots.json。请重新运行 botmux setup。');
+        return null;
+    }
+    console.log('✅ 凭证有效（tenant_access_token 已成功获取）\n');
+    console.log('支持的 CLI: 1) claude-code  2) aiden  3) coco  4) codex  5) gemini  6) opencode');
     const cliChoice = await ask(rl, 'CLI 适配器 [1]: ');
     const cliIdMap = { '1': 'claude-code', '2': 'aiden', '3': 'coco', '4': 'codex', '5': 'gemini', '6': 'opencode' };
     const cliId = cliIdMap[cliChoice] ?? (cliChoice || 'claude-code');
     const workingDir = await ask(rl, '默认工作目录 [~]: ');
-    const allowedUsers = await ask(rl, '允许的用户 (邮箱或 open_id，逗号分隔，留空=不限制): ');
-    const bot = { larkAppId: appId, larkAppSecret: appSecret, cliId };
-    if (workingDir)
-        bot.workingDir = workingDir;
-    if (allowedUsers)
-        bot.allowedUsers = allowedUsers.split(',').map((s) => s.trim()).filter(Boolean);
+    // 不再持久化 brand 字段: setup 阶段 brand=lark 直接被 obtainCredentials 中止,
+    // 落盘的永远是 'feishu', 写进配置是死字段. 等 lark 完整接入再加回来, 那时
+    // 同步打开 daemon 链路的 brand 透传. botBrand() helper 读不到字段会 default
+    // 到 'feishu', 兼容旧版同时支持将来扩展.
+    const bot = {
+        larkAppId: creds.appId,
+        larkAppSecret: creds.appSecret,
+        cliId,
+        // 总是写 workingDir, 留空用 '~'. 用户手动编辑 bots.json 时一眼能看到字段
+        // 在哪儿, 不用去 README 查字段名.
+        workingDir: workingDir.trim() || '~',
+    };
+    // 不再问 allowedUsers — 扫码场景默认填扫码人自己 (registerApp 返回里有 open_id);
+    // 想改成多人共用 / 不限制, 用户后续手动编辑 ~/.botmux/bots.json 的 allowedUsers
+    // 字段即可. 手动 fallback 场景没 open_id, 字段直接不写 (== 不限制).
+    if (creds.userOpenId)
+        bot.allowedUsers = [creds.userOpenId];
     return bot;
 }
 /** Parse .env file to extract bot config for migration to bots.json */
@@ -177,16 +383,25 @@ function parseDotEnvToBotConfig() {
         bot.projectScanDir = vars.PROJECT_SCAN_DIR;
     return bot;
 }
-/** Write single-bot config to bots.json (fresh install or reconfigure) */
+/**
+ * 收集一个机器人配置并写盘 (单机器人 fresh install / 重新配置).
+ *
+ * 失败路径 (扫码取消 / 凭证校验不通过): 不创建任何配置文件, 不动旧 .env.
+ * Codex review 边界 #2: 中途失败一律不留半截 JSON.
+ */
 async function writeSingleBotConfig() {
-    console.log('── 飞书应用配置 ──\n');
-    printLarkPermissions();
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     const bot = await promptBotConfig(rl);
     rl.close();
-    writeFileSync(BOTS_JSON_FILE, JSON.stringify([bot], null, 2) + '\n');
+    if (!bot)
+        return false;
+    writeBotsJsonAtomic([bot]);
     console.log(`\n✅ 配置已写入: ${BOTS_JSON_FILE}`);
-    console.log(`\n下一步: botmux start`);
+    printRemainingSteps(bot.larkAppId, botBrand(bot));
+    console.log(`下一步:`);
+    console.log(`  1. botmux start              启动 daemon`);
+    console.log(`  2. botmux autostart enable   注册开机自启（推荐：${process.platform === 'darwin' ? 'mac launchd' : process.platform === 'linux' ? 'linux user systemd' : '当前平台暂不支持'}，无需 sudo）`);
+    return true;
 }
 // ─── Commands ────────────────────────────────────────────────────────────────
 async function cmdSetup() {
@@ -207,26 +422,36 @@ async function cmdSetup() {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
         const action = await ask(rl, '操作: 1) 添加新机器人  2) 重新配置  (1/2) [1]: ');
         if (action === '2') {
-            renameSync(BOTS_JSON_FILE, BOTS_JSON_FILE + '.bak');
-            console.log(`旧配置已备份: ${BOTS_JSON_FILE}.bak\n`);
             console.log('\n── 重新配置 ──\n');
-            printLarkPermissions();
             const newBot = await promptBotConfig(rl);
             rl.close();
-            writeFileSync(BOTS_JSON_FILE, JSON.stringify([newBot], null, 2) + '\n');
-            console.log(`\n✅ 配置已写入: ${BOTS_JSON_FILE}`);
-            console.log(`\n下一步: botmux restart`);
+            if (!newBot) {
+                console.log('\n⚠️  setup 中止，旧配置保留不动。');
+                return;
+            }
+            // Codex review #1: 先 copyFileSync 备份, 再原子写新文件. 之前先 rename
+            // 旧文件再 write, 一旦 write 失败 (磁盘/权限/进程被 kill) 用户就丢了
+            // bots.json. copy 之后写失败旧文件原地不动, .bak 是无害的同名副本.
+            copyFileSync(BOTS_JSON_FILE, BOTS_JSON_FILE + '.bak');
+            console.log(`旧配置已备份: ${BOTS_JSON_FILE}.bak`);
+            writeBotsJsonAtomic([newBot]);
+            console.log(`✅ 配置已写入: ${BOTS_JSON_FILE}`);
+            printRemainingSteps(newBot.larkAppId, botBrand(newBot));
+            console.log(`下一步: botmux restart\n`);
             return;
         }
         console.log('\n── 添加新机器人 ──\n');
-        printLarkPermissions();
         const newBot = await promptBotConfig(rl);
         rl.close();
-        bots.push(newBot);
-        writeFileSync(BOTS_JSON_FILE, JSON.stringify(bots, null, 2) + '\n');
-        console.log(`\n✅ 已添加机器人 ${newBot.larkAppId}，共 ${bots.length} 个`);
+        if (!newBot) {
+            console.log('\n⚠️  setup 中止，bots.json 不动。');
+            return;
+        }
+        writeBotsJsonAtomic([...bots, newBot]);
+        console.log(`\n✅ 已添加机器人 ${newBot.larkAppId}，共 ${bots.length + 1} 个`);
         console.log(`   配置文件: ${BOTS_JSON_FILE}`);
-        console.log(`\n下一步: botmux restart`);
+        printRemainingSteps(newBot.larkAppId, botBrand(newBot));
+        console.log(`下一步: botmux restart\n`);
     }
     else if (hasEnv) {
         // --- Single-bot mode (.env exists) ---
@@ -235,9 +460,11 @@ async function cmdSetup() {
         const action = await ask(rl, '操作: 1) 添加新机器人  2) 覆盖当前配置  (1/2): ');
         if (action === '2') {
             rl.close();
-            await writeSingleBotConfig();
-            renameSync(ENV_FILE, ENV_FILE + '.bak');
-            console.log(`   旧 .env 已备份: ${ENV_FILE}.bak`);
+            const ok = await writeSingleBotConfig();
+            if (ok) {
+                renameSync(ENV_FILE, ENV_FILE + '.bak');
+                console.log(`   旧 .env 已备份: ${ENV_FILE}.bak`);
+            }
             return;
         }
         // Migrate .env → bots.json
@@ -250,16 +477,20 @@ async function cmdSetup() {
         }
         console.log(`\n当前机器人: ${existingBot.larkAppId} (${existingBot.cliId ?? 'claude-code'})`);
         console.log('\n── 添加新机器人 ──\n');
-        printLarkPermissions();
         const newBot = await promptBotConfig(rl);
         rl.close();
-        const bots = [existingBot, newBot];
-        writeFileSync(BOTS_JSON_FILE, JSON.stringify(bots, null, 2) + '\n');
+        if (!newBot) {
+            console.log('\n⚠️  setup 中止，.env 和 bots.json 都不动。');
+            return;
+        }
+        // 写新文件成功后才备份 .env. 失败不动两边.
+        writeBotsJsonAtomic([existingBot, newBot]);
         renameSync(ENV_FILE, ENV_FILE + '.bak');
         console.log(`\n✅ 已迁移到多机器人配置`);
         console.log(`   配置文件: ${BOTS_JSON_FILE}`);
         console.log(`   旧配置已备份: ${ENV_FILE}.bak`);
-        console.log(`\n下一步: botmux restart`);
+        printRemainingSteps(newBot.larkAppId, botBrand(newBot));
+        console.log(`下一步: botmux restart\n`);
     }
     else {
         // --- Fresh install ---
@@ -342,7 +573,7 @@ function preflightNodeSanity() {
         }
     }
 }
-function cmdStart() {
+async function cmdStart() {
     if (!hasConfig()) {
         console.error('❌ 未找到配置文件');
         console.error('   请先运行: botmux setup');
@@ -350,6 +581,41 @@ function cmdStart() {
     }
     ensureConfigDir();
     preflightNodeSanity();
+    await ensureSystemDependencies();
+    // 启动前快速校验每个 bot 的凭证. Codex review 边界 #5: 凭证无效是
+    // 唯一应该阻塞 start 的情况; scope/event 缺失在 daemon 起来后用 WARN
+    // + 私信处理 (event-dispatcher.checkRequiredScopes).
+    //
+    // 失败时打印明确的 appId 前缀和错误码, 不打印 secret, 不 spawn pm2 进程.
+    const botsForCheck = loadBotsJson();
+    if (botsForCheck.length > 0) {
+        const { validateCredentials } = await import('./setup/verify-permissions.js');
+        const invalid = [];
+        for (const b of botsForCheck) {
+            if (!b.larkAppId || !b.larkAppSecret) {
+                invalid.push({ appId: b.larkAppId || '(空 appId)', reason: 'larkAppId/larkAppSecret 缺失' });
+                continue;
+            }
+            const v = await validateCredentials(b.larkAppId, b.larkAppSecret, botBrand(b));
+            if (!v.ok) {
+                if (v.error === 'invalid_credentials') {
+                    invalid.push({ appId: b.larkAppId, reason: v.message });
+                }
+                else {
+                    // network / unknown — 不应该拦下启动, 走 WARN
+                    console.warn(`⚠️  [${b.larkAppId}] 启动前凭证验证未成功（${v.error}）: ${v.message}`);
+                    console.warn(`   daemon 仍会启动；启动后 dispatcher 会自行重试。`);
+                }
+            }
+        }
+        if (invalid.length > 0) {
+            console.error('\n❌ 以下机器人凭证无效，botmux start 中止：\n');
+            for (const e of invalid)
+                console.error(`   - ${e.appId}: ${e.reason}`);
+            console.error('\n   修复方式: 运行 `botmux setup` 选 "重新配置" 重新走扫码/手动流程。');
+            process.exit(1);
+        }
+    }
     cleanupLegacyPm2();
     const cfg = ecosystemConfig();
     runPm2(['start', cfg]);
@@ -358,6 +624,33 @@ function cmdStart() {
     console.log(`\n✅ daemon 已启动${count > 1 ? ` (${count} 个机器人, 每个独立进程)` : ''}`);
     console.log(`   日志: botmux logs`);
     console.log(`   状态: botmux status`);
+    // If the user previously enabled autostart, sync the unit file in case
+    // node/cli.js paths changed since (nvm switch, npm upgrade, etc.).
+    if (refreshAutostart({ pkgRoot: PKG_ROOT, configDir: CONFIG_DIR, logDir: LOG_DIR })) {
+        console.log(`   autostart unit 已同步到当前 Node/cli.js 路径`);
+    }
+}
+/**
+ * Wipe stale dashboard-daemon descriptors (mtime older than 5 minutes).
+ * Live daemons refresh their descriptor every 30s via heartbeat; anything
+ * older is from a daemon that exited without cleaning up. Called as part of
+ * the pm2 zombie-cleanup flow so the dashboard registry stays consistent.
+ */
+function cleanupStaleDaemonDescriptors() {
+    const regDir = join(DATA_DIR, 'dashboard-daemons');
+    if (!existsSync(regDir))
+        return;
+    for (const f of readdirSync(regDir)) {
+        if (!f.endsWith('.json'))
+            continue;
+        const fp = join(regDir, f);
+        try {
+            const stat = statSync(fp);
+            if (Date.now() - stat.mtimeMs > 5 * 60_000)
+                unlinkSync(fp);
+        }
+        catch { /* ignore */ }
+    }
 }
 /** Delete all pm2 processes matching botmux / botmux-* under the given PM2_HOME. */
 function deleteAllBotmuxProcesses(home = PM2_HOME) {
@@ -439,10 +732,12 @@ function cmdStop() {
         }
     }
     catch { /* */ }
+    // Wipe abandoned dashboard-daemon descriptors left behind by stopped daemons.
+    cleanupStaleDaemonDescriptors();
     if (!stopped)
         console.log('daemon 未在运行。');
 }
-function cmdRestart() {
+async function cmdRestart() {
     if (!hasConfig()) {
         console.error('❌ 未找到配置文件');
         console.error('   请先运行: botmux setup');
@@ -450,11 +745,31 @@ function cmdRestart() {
     }
     ensureConfigDir();
     preflightNodeSanity();
+    await ensureSystemDependencies();
     cleanupLegacyPm2();
     // Delete all botmux processes (handles both old single-process and new multi-process)
     deleteAllBotmuxProcesses();
+    // Wipe abandoned dashboard-daemon descriptors left behind by killed daemons.
+    cleanupStaleDaemonDescriptors();
     const cfg = ecosystemConfig();
     runPm2(['start', cfg]);
+    if (refreshAutostart({ pkgRoot: PKG_ROOT, configDir: CONFIG_DIR, logDir: LOG_DIR })) {
+        console.log(`autostart unit 已同步到当前 Node/cli.js 路径`);
+    }
+}
+/** Wraps `ensureDependencies()`. Neither tmux nor fonts are load-bearing —
+ *  ensureDependencies surfaces failures as warnings and the daemon continues
+ *  on PTY backend. Only an unexpected exception (programmer error) propagates. */
+async function ensureSystemDependencies() {
+    const { ensureDependencies } = await import('./setup/index.js');
+    try {
+        await ensureDependencies();
+    }
+    catch (err) {
+        console.error('');
+        console.error(`依赖检测内部错误: ${err?.message ?? String(err)}`);
+        // Don't exit — let daemon start try anyway; worst case PTY backend works.
+    }
 }
 /**
  * If a legacy ~/.pm2 daemon with botmux processes still exists alongside our
@@ -538,6 +853,44 @@ function cmdUpgrade() {
         process.exit(1);
     }
 }
+/**
+ * Print a fresh dashboard URL by HMAC-authing to the dashboard process's
+ * loopback rotation endpoint. Each call invalidates the previously-issued
+ * token, so sharing a URL is the same as sharing a one-shot session.
+ */
+async function cmdDashboard() {
+    const SECRET_PATH = join(CONFIG_DIR, '.dashboard-secret');
+    if (!existsSync(SECRET_PATH)) {
+        console.error('Dashboard not initialised. Run `botmux restart` first.');
+        process.exit(1);
+    }
+    const secret = readFileSync(SECRET_PATH, 'utf8').trim();
+    const ts = Math.floor(Date.now() / 1000).toString();
+    const nonce = randomBytes(8).toString('hex');
+    const sig = createHmac('sha256', secret).update(`${ts}:${nonce}`).digest('base64url');
+    const port = process.env.BOTMUX_DASHBOARD_PORT ?? '7891';
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${port}/__cli/rotate`, {
+            method: 'POST',
+            headers: {
+                'X-Botmux-Cli-Ts': ts,
+                'X-Botmux-Cli-Nonce': nonce,
+                'X-Botmux-Cli-Auth': sig,
+            },
+        });
+    }
+    catch {
+        console.error(`dashboard process not reachable on 127.0.0.1:${port} — \`botmux restart\` will start it`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        console.error('Rotation failed:', res.status, await res.text());
+        process.exit(1);
+    }
+    const body = await res.json();
+    console.log(body.url);
+}
 /**
  * Resolve the session data directory.
  * Priority: SESSION_DATA_DIR env > daemon breadcrumb (~/.botmux/.data-dir) > default (~/.botmux/data)
@@ -812,7 +1165,7 @@ function printSessionTable(active) {
 /** Check if a tmux session exists. */
 function tmuxSessionExists(name) {
     try {
-        execSync(`tmux has-session -t ${name} 2>/dev/null`, { stdio: 'ignore' });
+        execSync(`tmux has-session -t ${name} 2>/dev/null`, { stdio: 'ignore', env: tmuxEnv() });
         return true;
     }
     catch {
@@ -956,7 +1309,7 @@ function interactiveSessionPicker(active) {
             // Kill tmux session
             if (r.hasTmux) {
                 try {
-                    execSync(`tmux kill-session -t '${r.tmuxName}' 2>/dev/null`, { stdio: 'ignore' });
+                    execSync(`tmux kill-session -t '${r.tmuxName}' 2>/dev/null`, { stdio: 'ignore', env: tmuxEnv() });
                 }
                 catch { /* */ }
             }
@@ -1027,6 +1380,7 @@ function interactiveSessionPicker(active) {
                 cleanup();
                 spawnSync('tmux', ['attach-session', '-t', selected.tmuxName], {
                     stdio: 'inherit',
+                    env: tmuxEnv(),
                 });
                 resolve();
                 return;
@@ -1124,7 +1478,7 @@ function cmdDelete() {
         // Kill associated tmux session if it exists
         const tmuxName = `bmx-${s.sessionId.substring(0, 8)}`;
         try {
-            execSync(`tmux kill-session -t '${tmuxName}' 2>/dev/null`, { stdio: 'ignore' });
+            execSync(`tmux kill-session -t '${tmuxName}' 2>/dev/null`, { stdio: 'ignore', env: tmuxEnv() });
             console.log(`  killed tmux ${tmuxName}`);
         }
         catch { /* no tmux session */ }
@@ -1136,6 +1490,140 @@ function cmdDelete() {
     }
     console.log(`\n已关闭 ${toDelete.length} 个会话`);
 }
+/**
+ * Discover online daemons. Mirrors the staleness rule used by
+ * dashboard/registry.ts (90s heartbeat) so we don't try to talk to a daemon
+ * that's been dead but left a stale descriptor behind. Uses resolveDataDir()
+ * so SESSION_DATA_DIR / breadcrumb-overridden deployments find the right
+ * descriptor directory.
+ */
+function listOnlineDaemons() {
+    const regDir = join(resolveDataDir(), 'dashboard-daemons');
+    if (!existsSync(regDir))
+        return [];
+    const STALE_MS = 90_000;
+    const now = Date.now();
+    const all = [];
+    let names = [];
+    try {
+        names = readdirSync(regDir);
+    }
+    catch {
+        return [];
+    }
+    for (const f of names) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const d = JSON.parse(readFileSync(join(regDir, f), 'utf-8'));
+            if (typeof d?.ipcPort !== 'number' || typeof d?.larkAppId !== 'string')
+                continue;
+            if (now - (d.lastHeartbeat ?? 0) > STALE_MS)
+                continue;
+            all.push({ ipcPort: d.ipcPort, larkAppId: d.larkAppId, lastHeartbeat: d.lastHeartbeat });
+        }
+        catch { /* skip malformed */ }
+    }
+    return all;
+}
+function findDaemon(larkAppId) {
+    const all = listOnlineDaemons();
+    if (larkAppId)
+        return all.find(d => d.larkAppId === larkAppId) ?? null;
+    return all[0] ?? null;
+}
+async function cmdResume() {
+    const target = process.argv[3];
+    if (!target) {
+        console.error('用法: botmux resume <session-id|prefix>');
+        console.error('  通过 botmux list 查看活跃会话；resume 仅适用于 status=closed 的会话');
+        process.exit(1);
+    }
+    const sessions = loadSessions();
+    const closed = [...sessions.values()].filter(s => s.status === 'closed');
+    if (closed.length === 0) {
+        console.error('没有已关闭的会话可恢复。');
+        process.exit(1);
+    }
+    const matches = closed.filter(s => s.sessionId.startsWith(target));
+    if (matches.length === 0) {
+        console.error(`❌ 未找到匹配 "${target}" 的已关闭会话`);
+        process.exit(1);
+    }
+    if (matches.length > 1) {
+        console.error(`❌ "${target}" 匹配了 ${matches.length} 个会话，请提供更长的 ID 前缀：`);
+        for (const s of matches) {
+            console.error(`   ${s.sessionId.substring(0, 12)}  ${s.title}`);
+        }
+        process.exit(1);
+    }
+    const session = matches[0];
+    // Legacy sessions persisted before per-bot files lack larkAppId. Rather
+    // than silently routing to "the first online daemon" — which can land on
+    // the wrong bot in multi-bot setups and corrupt state — refuse and tell
+    // the user what's missing. Single-bot setups still work (we resolve to
+    // that lone daemon below).
+    if (!session.larkAppId) {
+        const online = listOnlineDaemons();
+        if (online.length > 1) {
+            console.error(`❌ 会话 ${session.sessionId.substring(0, 12)} 缺少 larkAppId，多 bot 部署下无法判定归属。`);
+            console.error('   解决办法：手动给该 session 补 larkAppId 后重试，或使用对应 bot 的话题里 ▶️ 恢复会话 按钮。');
+            console.error(`   在线 daemon (${online.length}): ${online.map(d => d.larkAppId).join(', ')}`);
+            process.exit(1);
+        }
+        if (online.length === 0) {
+            console.error('❌ 没有在线 daemon。请先：botmux start');
+            process.exit(1);
+        }
+        // Single online daemon — safe to use
+    }
+    const daemon = findDaemon(session.larkAppId);
+    if (!daemon) {
+        const hint = session.larkAppId
+            ? `未找到 daemon (larkAppId=${session.larkAppId})`
+            : '未找到任何在线 daemon';
+        console.error(`❌ ${hint}。请确认 daemon 正在运行：botmux status`);
+        process.exit(1);
+    }
+    let res;
+    try {
+        res = await fetch(`http://127.0.0.1:${daemon.ipcPort}/api/sessions/${encodeURIComponent(session.sessionId)}/resume`, { method: 'POST' });
+    }
+    catch (err) {
+        console.error(`❌ 无法连接到 daemon (port=${daemon.ipcPort}): ${err?.message ?? err}`);
+        process.exit(1);
+    }
+    let body = {};
+    try {
+        body = await res.json();
+    }
+    catch { /* */ }
+    if (res.ok && body?.ok) {
+        console.log(`✅ 会话已恢复: ${session.sessionId.substring(0, 12)}  ${session.title}`);
+        if (body.workingDir)
+            console.log(`   工作目录: ${body.workingDir}`);
+        console.log('   下一条消息会以 --resume 拉起 CLI；已在原话题留通知。');
+        return;
+    }
+    const errCode = body?.error ?? `HTTP ${res.status}`;
+    if (errCode === 'anchor_occupied') {
+        const occ = body?.activeSessionId ? ` (占用者: ${body.activeSessionId.substring(0, 12)})` : '';
+        console.error(`❌ 当前话题已有新的活跃会话${occ}，无法 resume 旧会话。`);
+    }
+    else if (errCode === 'not_closed') {
+        console.error('❌ 会话当前不是 closed 状态，无需 resume。');
+    }
+    else if (errCode === 'not_found') {
+        console.error('❌ daemon 中找不到该会话（可能已被清理）。');
+    }
+    else if (errCode === 'adopt_unsupported') {
+        console.error('❌ adopt 接管会话不支持 resume。');
+    }
+    else {
+        console.error(`❌ 恢复失败: ${errCode}`);
+    }
+    process.exit(1);
+}
 function showHelp() {
     console.log(`
 botmux v${getVersion()} — IM ↔ AI 编程 CLI 桥接
@@ -1148,11 +1636,17 @@ botmux v${getVersion()} — IM ↔ AI 编程 CLI 桥接
   logs        查看 daemon 日志（--lines N, --bot <index>）
   status      查看 daemon 状态
   upgrade     升级到最新版本
+  dashboard   打印新的 Web Dashboard 一次性登录 URL（旧 token 同时失效）
   list        列出活跃会话（交互式选择并连接 tmux）
               --plain  纯文本表格输出（管道/脚本场景）
   delete <id>      关闭指定会话（支持 ID 前缀匹配）
   delete all       关闭所有活跃会话
   delete stopped   清理所有进程已退出的僵尸会话
+  resume <id>      恢复一个已关闭的会话（支持 ID 前缀匹配）— 会话标记回 active，
+                   下条消息会以 --resume 重新拉起 CLI 进程
+  autostart enable     注册开机自启（macOS launchd / Linux user systemd，无需 sudo）
+  autostart disable    注销开机自启
+  autostart status     查看自启状态
 
 定时任务（可在 CLI 会话内自动推断 chat）:
   schedule list                        列出所有任务
@@ -1167,8 +1661,15 @@ botmux v${getVersion()} — IM ↔ AI 编程 CLI 桥接
        --files <path>                  附件（可重复）
        --mention <open_id:name>        @提及（可重复）
        --card | --text                 强制卡片 / 纯文本（默认按 md 语法自动判断）
+       --top-level                     发顶层消息（不回复进当前话题）
+       --chat-id <oc_xxx>              指定目标群（默认当前话题所在群）
   bots list                            列出当前群聊中的机器人（含 open_id）
-  thread messages [--limit N]          拉取当前话题的消息历史 (JSON)
+  history [--limit N]                  拉取当前会话的消息历史 (JSON)，话题群 → 话题内，普通群 → 整群
+  quoted <message_id>                  拉取被引用的单条消息 (JSON)，message_id 取自 daemon 注入的引用提示行
+
+新建飞书群:
+  create-group --bot <name> [--bot ...] [--name "群名"]
+                                       用指定 bot 起新群；详见 \`botmux create-group --help\`
 
 配置目录: ~/.botmux/
 文档: https://github.com/deepcoldy/botmux
@@ -1246,13 +1747,18 @@ function argFlag(args, flag) {
     return args.includes(flag);
 }
 /** Extract positional args, skipping --flag and the value that follows it
- *  (for --flag <value> style).  --flag=value style is self-contained. */
-function positionals(args) {
+ *  (for --flag <value> style).  --flag=value style is self-contained.
+ *  `booleanFlags` lists flags that take no value — without this hint the
+ *  parser swallows the *next* arg as the flag's value, which silently eats
+ *  positional content (or, worse, a following --flag's value). */
+function positionals(args, booleanFlags = []) {
     const out = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
         if (a.startsWith('--')) {
-            if (!a.includes('=') && i + 1 < args.length)
+            const flagName = a.includes('=') ? a.slice(0, a.indexOf('=')) : a;
+            const isBoolean = booleanFlags.includes(flagName);
+            if (!a.includes('=') && !isBoolean && i + 1 < args.length)
                 i++; // skip value
             continue;
         }
@@ -1331,6 +1837,9 @@ async function cmdSchedule(sub, rest) {
             chatId,
             rootMessageId,
             larkAppId,
+            creatorChatId: cur?.chatId,
+            creatorRootMessageId: cur?.rootMessageId,
+            creatorLarkAppId: cur?.larkAppId,
             chatType: cur?.chatType === 'p2p' ? 'p2p' : 'topic_group',
             deliver,
         });
@@ -1395,13 +1904,15 @@ async function cmdSchedule(sub, rest) {
             process.exit(1);
     }
 }
-async function cmdThreadMessages(rest) {
+/** Resolve a CLI subcommand's larkAppId by walking the session marker. Common
+ *  prelude for `history` / `quoted` / similar commands that need to talk to
+ *  Lark on behalf of the session that spawned them. Exits with stderr on
+ *  failure so callers can stay focused on the happy path. */
+async function resolveSessionAppId(sessionIdArg) {
     process.env.SESSION_DATA_DIR ??= resolveDataDir();
-    const limit = parseInt(argValue(rest, '--limit') ?? '50', 10);
-    const sessionIdArg = argValue(rest, '--session-id');
     const sid = sessionIdArg ?? findAncestorSessionId();
     if (!sid) {
-        console.error('无法推断 session-id。请在 Lark 话题内的 CLI 会话中运行，或传 --session-id <id>。');
+        console.error('无法推断 session-id。请在 Lark 话题/群里的 CLI 会话中运行，或传 --session-id <id>。');
         process.exit(1);
     }
     const sessions = loadSessions();
@@ -1421,15 +1932,75 @@ async function cmdThreadMessages(rest) {
             registerBot(cfg);
     }
     catch { /* ignore */ }
-    const { listThreadMessages } = await import('./im/lark/client.js');
+    return { sid, larkAppId: s.larkAppId, session: s };
+}
+async function cmdHistory(rest) {
+    const limit = parseInt(argValue(rest, '--limit') ?? '50', 10);
+    const sessionIdArg = argValue(rest, '--session-id');
+    const { sid, larkAppId: appId, session: s } = await resolveSessionAppId(sessionIdArg);
+    const { listThreadMessages, listChatMessages } = await import('./im/lark/client.js');
     const { parseApiMessage } = await import('./im/lark/message-parser.js');
+    const { expandMergeForward } = await import('./im/lark/merge-forward.js');
     try {
-        const raw = await listThreadMessages(s.larkAppId, s.chatId, s.rootMessageId, limit);
-        const messages = raw.map(m => parseApiMessage(m));
-        console.log(JSON.stringify({ sessionId: sid, threadId: s.rootMessageId, messages, total: messages.length }, null, 2));
+        // Chat-scope sessions (普通群整群一会话) have no thread to walk — list the
+        // chat container directly and let the caller cap with --limit. Thread-scope
+        // sessions walk the thread container by root_id.
+        const isChatScope = s.scope === 'chat';
+        const raw = isChatScope
+            ? await listChatMessages(appId, s.chatId, limit)
+            : await listThreadMessages(appId, s.chatId, s.rootMessageId, limit);
+        // Expand merge_forward to <forwarded_messages> XML, mirroring the live event
+        // path in daemon.ts. Each merge_forward gets its own numberer (we don't
+        // download resources here — only [图片 N] placeholders matter).
+        const messages = await Promise.all(raw.map(async (m) => {
+            const parsed = parseApiMessage(m);
+            if (parsed.msgType === 'merge_forward') {
+                await expandMergeForward(appId, parsed.messageId, parsed);
+            }
+            return parsed;
+        }));
+        console.log(JSON.stringify({
+            sessionId: sid,
+            chatId: s.chatId,
+            scope: isChatScope ? 'chat' : 'thread',
+            ...(isChatScope ? {} : { rootMessageId: s.rootMessageId }),
+            messages,
+            total: messages.length,
+        }, null, 2));
     }
     catch (err) {
-        console.error(`获取话题消息失败: ${err.message}`);
+        console.error(`获取消息失败: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function cmdQuoted(rest) {
+    const sessionIdArg = argValue(rest, '--session-id');
+    // Positional message_id is required. The id comes verbatim from the
+    // `[用户引用了消息 用 botmux quoted om_xxx 查看]` prompt prefix the daemon
+    // injects when the user used the Lark quote-reply UI. Skip --session-id and
+    // its value so `botmux quoted --session-id <uuid> om_xxx` doesn't pick up
+    // the uuid as the message id.
+    const messageId = firstPositional(rest, ['--session-id']);
+    if (!messageId) {
+        console.error('用法: botmux quoted <message_id> [--session-id <id>]');
+        process.exit(1);
+    }
+    const { larkAppId: appId } = await resolveSessionAppId(sessionIdArg);
+    const { getMessageDetail } = await import('./im/lark/client.js');
+    const { expandMergeForward } = await import('./im/lark/merge-forward.js');
+    const { renderQuotedMessage } = await import('./cli/quoted-render.js');
+    try {
+        const detail = await getMessageDetail(appId, messageId);
+        const msg = detail?.items?.[0];
+        if (!msg) {
+            console.error(`未找到消息 ${messageId}`);
+            process.exit(1);
+        }
+        const rendered = await renderQuotedMessage(appId, msg, expandMergeForward);
+        console.log(JSON.stringify(rendered, null, 2));
+    }
+    catch (err) {
+        console.error(`获取被引用消息失败: ${err.message}`);
         process.exit(1);
     }
 }
@@ -1464,139 +2035,23 @@ function argValues(args, ...flags) {
     }
     return out;
 }
-/** Feishu card markdown element doesn't render ATX headings → promote to bold. */
-function transformHeadings(md) {
-    return md.replace(/^#{1,6}\s+(.+)$/gm, (_m, c) => `**${c.trim()}**`);
-}
-/** Parse a contiguous pipe-table block into a Feishu card v2 `table` element. */
-function parseTableBlock(block) {
-    const lines = block.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
-    if (lines.length < 2)
-        return null;
-    const rows = lines.map(l => l.replace(/^\|/, '').replace(/\|$/, '').split('|').map(c => c.trim()));
-    const sepIdx = rows.findIndex(r => r.length > 0 && r.every(c => /^:?-{2,}:?$/.test(c)));
-    const header = rows[0];
-    const body = sepIdx === 1 ? rows.slice(2) : rows.slice(1);
-    if (header.length === 0)
-        return null;
-    const columns = header.map((h, i) => ({
-        name: `c${i}`,
-        display_name: h || ' ',
-        data_type: 'lark_md',
-        width: 'auto',
-    }));
-    const tableRows = body.map(r => {
-        const o = {};
-        for (let i = 0; i < header.length; i++)
-            o[`c${i}`] = r[i] ?? '';
-        return o;
-    });
-    return {
-        tag: 'table',
-        page_size: Math.min(10, Math.max(1, tableRows.length || 1)),
-        row_height: 'low',
-        header_style: {
-            text_align: 'left',
-            text_size: 'normal',
-            background_style: 'grey',
-            text_color: 'default',
-            bold: true,
-            lines: 1,
-        },
-        columns,
-        rows: tableRows,
-    };
-}
-/**
- * Split markdown into card v2 body elements:
- *   1. Fenced code blocks are preserved verbatim (shielded from heading/table
- *      transforms so `#` and `|` inside code don't get mis-parsed).
- *   2. Pipe-table blocks in prose become native `table` elements.
- *   3. Everything else becomes a `markdown` element with ATX headings promoted
- *      to bold (Feishu's markdown element doesn't render `#`).
- * Consecutive markdown fragments are merged so the card keeps reasonable
- * element counts.
- */
-function buildCardBodyElements(md) {
-    const elements = [];
-    let buffer = '';
-    const flushBuffer = () => {
-        const t = buffer.replace(/^\s+|\s+$/g, '');
-        if (t)
-            elements.push({ tag: 'markdown', content: transformHeadings(t) });
-        buffer = '';
-    };
-    // Segment by fenced code blocks (``` ... ```)
-    const fenceRe = /^```[^\n]*\n[\s\S]*?^```[ \t]*$/gm;
-    const segments = [];
-    let fCursor = 0;
-    let fm;
-    while ((fm = fenceRe.exec(md)) !== null) {
-        if (fm.index > fCursor)
-            segments.push({ type: 'prose', text: md.slice(fCursor, fm.index) });
-        segments.push({ type: 'code', text: fm[0] });
-        fCursor = fm.index + fm[0].length;
-    }
-    if (fCursor < md.length)
-        segments.push({ type: 'prose', text: md.slice(fCursor) });
-    for (const seg of segments) {
-        if (seg.type === 'code') {
-            buffer += (buffer && !buffer.endsWith('\n') ? '\n' : '') + seg.text + '\n';
-            continue;
-        }
-        const tableRe = /(?:^[ \t]*\|.+\|[ \t]*\r?\n?){2,}/gm;
-        let tCursor = 0;
-        let tm;
-        while ((tm = tableRe.exec(seg.text)) !== null) {
-            buffer += seg.text.slice(tCursor, tm.index);
-            flushBuffer();
-            const table = parseTableBlock(tm[0]);
-            if (table)
-                elements.push(table);
-            else
-                buffer += tm[0];
-            tCursor = tm.index + tm[0].length;
-        }
-        buffer += seg.text.slice(tCursor);
-    }
-    flushBuffer();
-    return elements;
-}
-/**
- * Heuristic: does `text` contain markdown syntax that renders badly as plain
- * text in Feishu (code fences, headings, lists, bold, inline code, links,
- * tables, blockquotes, hr)? If so, `cmdSend` switches to an interactive card
- * so Feishu can render it properly.
- */
-function hasMarkdown(text) {
-    if (!text)
-        return false;
-    return (/```/.test(text) ||
-        /^#{1,6}\s/m.test(text) ||
-        /^\s{0,3}[-*+]\s+\S/m.test(text) ||
-        /^\s{0,3}\d+\.\s+\S/m.test(text) ||
-        /\*\*[^*\n]+\*\*/.test(text) ||
-        /(^|[^`])`[^`\n]+`([^`]|$)/.test(text) ||
-        /\[[^\]\n]+\]\([^)\n]+\)/.test(text) ||
-        /^\s*\|.+\|\s*$/m.test(text) ||
-        /^>\s/m.test(text) ||
-        /^(?:---|\*\*\*|___)\s*$/m.test(text));
-}
+// Card v2 body builder helpers — extracted to im/lark/md-card.ts so the
+// daemon's bridge fallback path can produce identical cards. cmdSend
+// keeps using `buildCardBodyElements` and `hasMarkdown` from there.
+import { buildCardBodyElements, hasMarkdown } from './im/lark/md-card.js';
 /**
  * Decide who the reply card should @ in its footer.
  *
- * Non-oncall chats: `发送给: @<owner>` as before, no cc.
- * Oncall chats: `发送给: @<last caller>` (falls back to owner if unknown);
- *   if caller differs from the owners list, `cc` the owners so they stay
- *   notified. Caller is deduped out of cc to avoid double-@.
+ * Non-oncall chats: `发送给: @<owner>`.
+ * Oncall chats: `发送给: @<last caller>` (falls back to owner if unknown) —
+ *   permission is governed by allowedUsers, so there's no per-chat list to cc.
  */
 function buildFooterAddressing(s, oncall) {
     const owner = s.ownerOpenId;
     const caller = s.lastCallerOpenId ?? owner;
     if (!oncall)
         return { sendTo: owner, cc: [] };
-    const cc = oncall.owners.filter(id => id && id !== caller);
-    return { sendTo: caller, cc };
+    return { sendTo: caller, cc: [] };
 }
 async function cmdSend(rest) {
     process.env.SESSION_DATA_DIR ??= resolveDataDir();
@@ -1607,6 +2062,12 @@ async function cmdSend(rest) {
     const contentFile = argValue(rest, '--content-file');
     const forceCard = rest.includes('--card');
     const forceText = rest.includes('--text');
+    // Publish-mode flags: post a fresh top-level message in a chat instead of
+    // replying into the bound thread. Lets a session "publish" to a different
+    // chat (e.g. a public release-notes group) while keeping its own thread
+    // for streaming-card / progress UI.
+    const sendTopLevel = rest.includes('--top-level');
+    const overrideChatId = argValue(rest, '--chat-id');
     const sid = sessionIdArg ?? findAncestorSessionId();
     if (!sid) {
         console.error('无法推断 session-id。请在 Lark 话题内的 CLI 会话中运行，或传 --session-id <id>。');
@@ -1632,7 +2093,7 @@ async function cmdSend(rest) {
         content = readFileSync(contentFile, 'utf-8');
     }
     else {
-        const pos = positionals(rest);
+        const pos = positionals(rest, ['--card', '--text', '--top-level']);
         if (pos.length > 0) {
             content = pos.join(' ');
         }
@@ -1666,15 +2127,31 @@ async function cmdSend(rest) {
         }
     }
     // Register bots so Lark client works
-    const { registerBot, loadBotConfigs, findOncallChat } = await import('./bot-registry.js');
+    const { registerBot, loadBotConfigs, findOncallChatForAnyBot } = await import('./bot-registry.js');
     try {
         for (const cfg of loadBotConfigs())
             registerBot(cfg);
     }
     catch { /* */ }
-    const { replyMessage, uploadImage, uploadFile } = await import('./im/lark/client.js');
+    const { sendMessage, replyMessage, uploadImage, uploadFile } = await import('./im/lark/client.js');
     const appId = s.larkAppId;
-    const oncallEntry = s.chatId ? findOncallChat(appId, s.chatId) : undefined;
+    // Effective target chat for top-level mode (defaults to session's chat)
+    const targetChatId = overrideChatId ?? s.chatId;
+    // Chat-scope sessions (普通群整群一会话) post to chatId without
+    // reply_in_thread, otherwise Lark would force every reply into a fresh
+    // topic — defeating the whole point of chat-scope routing.
+    const isChatScope = s.scope === 'chat';
+    // Oncall addressing only meaningful for replies inside the session's own
+    // chat — skip when publishing top-level or to a different chat. Treat
+    // oncall as chat-level: in multi-daemon setups this session's bot may not
+    // be the one that persisted the binding, but users still expect footer
+    // addressing to go to the last caller in the shared oncall workspace.
+    const oncallEntry = !sendTopLevel && !overrideChatId && s.chatId
+        ? findOncallChatForAnyBot(s.chatId) : undefined;
+    // Dispatch helper: top-level / chat-scope send vs reply-in-thread, single decision point
+    const dispatch = (content, msgType) => (sendTopLevel || isChatScope)
+        ? sendMessage(appId, targetChatId, content, msgType)
+        : replyMessage(appId, s.rootMessageId, content, msgType, true);
     try {
         // Upload images in parallel
         const imageKeys = [];
@@ -1702,6 +2179,13 @@ async function cmdSend(rest) {
         // app's cross-ref file for per-app-scoped open_ids. Without this, a plain
         // "@Claude" in text only triggers IPC routing but Lark UI shows it as
         // plain text — confusing the user who thinks the @ didn't fire.
+        //
+        // bot-to-bot @mention 两条触发入口（显式 --mention / 正文 `@BotName`）都
+        // 落到下方的 mentions 数组，单 source of truth：让 Lark 在消息里渲染
+        // 真正的 @at 元素。对方 bot 的 daemon 通过 WSClient 原生事件接到（依赖
+        // "获取群组中其他机器人和用户@当前机器人的消息"权限），不再走任何本地
+        // 转发——botmux 历史上为绕过 Lark 不投递跨 bot 事件搞过 signal-file，
+        // 那套已经在该权限上线后整体下线。
         try {
             const dataDir = resolveDataDir();
             const botInfoPath = join(dataDir, 'bots-info.json');
@@ -1711,18 +2195,34 @@ async function cmdSend(rest) {
                 ? JSON.parse(readFileSync(crossRefPath, 'utf-8'))
                 : {};
             const alreadyMentioned = new Set(mentions.map(m => m.open_id));
-            for (const entry of botEntries) {
+            // Sort by name length desc so longer names ("Claude分身") win over their
+            // prefix ("Claude") when both could match — break-on-first-hit otherwise
+            // routes "@Claude分身" to Claude.
+            const sortedEntries = [...botEntries].sort((a, b) => (b.botName?.length ?? 0) - (a.botName?.length ?? 0));
+            for (const entry of sortedEntries) {
                 if (!entry.botName || entry.larkAppId === appId)
                     continue;
                 const names = [entry.botName, entry.cliId].filter(Boolean);
                 for (const name of names) {
-                    const re = new RegExp(`@${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+                    const escName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    // Boundary: lookbehind blocks only ASCII word chars (so `user@Claude`
+                    // is rejected but `看看@CoCo` is accepted — CJK prefix is normal in
+                    // Chinese text). Lookahead blocks any Unicode letter/digit so
+                    // `@Claude2` doesn't match name "Claude" and `@Claude分身好的` doesn't
+                    // either-half-match.
+                    const re = new RegExp(`(?<![A-Za-z0-9_])@${escName}(?![\\p{L}\\p{N}_])`, 'iu');
                     if (!re.test(text))
                         continue;
-                    // Prefer sender-scoped open_id from cross-ref (what Lark's sender app
-                    // has seen for the target bot); fall back to target's own open_id.
-                    const senderScopedId = crossRef[entry.botName] ?? entry.botOpenId;
-                    if (!senderScopedId || alreadyMentioned.has(senderScopedId))
+                    // Lark open_id is per-app scoped. Use sender-scoped id from cross-ref
+                    // only — falling back to entry.botOpenId would feed Lark a wrong-scope
+                    // id (target's self-scoped) and the API would reject it. Skip + warn
+                    // so the missing cross-ref is observable instead of silently dropped.
+                    const senderScopedId = crossRef[entry.botName];
+                    if (!senderScopedId) {
+                        console.error(`[botmux send] no cross-ref entry for "${entry.botName}" in app ${appId}, skipping auto-mention (cross-ref populates after the sender app first sees the target bot)`);
+                        break;
+                    }
+                    if (alreadyMentioned.has(senderScopedId))
                         break;
                     mentions.push({ open_id: senderScopedId, name: entry.botName });
                     alreadyMentioned.add(senderScopedId);
@@ -1742,6 +2242,13 @@ async function cmdSend(rest) {
         const mentionPattern = namedMentions.length > 0
             ? new RegExp(`@(${namedMentions.map(m => m.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})\\b`, 'gi')
             : null;
+        // Capture sentAtMs BEFORE dispatch — the worker's bridge fallback gates
+        // on `sentAtMs ∈ [turn.markTimeMs, nextTurn.markTimeMs)`. If we recorded
+        // it after dispatch (which can take seconds), a slow Lark RTT could push
+        // this send's timestamp past the next turn's mark and falsely suppress
+        // that turn's fallback emit. Pre-dispatch timestamp captures the moment
+        // we committed to sending — that's the boundary the gate cares about.
+        const sentAtMs = Date.now();
         let messageId;
         if (useCard) {
             // Inline @mention → <at id=open_id></at>; explicit --mention args that
@@ -1788,10 +2295,13 @@ async function cmdSend(rest) {
             // Footer: de-emphasized markdown (v2 dropped the `note` tag). Use small
             // text size + grey font tag so it reads like a footnote below the hr.
             // Oncall groups: `发送给` targets whoever triggered this turn (may not
-            // be the session owner), plus a `cc` line listing oncall owners so they
-            // stay informed. Non-oncall: keep owner-only behaviour.
+            // be the session owner). Non-oncall: keep owner-only behaviour.
             const footerParts = ['[botmux](https://github.com/deepcoldy/botmux)'];
-            const addressing = buildFooterAddressing(s, oncallEntry);
+            // Top-level publish has no specific recipient — drop "发送给/cc" addressing
+            // so the message doesn't @ the session owner who isn't even in the target chat.
+            const addressing = sendTopLevel
+                ? { sendTo: undefined, cc: [] }
+                : buildFooterAddressing(s, oncallEntry);
             if (addressing.sendTo)
                 footerParts.push(`发送给：<at id=${addressing.sendTo}></at>`);
             if (addressing.cc.length > 0) {
@@ -1808,7 +2318,7 @@ async function cmdSend(rest) {
                 config: { update_multi: true },
                 body: { direction: 'vertical', elements },
             });
-            messageId = await replyMessage(appId, s.rootMessageId, cardJson, 'interactive', true);
+            messageId = await dispatch(cardJson, 'interactive');
         }
         else {
             // Plain-text path: build post content, paragraph per line.
@@ -1847,9 +2357,11 @@ async function cmdSend(rest) {
                 }
             }
             // Footer: mirror the card layout — a blank paragraph separates the body
-            // from the addressing line(s). `发送给: @<caller>` always; oncall groups
-            // additionally get `cc: @<owners>` on the next line.
-            const addressing = buildFooterAddressing(s, oncallEntry);
+            // from the addressing line(s). `发送给: @<caller>` always. Top-level
+            // publish has no specific recipient — skip addressing entirely.
+            const addressing = sendTopLevel
+                ? { sendTo: undefined, cc: [] }
+                : buildFooterAddressing(s, oncallEntry);
             if (addressing.sendTo || addressing.cc.length > 0) {
                 if (postContent.length > 0)
                     postContent.push([{ tag: 'text', text: '' }]);
@@ -1861,77 +2373,37 @@ async function cmdSend(rest) {
                 }
             }
             const postJson = JSON.stringify({ zh_cn: { title: '', content: postContent } });
-            messageId = await replyMessage(appId, s.rootMessageId, postJson, 'post', true);
+            messageId = await dispatch(postJson, 'post');
+        }
+        // Bridge fallback marker — append-only jsonl per session. The worker
+        // gates its non-adopt transcript-driven fallback on whether any send
+        // happened within the current Lark turn's window. Only when this send
+        // landed in the session's own thread (not --top-level, not --chat-id
+        // override) does it cancel that turn's fallback.
+        if (!sendTopLevel && !overrideChatId) {
+            try {
+                const markerDir = join(resolveDataDir(), 'turn-sends');
+                if (!existsSync(markerDir))
+                    mkdirSync(markerDir, { recursive: true });
+                // sentAtMs was captured pre-dispatch (see above). messageId is the
+                // confirmed Lark message id from the now-successful dispatch.
+                const line = JSON.stringify({ sentAtMs, messageId }) + '\n';
+                appendFileSync(join(markerDir, `${sid}.jsonl`), line);
+            }
+            catch { /* best-effort: marker miss only causes a redundant fallback message */ }
         }
         // Send file attachments as separate messages
         const fileIds = [];
         for (const fp of files) {
             const fileKey = await uploadFile(appId, fp);
-            const fid = await replyMessage(appId, s.rootMessageId, JSON.stringify({ file_key: fileKey }), 'file', true);
+            const fid = await dispatch(JSON.stringify({ file_key: fileKey }), 'file');
             fileIds.push(fid);
         }
-        // Bot-to-bot mention signals
-        const dataDir = resolveDataDir();
-        const botInfoPath = join(dataDir, 'bots-info.json');
-        let botEntries = [];
-        try {
-            if (existsSync(botInfoPath))
-                botEntries = JSON.parse(readFileSync(botInfoPath, 'utf-8'));
-        }
-        catch { /* */ }
-        const openIdToAppId = new Map();
-        for (const e of botEntries)
-            if (e.botOpenId)
-                openIdToAppId.set(e.botOpenId, e.larkAppId);
-        try {
-            for (const file of readdirSync(dataDir)) {
-                if (!file.startsWith('bot-openids-') || !file.endsWith('.json'))
-                    continue;
-                try {
-                    const crossRef = JSON.parse(readFileSync(join(dataDir, file), 'utf-8'));
-                    for (const [botName, crossOpenId] of Object.entries(crossRef)) {
-                        const entry = botEntries.find(e => e.botName?.toLowerCase() === botName.toLowerCase());
-                        if (entry)
-                            openIdToAppId.set(crossOpenId, entry.larkAppId);
-                    }
-                }
-                catch { /* */ }
-            }
-        }
-        catch { /* */ }
-        const targetAppIds = new Set();
-        for (const m of mentions) {
-            const ta = openIdToAppId.get(m.open_id);
-            if (ta && ta !== appId)
-                targetAppIds.add(ta);
-        }
-        if (text && botEntries.length > 0) {
-            for (const entry of botEntries) {
-                if (!entry.botOpenId || entry.larkAppId === appId)
-                    continue;
-                const names = [entry.botName, entry.cliId].filter(Boolean);
-                for (const name of names) {
-                    if (new RegExp(`@${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i').test(text)) {
-                        targetAppIds.add(entry.larkAppId);
-                        break;
-                    }
-                }
-            }
-        }
-        if (targetAppIds.size > 0) {
-            const signalDir = join(dataDir, 'bot-mentions');
-            if (!existsSync(signalDir))
-                mkdirSync(signalDir, { recursive: true });
-            for (const targetApp of targetAppIds) {
-                const te = botEntries.find(e => e.larkAppId === targetApp);
-                const signal = {
-                    rootMessageId: s.rootMessageId, chatId: s.chatId, chatType: s.chatType,
-                    senderAppId: appId, targetBotOpenId: te?.botOpenId ?? targetApp,
-                    content: text, messageId, timestamp: Date.now(),
-                };
-                writeFileSync(join(signalDir, `${Date.now()}-${(te?.botOpenId ?? targetApp).slice(-8)}.json`), JSON.stringify(signal));
-            }
-        }
+        // Bot-to-bot 转发依赖飞书"获取群组中其他机器人和用户@当前机器人的消息"权限：
+        // 目标 bot 的 daemon 现在能从 WSClient 原生收到 sender_type='app' 的事件，
+        // 不需要 botmux 自己再写本地 signal 文件做转发。outgoing 消息里 @BotName /
+        // --mention 的 open_id 解析（在上方 mentions 数组里完成）仍然必要，它让
+        // Lark 在消息里渲染真正的 @at 元素，从而触发对方 bot 的 WS 事件投递。
         console.log(JSON.stringify({ success: true, messageId, sessionId: sid }));
     }
     catch (err) {
@@ -1939,6 +2411,147 @@ async function cmdSend(rest) {
         process.exit(1);
     }
 }
+// ─── Create-group subcommand ─────────────────────────────────────────────────
+async function cmdCreateGroup(rest) {
+    if (rest.includes('--help') || rest.includes('-h')) {
+        console.log(`
+botmux create-group — 用一组机器人新建飞书群
+
+用法:
+  botmux create-group --bot <name|larkAppId> [--bot ...] [--name "群名"]
+
+参数:
+  --bot <ref>     至少一个，可多次。ref 推荐用 bot 显示名（同 botmux send 的 @<name>）或完整 larkAppId；
+                  cliId（如 claude-code）仅作 fallback —— 多个 bot 常共用同一个 cliId，重名命中只能取
+                  bots.json 中第一个。重名 → 取 bots.json 中第一个匹配，stderr 打 warning。
+                  重复 ref → 自动去重保留首次顺序。
+  --name <群名>   可选；不传则用飞书默认无名群。
+
+行为:
+  - 第一个解析到的 bot 作为 creator（决定建群身份 + 初始群主 + open_id app scope）。
+  - 邀请用户 / 转让群主 / @通知 对象都从 creator 的 resolvedAllowedUsers 取首个 open_id（email 自动转换；
+    转不出来或为空则跳过对应步骤，stderr warning）。
+  - 不依赖 botmux 会话，任何环境都能跑。
+
+输出协议（skill 友好）:
+  - 成功（即使 transfer/notify 部分失败）：stdout 单行 chatId，exit 0；stderr 打人类提示 + applink。
+  - 失败（缺 --bot / 解析失败 / chat.create 抛错）：stdout 空，exit 非零；stderr 打错误。
+`);
+        return;
+    }
+    process.env.SESSION_DATA_DIR ??= resolveDataDir();
+    const botRefs = argValues(rest, '--bot');
+    const name = argValue(rest, '--name');
+    if (botRefs.length === 0) {
+        console.error('用法: botmux create-group --bot <name|larkAppId> [--bot ...] [--name "群名"]');
+        console.error('至少传一个 --bot。');
+        process.exit(1);
+    }
+    // Load bot configs (bots.json order) and bots-info.json (for botName)
+    const { registerBot, loadBotConfigs } = await import('./bot-registry.js');
+    let botConfigs;
+    try {
+        botConfigs = loadBotConfigs().map(c => ({ larkAppId: c.larkAppId, cliId: c.cliId }));
+    }
+    catch (err) {
+        console.error(`加载 bots.json 失败: ${err?.message ?? err}`);
+        process.exit(1);
+    }
+    const dataDir = resolveDataDir();
+    const botInfoPath = join(dataDir, 'bots-info.json');
+    let botInfoEntries = [];
+    try {
+        if (existsSync(botInfoPath))
+            botInfoEntries = JSON.parse(readFileSync(botInfoPath, 'utf-8'));
+    }
+    catch { /* */ }
+    const { resolveBotRefs } = await import('./cli/create-group-resolver.js');
+    const resolved = resolveBotRefs(botRefs, botConfigs, botInfoEntries.map(b => ({ larkAppId: b.larkAppId, botName: b.botName })));
+    for (const w of resolved.ambiguousWarnings)
+        console.error(`⚠️  ${w}`);
+    if (resolved.invalid.length > 0) {
+        console.error(`无法解析的 --bot 引用: ${resolved.invalid.join(', ')}`);
+        console.error('可用 bot：');
+        for (const cfg of botConfigs) {
+            const info = botInfoEntries.find(b => b.larkAppId === cfg.larkAppId);
+            console.error(`  - ${info?.botName ?? '(unnamed)'}  cliId=${cfg.cliId}  ${cfg.larkAppId}`);
+        }
+        process.exit(1);
+    }
+    if (resolved.larkAppIds.length === 0) {
+        console.error('未解析到任何 bot，请检查 --bot 引用。');
+        process.exit(1);
+    }
+    const creatorLarkAppId = resolved.larkAppIds[0];
+    // Register bots so getBotClient works inside service
+    const fullConfigs = loadBotConfigs();
+    const needed = new Set(resolved.larkAppIds);
+    try {
+        for (const cfg of fullConfigs)
+            if (needed.has(cfg.larkAppId))
+                registerBot(cfg);
+    }
+    catch (err) {
+        console.error(`注册 bot 失败: ${err?.message ?? err}`);
+        process.exit(1);
+    }
+    // Derive user_open_id from creator's allowedUsers (creator app scope only).
+    // resolveAllowedUsers converts emails → open_ids via creator's Lark client.
+    const creatorCfg = fullConfigs.find(c => c.larkAppId === creatorLarkAppId);
+    const allowedRaw = creatorCfg?.allowedUsers ?? [];
+    const { resolveAllowedUsers } = await import('./im/lark/client.js');
+    let creatorAllowedOpenIds = [];
+    try {
+        creatorAllowedOpenIds = await resolveAllowedUsers(creatorLarkAppId, allowedRaw);
+    }
+    catch (err) {
+        console.error(`⚠️  解析 creator allowedUsers 失败: ${err?.message ?? err}（继续创建空群）`);
+    }
+    const targetOpenId = creatorAllowedOpenIds[0];
+    if (!targetOpenId) {
+        console.error('⚠️  creator bot 的 allowedUsers 没有可用 open_id — 将创建仅含 bot 的群（跳过邀请/转让/@通知）。');
+    }
+    const { createGroupWithBots } = await import('./services/group-creator.js');
+    let result;
+    try {
+        result = await createGroupWithBots({
+            creatorLarkAppId,
+            larkAppIds: resolved.larkAppIds,
+            name: name?.trim() || undefined,
+            userOpenIds: targetOpenId ? [targetOpenId] : [],
+            transferOwnerTo: targetOpenId,
+            notifyOwnerOpenId: targetOpenId,
+        });
+    }
+    catch (err) {
+        console.error(`建群失败: ${err?.message ?? err}`);
+        process.exit(1);
+    }
+    // Always stdout chatId on createChat success — even if transfer/notify
+    // partially failed, the chat exists and retrying would create duplicates.
+    process.stdout.write(`${result.chatId}\n`);
+    // Human-readable summary + warnings → stderr.
+    const link = `https://applink.feishu.cn/client/chat/open?openChatId=${encodeURIComponent(result.chatId)}`;
+    console.error(`✅ 群已创建：${link}`);
+    if (result.invalidBotIds.length > 0) {
+        console.error(`⚠️  飞书拒绝邀请的 bot: ${result.invalidBotIds.join(', ')}`);
+    }
+    if (result.invalidUserIds.length > 0) {
+        console.error(`⚠️  飞书拒绝邀请的 user: ${result.invalidUserIds.join(', ')}`);
+    }
+    if (result.transferError) {
+        console.error(`⚠️  群主转让失败 (${result.transferError}) — 当前群主仍为 creator bot`);
+    }
+    else if (result.ownerTransferredTo) {
+        console.error(`✅ 群主已转让给 ${result.ownerTransferredTo}`);
+    }
+    if (result.notifyError) {
+        console.error(`⚠️  @通知发送失败: ${result.notifyError}`);
+    }
+    else if (result.notifyMessageId) {
+        console.error(`✅ @通知已发送 (msg ${result.notifyMessageId})`);
+    }
+}
 // ─── Bots subcommand ─────────────────────────────────────────────────────────
 async function cmdBots(sub, rest) {
     process.env.SESSION_DATA_DIR ??= resolveDataDir();
@@ -2019,13 +2632,13 @@ switch (command) {
         await cmdSetup();
         break;
     case 'start':
-        cmdStart();
+        await cmdStart();
         break;
     case 'stop':
         cmdStop();
         break;
     case 'restart':
-        cmdRestart();
+        await cmdRestart();
         break;
     case 'logs':
         cmdLogs();
@@ -2036,6 +2649,9 @@ switch (command) {
     case 'upgrade':
         cmdUpgrade();
         break;
+    case 'dashboard':
+        await cmdDashboard();
+        break;
     case 'list':
     case 'ls':
         await cmdList();
@@ -2045,21 +2661,49 @@ switch (command) {
     case 'rm':
         cmdDelete();
         break;
+    case 'resume':
+        await cmdResume();
+        break;
     case 'schedule':
         await cmdSchedule(process.argv[3] ?? '', process.argv.slice(4));
         break;
     case 'send':
         await cmdSend(process.argv.slice(3));
         break;
+    case 'create-group':
+        await cmdCreateGroup(process.argv.slice(3));
+        break;
     case 'bots':
         await cmdBots(process.argv[3] ?? 'list', process.argv.slice(4));
         break;
+    case 'history':
+        await cmdHistory(process.argv.slice(3));
+        break;
+    case 'quoted':
+        await cmdQuoted(process.argv.slice(3));
+        break;
     case 'thread': {
+        // Removed in favor of `botmux history` (普通群也兼容). Friendly stderr so
+        // pre-rename scripts/skills surface the rename instead of "unknown command".
         const sub = process.argv[3] ?? '';
-        if (sub === 'messages' || sub === 'msgs')
-            await cmdThreadMessages(process.argv.slice(4));
+        console.error(sub === 'messages' || sub === 'msgs'
+            ? `\`botmux thread ${sub}\` 已重命名为 \`botmux history\` (跑普通群和话题群都用它)。`
+            : `\`botmux thread\` 已下线，请用 \`botmux history\``);
+        process.exit(1);
+        break;
+    }
+    case 'autostart': {
+        ensureConfigDir();
+        const sub = process.argv[3] ?? 'status';
+        const opts = { pkgRoot: PKG_ROOT, configDir: CONFIG_DIR, logDir: LOG_DIR };
+        if (sub === 'enable' || sub === 'install')
+            enableAutostart(opts);
+        else if (sub === 'disable' || sub === 'uninstall')
+            disableAutostart(opts);
+        else if (sub === 'status')
+            autostartStatus(opts);
         else {
-            console.error(`用法: botmux thread messages [--limit N] [--session-id ID]`);
+            console.error(`用法: botmux autostart <enable|disable|status>`);
             process.exit(1);
         }
         break;