botmux 2.9.1 → 2.9.3

package/dist/daemon.js

@@ -1,30 +1,39 @@
 import { execFileSync } from 'node:child_process';
-import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync, watch, readdirSync } from 'node:fs';
+import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { config } from './config.js';
-import { replyMessage, resolveAllowedUsers, getMessageDetail } from './im/lark/client.js';
-import { loadBotConfigs, registerBot, getBot, getAllBots, findOncallChat } from './bot-registry.js';
+import { statSync } from 'node:fs';
+import { getChatMode, replyMessage, resolveAllowedUsers, sendMessage } from './im/lark/client.js';
+import { loadBotConfigs, registerBot, getBot, getAllBots, findOncallChatForAnyBot, isChatOncallBoundForAnyBot } from './bot-registry.js';
 import * as sessionStore from './services/session-store.js';
+import * as chatFirstSeenStore from './services/chat-first-seen-store.js';
+import { autoBindOncallFromDefault } from './services/oncall-store.js';
+import * as scheduleStore from './services/schedule-store.js';
 import * as messageQueue from './services/message-queue.js';
-import { parseEventMessage, parseApiMessage, extractResources, resolveNonsupportMessage, createImgNumberer, unwrapUserDslContent, stripLeadingMentions } from './im/lark/message-parser.js';
+import { parseEventMessage, resolveNonsupportMessage, stripLeadingMentions } from './im/lark/message-parser.js';
+import { expandMergeForward } from './im/lark/merge-forward.js';
+import { buildQuoteHint } from './im/lark/quote-hint.js';
 import { logger } from './utils/logger.js';
 import { ensureCjkFontsInstalled } from './utils/font-installer.js';
-import { sessionKey } from './core/types.js';
+import { sessionKey, sessionAnchorId } from './core/types.js';
 import * as scheduler from './core/scheduler.js';
 import { scanMultipleProjects } from './services/project-scanner.js';
 import { buildRepoSelectCard, buildStreamingCard, getCliDisplayName } from './im/lark/card-builder.js';
 import { createCliAdapterSync } from './adapters/cli/registry.js';
-import { initWorkerPool, forkWorker, killWorker, scheduleCardPatch, setCurrentCliVersion, CARD_POSTING_SENTINEL, } from './core/worker-pool.js';
+import { initWorkerPool, setActiveSessionsRegistry, forkWorker, killWorker, scheduleCardPatch, setCurrentCliVersion, CARD_POSTING_SENTINEL, parkStreamCard, closeSession as closeSessionHelper, } from './core/worker-pool.js';
+import { setBotName, setLarkAppId, startIpcServer } from './core/dashboard-ipc-server.js';
 import { saveFrozenCards } from './services/frozen-card-store.js';
-import { DAEMON_COMMANDS, PASSTHROUGH_COMMANDS, handleCommand } from './core/command-handler.js';
+import { DAEMON_COMMANDS, PASSTHROUGH_COMMANDS, handleCommand, parseSlashCommandInvocation, parseForceTopicInvocation } from './core/command-handler.js';
+import { findInheritablePeer } from './core/inherit-peer.js';
 import { isCallbackUrl, handleCallbackUrl } from './utils/user-token.js';
-import { getSessionWorkingDir, getProjectScanDirs, downloadResources, formatAttachmentsHint, buildNewTopicPrompt, buildFollowUpContent, getAvailableBots, restoreActiveSessions, executeScheduledTask, persistStreamCardState, } from './core/session-manager.js';
+import { getSessionWorkingDir, getProjectScanDirs, expandHome, downloadResources, formatAttachmentsHint, buildNewTopicPrompt, buildFollowUpContent, buildBridgeInputContent, buildReforkPrompt, getAvailableBots, restoreActiveSessions, executeScheduledTask, persistStreamCardState, } from './core/session-manager.js';
 import { handleCardAction } from './im/lark/card-handler.js';
-import { isBotMentioned, probeBotOpenId, startLarkEventDispatcher, writeBotInfoFile, canOperate } from './im/lark/event-dispatcher.js';
+import { isBotMentioned, probeBotOpenId, startLarkEventDispatcher, writeBotInfoFile, canOperate, isKnownPeerBot, checkRequiredScopes } from './im/lark/event-dispatcher.js';
+import { markSessionActivity } from './core/session-activity.js';
 // ─── State ───────────────────────────────────────────────────────────────────
 const activeSessions = new Map();
 // Cache last /repo scan results per chat for /repo <number> fallback
@@ -32,18 +41,31 @@ const lastRepoScan = new Map();
 const cliVersionCache = new Map();
 const VERSION_CHECK_INTERVAL = 60_000; // cache 1 min
 /**
- * Reply to a message, automatically using reply_in_thread for p2p sessions.
- * Always reply in thread to create/continue a topic.
- * This ensures topic-style replies in all chat types (p2p, group, topic group).
+ * Reply into a session — scope-aware.
+ *
+ * `anchor` is whatever the caller has at hand:
+ *   - thread-scope sessions → rootMessageId
+ *   - chat-scope sessions  → chatId
+ *
+ * Behaviour:
+ *   - thread-scope (or no matching DS, the legacy default) → reply with
+ *     reply_in_thread=true to the anchor message_id
+ *   - chat-scope                                           → send a plain
+ *     message to ds.chatId (no reply, no thread). Cards / button values
+ *     embed the chatId so handleCardAction can route back into the same
+ *     session.
+ *
+ * Lark message ids start with `om_` and chat ids with `oc_`, so the two
+ * address spaces never collide; the lookup just tries both.
  */
-async function sessionReply(rootId, content, msgType = 'text', larkAppId) {
+async function sessionReply(anchor, content, msgType = 'text', larkAppId) {
     let ds;
     if (larkAppId) {
-        ds = activeSessions.get(sessionKey(rootId, larkAppId));
+        ds = activeSessions.get(sessionKey(anchor, larkAppId));
     }
     else {
         for (const s of activeSessions.values()) {
-            if (s.session.rootMessageId === rootId) {
+            if (sessionAnchorId(s) === anchor) {
                 ds = s;
                 break;
             }
@@ -52,7 +74,33 @@ async function sessionReply(rootId, content, msgType = 'text', larkAppId) {
     const appId = larkAppId ?? ds?.larkAppId ?? getAllBots()[0]?.config.larkAppId;
     if (!appId)
         throw new Error('No bot configured');
-    return replyMessage(appId, rootId, content, msgType, true);
+    // Chat-scope: post a plain message to the chat. No reply_in_thread → keeps
+    // the conversation flat in 普通群. The card layer carries chatId in its button
+    // values, so handleCardAction routes back via sessionKey(chatId).
+    //
+    // If a 普通群 is converted to a 话题群 while this chat-scope session is alive,
+    // a top-level sendMessage would create a brand-new topic for every reply.
+    // Force-refresh chat_mode at dispatch time and fall back to the session's
+    // original triggering message as the thread anchor.
+    //
+    // Detect chat-scope from either ds.scope or anchor's `oc_` prefix. The
+    // prefix fallback covers the close-button race: card-handler deletes ds
+    // from activeSessions BEFORE sending the close-confirmation reply, so by
+    // the time we run, ds is gone — but the anchor (chatId, oc_xxx) is enough
+    // to know we should sendMessage, not reply_in_thread to a non-message-id.
+    if (ds?.scope === 'chat' || anchor.startsWith('oc_')) {
+        const chatId = ds?.chatId ?? anchor;
+        if (ds?.scope === 'chat' && ds.session.rootMessageId) {
+            const mode = await getChatMode(appId, chatId, { forceRefresh: true });
+            if (mode === 'topic') {
+                logger.warn(`[routing] Chat-scope session ${ds.session.sessionId.substring(0, 8)} is now topic-mode; replying in original thread ${ds.session.rootMessageId.substring(0, 12)}`);
+                return replyMessage(appId, ds.session.rootMessageId, content, msgType, true);
+            }
+        }
+        return sendMessage(appId, chatId, content, msgType);
+    }
+    // Thread-scope (or unknown / legacy): reply in thread.
+    return replyMessage(appId, anchor, content, msgType, true);
 }
 // ─── PID file ────────────────────────────────────────────────────────────────
 function getPidFile() {
@@ -107,6 +155,26 @@ function removePidFile() {
         logger.info('PID file removed');
     }
 }
+// ─── Daemon descriptor (dashboard registry) ─────────────────────────────────
+// Each per-bot daemon publishes a self-descriptor JSON at
+// ~/.botmux/data/dashboard-daemons/<larkAppId>.json so the dashboard sibling
+// process can discover all running daemons. The file is touched every 30s as
+// a heartbeat (mtime drives offline detection) and removed on graceful exit.
+const DAEMON_REGISTRY_DIR = join(homedir(), '.botmux', 'data', 'dashboard-daemons');
+function writeDaemonDescriptor(d) {
+    mkdirSync(DAEMON_REGISTRY_DIR, { recursive: true });
+    const fp = join(DAEMON_REGISTRY_DIR, `${d.larkAppId}.json`);
+    writeFileSync(fp, JSON.stringify(d), { mode: 0o600 });
+}
+function removeDaemonDescriptor(larkAppId) {
+    const fp = join(DAEMON_REGISTRY_DIR, `${larkAppId}.json`);
+    if (existsSync(fp)) {
+        try {
+            unlinkSync(fp);
+        }
+        catch { /* ignore */ }
+    }
+}
 // ─── Version tracking ────────────────────────────────────────────────────────
 function refreshCliVersion(cliId, cliPathOverride) {
     const now = Date.now();
@@ -150,6 +218,39 @@ function getActiveCount() {
     }
     return count;
 }
+/**
+ * Freeze the previous turn's streaming card at "idle" and mark a new turn so the
+ * next screen_update from the worker POSTs a fresh streaming card instead of
+ * PATCH-ing the previous one. Shared by the normal-message path and the
+ * passthrough slash-command path (/model, /clear, /compact, etc.) — without
+ * this, passthrough commands silently PATCH the previous card and the user
+ * sees no visible response.
+ */
+function beginNewTurn(ds, title) {
+    if (ds.streamCardId && ds.workerPort) {
+        const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
+        const dsBotCfg = getBot(ds.larkAppId).config;
+        const prevTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(dsBotCfg.cliId);
+        const prevMode = ds.displayMode ?? 'hidden';
+        const frozenCard = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, prevTitle, ds.lastScreenContent ?? '', 'idle', dsBotCfg.cliId, prevMode, ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false);
+        scheduleCardPatch(ds, frozenCard);
+        if (ds.streamCardNonce && ds.streamCardId !== CARD_POSTING_SENTINEL) {
+            if (!ds.frozenCards)
+                ds.frozenCards = new Map();
+            ds.frozenCards.set(ds.streamCardNonce, {
+                messageId: ds.streamCardId,
+                content: ds.lastScreenContent ?? '',
+                title: prevTitle,
+                displayMode: prevMode,
+                imageKey: ds.currentImageKey,
+            });
+            saveFrozenCards(ds.session.sessionId, ds.frozenCards);
+        }
+    }
+    ds.streamCardPending = true;
+    ds.currentTurnTitle = title.substring(0, 50);
+    persistStreamCardState(ds);
+}
 // Dependencies passed to command-handler
 const commandDeps = {
     activeSessions,
@@ -163,71 +264,66 @@ const cardDeps = {
     sessionReply,
     lastRepoScan,
 };
-// ─── Merge-forward expansion ────────────────────────────────────────────────
+// ─── Event handling ──────────────────────────────────────────────────────────
 /**
- * Expand a merge_forward message by fetching sub-messages via Lark API.
- * Replaces parsed.content with readable text and collects additional resources.
+ * Default-oncall is a uniform forward-only policy: whenever the toggle is
+ * on, ANY chat the bot is currently in — old or newly added, doesn't matter —
+ * gets auto-bound to the configured workingDir on its next observed topic,
+ * unless it's already bound (`findOncallChatForAnyBot` upstream) or the user
+ * has opted out via tombstone.
+ *
+ * Returns the binding entry on success, undefined when any precondition
+ * fails or the lock-internal authoritative check (in `autoBindOncallFromDefault`)
+ * sees a concurrent tombstone / existing binding.
  */
-async function expandMergeForward(larkAppId, messageId, parsed, depth = 0, numberer = createImgNumberer()) {
-    const MAX_DEPTH = 5;
-    const extraResources = [];
+async function maybeAutoBindDefaultOncall(larkAppId, chatId, chatType) {
+    if (chatType !== 'group')
+        return undefined; // oncall is group-only by design
+    const bot = getBot(larkAppId);
+    const def = bot.config.defaultOncall;
+    if (!def?.enabled || !def.workingDir)
+        return undefined;
+    // Fast-path tombstone check against the in-memory snapshot — avoids taking
+    // the lock when we already know we'd skip. The AUTHORITATIVE re-check lives
+    // inside autoBindOncallFromDefault under the file lock, so a race with a
+    // concurrent unbind (which writes the tombstone) is still safe.
+    const autobound = bot.config.defaultOncallAutoboundChats ?? [];
+    if (autobound.includes(chatId))
+        return undefined;
+    // Validate workingDir at fire time too — directory might have been
+    // deleted/moved since the dashboard save validated it. Skipping (vs.
+    // crashing) lets the user fix the path without losing other bot config.
+    const resolved = expandHome(def.workingDir);
+    let isDir = false;
     try {
-        // Lark returns HTTP 500 if user_card_content is combined with a
-        // merge_forward message_id, so explicitly disable it here. Interactive
-        // sub-messages come back in the simplified "Format A" shape which our
-        // card extractor already handles.
-        const detail = await getMessageDetail(larkAppId, messageId, { userCardContent: false });
-        const subMessages = (detail?.items ?? []).filter((m) => m.upper_message_id === messageId);
-        if (subMessages.length === 0)
-            return { extraResources };
-        const parts = ['[转发消息]'];
-        for (const msg of subMessages) {
-            const senderLabel = msg.sender?.sender_type === 'app' ? '机器人' : (msg.sender?.id ?? '未知');
-            parts.push(`--- ${senderLabel} ---`);
-            // Interactive sub-messages may still carry the simplified "upgrade your
-            // client" fallback; unwrap user_dsl before any extraction so both the
-            // resource pass and text pass see the real v2 body.
-            // Interactive sub-messages arrive via REST as a simplified fallback.
-            // Lark's im.message.get never returns user_dsl (even for the bot's own
-            // messages, even via direct id lookup), so we can only unwrap when a
-            // user_dsl somehow got through. For third-party cards whose simplified
-            // form is the "请升级至最新版本客户端" fallback, the real body is
-            // unrecoverable from REST.
-            if (msg.msg_type === 'interactive') {
-                const unwrapped = unwrapUserDslContent(msg.body?.content ?? '');
-                if (unwrapped !== null) {
-                    msg.body = { ...(msg.body ?? {}), content: unwrapped };
-                }
-            }
-            // Resources first so the numberer assigns [图片 N] in attachment order;
-            // text extraction below reuses those numbers. Do NOT override messageId —
-            // Lark requires the parent merge_forward's message_id to download
-            // resources (error 234003 if sub-message ID is used).
-            const subResources = extractResources(msg.msg_type ?? 'text', msg.body?.content ?? '', numberer);
-            extraResources.push(...subResources);
-            // Recursively expand nested merge_forward
-            if (msg.msg_type === 'merge_forward' && depth < MAX_DEPTH) {
-                const nested = { content: '[合并转发消息]', msgType: 'merge_forward', messageId: msg.message_id, rootId: '', senderId: msg.sender?.id ?? '', senderType: msg.sender?.sender_type ?? '', createTime: msg.create_time ?? '', mentions: [] };
-                const { extraResources: nestedResources } = await expandMergeForward(larkAppId, msg.message_id, nested, depth + 1, numberer);
-                parts.push(nested.content);
-                extraResources.push(...nestedResources);
-            }
-            else {
-                const sub = parseApiMessage(msg, numberer);
-                parts.push(sub.content);
-            }
-        }
-        parsed.content = parts.join('\n');
-        parsed.msgType = 'merge_forward_expanded';
+        isDir = statSync(resolved).isDirectory();
     }
-    catch (err) {
-        logger.warn(`Failed to expand merge_forward ${messageId}: ${err}`);
-        // Keep original placeholder content
+    catch { /* not a dir */ }
+    if (!isDir) {
+        logger.warn(`[${larkAppId}] defaultOncall workingDir invalid (${resolved}); ` +
+            `skipping auto-bind for chat=${chatId}`);
+        return undefined;
+    }
+    const r = await autoBindOncallFromDefault(larkAppId, chatId, def.workingDir);
+    if (!r.ok) {
+        logger.warn(`[${larkAppId}] defaultOncall auto-bind failed: chat=${chatId} reason=${r.reason}`);
+        return undefined;
+    }
+    if (r.skipped) {
+        // Lock-internal authoritative check disagreed with our fast-path —
+        // tombstone or binding raced in. Fine, just don't surface a binding.
+        logger.info(`[${larkAppId}] defaultOncall auto-bind skipped chat=${chatId} reason=${r.skipped}`);
+        return undefined;
     }
-    return { extraResources };
+    logger.info(`[${larkAppId}] defaultOncall auto-bound chat=${chatId} → ${def.workingDir}`);
+    return r.entry;
 }
-// ─── Event handling ──────────────────────────────────────────────────────────
-async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkAppId) {
+async function handleNewTopic(data, ctx) {
+    const { chatId, messageId, chatType, larkAppId } = ctx;
+    // scope/anchor are mutable here: `/t` / `/topic` may flip a 普通群 chat-scope
+    // routing into thread-scope so the bot's first reply seeds a Lark thread.
+    let scope = ctx.scope;
+    let anchor = ctx.anchor;
     await resolveNonsupportMessage(data, larkAppId);
     const { parsed, resources } = parseEventMessage(data);
     // Expand merge_forward: fetch sub-messages and collect their resources
@@ -235,32 +331,62 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
         const { extraResources } = await expandMergeForward(larkAppId, messageId, parsed);
         resources.push(...extraResources);
     }
-    const content = parsed.content.trim();
+    let content = parsed.content.trim();
     // Strip leading @<bot> mentions so "@bot /oncall bind" is recognized as a command.
-    const cmdContent = stripLeadingMentions(content, parsed.mentions);
+    let cmdContent = stripLeadingMentions(content, parsed.mentions);
+    // `/t` / `/topic` — force the bot to reply in a thread, even in 普通群.
+    // In 普通群 the inbound message is chat-scope by default; override to
+    // thread-scope anchored at the user's message_id so sessionReply() uses
+    // reply_in_thread=true and seeds a fresh Lark thread. In 话题群 / p2p
+    // (already thread-scope) it's just a prefix strip — no routing change.
+    // Empty prompt is allowed: the user can fill it in while the repo card is
+    // pending (pendingFollowUps in handleThreadReply picks up subsequent text).
+    const forceTopic = parseForceTopicInvocation(cmdContent);
+    if (forceTopic) {
+        if (scope === 'chat') {
+            scope = 'thread';
+            anchor = messageId;
+        }
+        content = forceTopic.prompt;
+        parsed.content = forceTopic.prompt;
+        cmdContent = forceTopic.prompt;
+        logger.info(`[/t] Force-topic invocation: prompt="${forceTopic.prompt.substring(0, 60)}" (scope=${scope}, anchor=${anchor.substring(0, 12)})`);
+    }
     const senderOpenId = data.sender?.sender_id?.open_id;
     const botCfg = getBot(larkAppId).config;
-    logger.info(`New topic: "${content.substring(0, 60)}" (resources: ${resources.length}, active: ${getActiveCount()}, messageId: ${messageId}, chatId: ${chatId}`);
+    logger.info(`New session: "${content.substring(0, 60)}" (scope=${scope}, anchor=${anchor.substring(0, 12)}, resources: ${resources.length}, active: ${getActiveCount()}, messageId: ${messageId}, chatId: ${chatId})`);
     // Intercept daemon commands in new topics (no session needed for some commands)
-    if (cmdContent.startsWith('/')) {
-        const cmd = cmdContent.split(/\s+/)[0].toLowerCase();
+    const invocation = parseSlashCommandInvocation(cmdContent);
+    if (invocation) {
+        const { cmd, content: commandContent } = invocation;
         if (PASSTHROUGH_COMMANDS.has(cmd)) {
-            await sessionReply(messageId, `${cmd} 需要在已有会话内使用（先发一条普通消息启动 CLI）。`, 'text', larkAppId);
+            await sessionReply(anchor, `${cmd} 需要在已有会话内使用（先发一条普通消息启动 CLI）。`, 'text', larkAppId);
             return;
         }
         if (DAEMON_COMMANDS.has(cmd)) {
-            // Oncall groups: any member can talk, but daemon commands (except /oncall
-            // itself which gates bind/unbind inside) are owner-only.
-            if (cmd !== '/oncall' && findOncallChat(larkAppId, chatId) && !canOperate(larkAppId, chatId, senderOpenId)) {
-                await sessionReply(messageId, `⚠️ ${cmd} 仅 oncall owner 可执行。`, 'text', larkAppId);
+            // Oncall groups: anyone can chat with the bot, but daemon commands
+            // (including /oncall itself) require allowedUsers. Treat the chat as
+            // oncall when ANY bot has it bound — sibling bots in multi-bot
+            // deployments inherit the same gate so /cd /restart /close don't slip
+            // past allowedUsers just because this bot wasn't the one that bound.
+            if (isChatOncallBoundForAnyBot(chatId) && !canOperate(larkAppId, chatId, senderOpenId)) {
+                await sessionReply(anchor, `⚠️ ${cmd} 仅 allowedUsers 可执行。`, 'text', larkAppId);
                 return;
             }
-            const session = sessionStore.createSession(chatId, messageId, cmdContent.substring(0, 50), chatType);
+            // Same rootMessageId reasoning as below in the main spawn path:
+            // thread-scope MUST anchor on the thread root or sessionAnchorId() will
+            // disagree with activeSessions's key and downstream card buttons silently
+            // break. Chat-scope keeps the inbound messageId as audit only.
+            const cmdRootIdForStore = scope === 'thread' ? anchor : messageId;
+            const session = sessionStore.createSession(chatId, cmdRootIdForStore, cmdContent.substring(0, 50), chatType);
+            const now = Date.now();
             session.larkAppId = larkAppId;
             session.ownerOpenId = senderOpenId;
             session.lastCallerOpenId = senderOpenId;
+            session.lastMessageAt = new Date(now).toISOString();
+            session.scope = scope;
             sessionStore.updateSession(session);
-            activeSessions.set(sessionKey(messageId, larkAppId), {
+            activeSessions.set(sessionKey(anchor, larkAppId), {
                 session,
                 worker: null,
                 workerPort: null,
@@ -268,14 +394,15 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
                 larkAppId,
                 chatId,
                 chatType,
-                spawnedAt: Date.now(),
+                scope,
+                spawnedAt: Date.parse(session.createdAt) || now,
                 cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
-                lastMessageAt: Date.now(),
+                lastMessageAt: now,
                 hasHistory: false,
                 ownerOpenId: senderOpenId,
             });
             // Pass mention-stripped content so /command argument parsing works.
-            await handleCommand(cmd, messageId, { ...parsed, content: cmdContent }, commandDeps, larkAppId);
+            await handleCommand(cmd, anchor, { ...parsed, content: commandContent }, commandDeps, larkAppId);
             return;
         }
     }
@@ -285,18 +412,55 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
         parsed.attachments = attachments;
     }
     if (needLogin) {
-        sessionReply(messageId, '⚠️ 部分图片/文件下载失败（缺少 User Token）。请在话题中发送 /login 授权后重新发送。', 'text', larkAppId);
+        sessionReply(anchor, '⚠️ 部分图片/文件下载失败（缺少 User Token）。请在话题中发送 /login 授权后重新发送。', 'text', larkAppId);
     }
+    // First-turn quote-reply: when the user @s the bot via Lark's "quote" UI as
+    // the very first interaction (no active session yet), the same hint that
+    // handleThreadReply prepends needs to ride along here too. Without it, the
+    // bot never learns about the quoted message_id and `botmux quoted` is dead
+    // weight on first turns. `content` (post force-topic-strip) is what the
+    // worker will see; promptContent wraps it for prompt-building paths but
+    // leaves `content` untouched for title / log substring uses.
+    const promptContent = buildQuoteHint(parsed, scope, anchor) + content;
     refreshCliVersion(botCfg.cliId, botCfg.cliPathOverride);
-    // Create session in pending-repo state — don't spawn CLI yet
-    const session = sessionStore.createSession(chatId, messageId, parsed.content.substring(0, 50), chatType);
+    // Create session in pending-repo state — don't spawn CLI yet.
+    // For thread-scope, rootMessageId == anchor (the thread root). Critical
+    // because sessionAnchorId() uses rootMessageId for thread-scope, and the
+    // session card's button payload (value.root_id) flows from there back into
+    // activeSessions.get(sessionKey(rootId, larkAppId)) — if rootMessageId is
+    // the inbound message_id instead of the thread root, every restart/close/
+    // disconnect click silently no-ops.
+    // For chat-scope, rootMessageId stores the seed message_id (audit only);
+    // routing keys off chatId via sessionAnchorId(), so any value works.
+    const rootIdForStore = scope === 'thread' ? anchor : messageId;
+    const session = sessionStore.createSession(chatId, rootIdForStore, parsed.content.substring(0, 50), chatType);
+    const now = Date.now();
     session.larkAppId = larkAppId;
     session.ownerOpenId = senderOpenId;
+    session.lastMessageAt = new Date(now).toISOString();
+    session.scope = scope;
     sessionStore.updateSession(session);
-    messageQueue.ensureQueue(messageId);
-    messageQueue.appendMessage(messageId, parsed);
-    // Oncall group: pin working dir from binding, skip repo selection entirely.
-    const oncallEntry = findOncallChat(larkAppId, chatId);
+    messageQueue.ensureQueue(anchor);
+    messageQueue.appendMessage(anchor, parsed);
+    // Oncall group: pin working dir from the chat-level binding, even if a
+    // sibling bot (running in another daemon) is the one that persisted it.
+    // Layered lookup:
+    //   1) any existing binding (this bot or sibling)
+    //   2) this bot's defaultOncall — auto-binds the chat if it's brand new
+    //      and the flag is on. Once auto-bound, the chat appears in oncallChats
+    //      so the next handleNewTopic sees it via (1).
+    let oncallEntry = findOncallChatForAnyBot(chatId);
+    if (!oncallEntry) {
+        oncallEntry = await maybeAutoBindDefaultOncall(larkAppId, chatId, chatType);
+    }
+    // Cross-bot / chat-scope inheritance: reuse a sibling session's workingDir
+    // and skip the repo card. Same block lives in handleThreadReply's auto-create
+    // branch — both handlers land unowned messages after the 4fec43c routing
+    // change. Helper is shared.
+    const inheritedFrom = !oncallEntry
+        ? findInheritablePeer({ scope, anchor, chatId, chatType, selfAppId: larkAppId })
+        : null;
+    const pinnedWorkingDir = oncallEntry?.workingDir ?? inheritedFrom?.workingDir;
     const ds = {
         session,
         worker: null,
@@ -305,29 +469,33 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
         larkAppId,
         chatId,
         chatType,
-        spawnedAt: Date.now(),
+        scope,
+        spawnedAt: Date.parse(session.createdAt) || now,
         cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
-        lastMessageAt: Date.now(),
+        lastMessageAt: now,
         hasHistory: false,
-        pendingRepo: !oncallEntry,
-        pendingPrompt: content,
+        pendingRepo: !pinnedWorkingDir,
+        pendingPrompt: promptContent,
         pendingAttachments: attachments.length > 0 ? attachments : undefined,
         pendingMentions: parsed.mentions,
         ownerOpenId: senderOpenId,
         currentTurnTitle: content.substring(0, 50),
-        workingDir: oncallEntry?.workingDir,
+        workingDir: pinnedWorkingDir,
     };
-    if (oncallEntry) {
-        ds.session.workingDir = oncallEntry.workingDir;
+    if (pinnedWorkingDir) {
+        ds.session.workingDir = pinnedWorkingDir;
         sessionStore.updateSession(ds.session);
     }
-    activeSessions.set(sessionKey(messageId, larkAppId), ds);
-    // Oncall-bound chat: spawn CLI immediately with the pinned working dir.
-    if (oncallEntry) {
+    activeSessions.set(sessionKey(anchor, larkAppId), ds);
+    // Pinned (oncall binding or inherited from sibling bot): spawn CLI immediately.
+    if (pinnedWorkingDir) {
         const selfBot = getBot(larkAppId);
-        const prompt = buildNewTopicPrompt(content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
+        const prompt = buildNewTopicPrompt(promptContent, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
         forkWorker(ds, prompt);
-        logger.info(`[${tag(ds)}] Oncall-bound chat ${chatId} → workingDir=${oncallEntry.workingDir}, skipped repo select`);
+        const reason = oncallEntry
+            ? `oncall-bound chat ${chatId}`
+            : `inherited from sibling session ${inheritedFrom.sessionId.substring(0, 8)} (app=${inheritedFrom.larkAppId ?? 'unknown'})`;
+        logger.info(`[${tag(ds)}] ${reason} → workingDir=${pinnedWorkingDir}, skipped repo select`);
         return;
     }
     // Show repo selection card
@@ -339,20 +507,56 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
     if (projects.length > 0) {
         lastRepoScan.set(chatId, projects);
         const currentCwd = getSessionWorkingDir(ds);
-        const cardJson = buildRepoSelectCard(projects, currentCwd, messageId);
-        ds.repoCardMessageId = await sessionReply(messageId, cardJson, 'interactive', larkAppId);
+        const cardJson = buildRepoSelectCard(projects, currentCwd, anchor);
+        ds.repoCardMessageId = await sessionReply(anchor, cardJson, 'interactive', larkAppId);
         logger.info(`[${tag(ds)}] Waiting for repo selection (${projects.length} projects)`);
     }
     else {
         // No projects found — skip repo selection, spawn directly
         ds.pendingRepo = false;
         const selfBot = getBot(larkAppId);
-        const prompt = buildNewTopicPrompt(content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
+        const prompt = buildNewTopicPrompt(promptContent, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
         forkWorker(ds, prompt);
         logger.info(`Session ${session.sessionId} ready (no projects to select), total active: ${getActiveCount()}`);
     }
 }
-async function handleThreadReply(data, rootId, larkAppId) {
+/** Reverse-lookup a foreign bot's display name for a sender open_id observed on
+ *  this app's WS events. Priority:
+ *    1) bot-openids-${larkAppId}.json — per-app cross-ref populated by
+ *       updateBotOpenIdCrossRef when @mentions go through us. Open_id is
+ *       per-app scoped, so this is the authoritative map for this larkAppId.
+ *    2) bots-info.json — fallback for bots not yet in our cross-ref but
+ *       registered as botmux peers (matches by their self-reported open_id;
+ *       only works when the peer's app id space coincides with ours).
+ *  Returns "Bot" if neither lookup hits — keeps the prefix readable rather
+ *  than blocking the message.
+ */
+function lookupForeignBotName(senderOpenId, larkAppId) {
+    try {
+        const fp = join(config.session.dataDir, `bot-openids-${larkAppId}.json`);
+        if (existsSync(fp)) {
+            const data = JSON.parse(readFileSync(fp, 'utf-8'));
+            for (const [name, openId] of Object.entries(data)) {
+                if (openId === senderOpenId)
+                    return name;
+            }
+        }
+    }
+    catch { /* fall through */ }
+    try {
+        const infoPath = join(config.session.dataDir, 'bots-info.json');
+        if (existsSync(infoPath)) {
+            const entries = JSON.parse(readFileSync(infoPath, 'utf-8'));
+            const hit = entries.find(e => e.botOpenId === senderOpenId);
+            if (hit)
+                return hit.botName ?? getCliDisplayName(hit.cliId);
+        }
+    }
+    catch { /* */ }
+    return 'Bot';
+}
+async function handleThreadReply(data, ctx) {
+    const { chatId: ctxChatId, chatType: ctxChatType, scope, anchor, larkAppId } = ctx;
     await resolveNonsupportMessage(data, larkAppId);
     const { parsed, resources } = parseEventMessage(data);
     // Expand merge_forward: fetch sub-messages and collect their resources
@@ -360,6 +564,34 @@ async function handleThreadReply(data, rootId, larkAppId) {
         const { extraResources } = await expandMergeForward(larkAppId, parsed.messageId, parsed);
         resources.push(...extraResources);
     }
+    // Foreign bot @mention prefix: when sender is another botmux bot，把内容包成
+    // [来自 X 的 @mention]\n<原文> 喂给 worker，让 CLI 知道这是另一个 bot 发的——
+    // 不是用户直接发的——后续不需要按"对话用户"的方式处理。signal-file 路径
+    // 删掉之前由 processBotMentionSignal 拼，现在统一在这里拼。仅影响发给
+    // worker 的 prompt 内容，title / 命令解析 / 日志还是用原 parsed.content。
+    //
+    // 检测策略走双轨：
+    //   1) `sender.sender_type === 'app' | 'bot'` —— 飞书事件标注为机器人发送。
+    //      'app' 是文档里的常规值；'bot' 是实测中跨 bot @ 卡片消息到接收方时
+    //      飞书实际给的值（与 'app' 等价对待，少依赖一次 cross-ref 学习）。
+    //   2) sender 的 open_id 在我们本 app 的 cross-ref（bot-openids-<appId>.json）
+    //      里能匹配到一个 botmux 同伴名字 —— 兜底覆盖 sender_type 又变其他取值
+    //      或者全无的边角情况，前提是之前已通过 @mention 学习链路记录过对方。
+    const senderOpenIdForPrefix = parsed.senderId || data?.sender?.sender_id?.open_id;
+    const selfBotOpenId = getBot(larkAppId).botOpenId;
+    const isBotSenderType = parsed.senderType === 'app' || parsed.senderType === 'bot';
+    const isForeignBot = !!senderOpenIdForPrefix &&
+        senderOpenIdForPrefix !== selfBotOpenId &&
+        (isBotSenderType ||
+            isKnownPeerBot(config.session.dataDir, larkAppId, senderOpenIdForPrefix));
+    const botSenderPrefix = isForeignBot
+        ? `[来自 ${lookupForeignBotName(senderOpenIdForPrefix, larkAppId)} 的 @mention]\n`
+        : '';
+    const promptContent = buildQuoteHint(parsed, scope, anchor) + botSenderPrefix + parsed.content;
+    if (isForeignBot) {
+        logger.info(`[${larkAppId}] foreign-bot @mention prefix attached: sender=${senderOpenIdForPrefix?.substring(0, 12)} ` +
+            `senderType=${parsed.senderType} via=${isBotSenderType ? 'sender_type' : 'cross-ref'}`);
+    }
     const content = parsed.content.trim();
     // Strip leading @<bot> mentions so "@bot /restart" is recognized as a command.
     const cmdContent = stripLeadingMentions(content, parsed.mentions);
@@ -367,49 +599,64 @@ async function handleThreadReply(data, rootId, larkAppId) {
     if (isCallbackUrl(content)) {
         const result = await handleCallbackUrl(content);
         if (result) {
-            replyMessage(larkAppId, parsed.messageId, JSON.stringify({ text: result }), 'text', true)
+            // Route through sessionReply so chat-scope (普通群) lands as a plain
+            // chat message instead of a forced new thread.
+            sessionReply(anchor, result, 'text', larkAppId)
                 .catch(err => logger.error(`Failed to reply login result: ${err}`));
             return;
         }
     }
     // Intercept daemon commands
-    if (cmdContent.startsWith('/')) {
-        const cmd = cmdContent.split(/\s+/)[0].toLowerCase();
+    const invocation = parseSlashCommandInvocation(cmdContent);
+    if (invocation) {
+        const { cmd, content: commandContent } = invocation;
         if (PASSTHROUGH_COMMANDS.has(cmd)) {
-            const ds = activeSessions.get(sessionKey(rootId, larkAppId));
+            const ds = activeSessions.get(sessionKey(anchor, larkAppId));
             if (ds?.worker && !ds.worker.killed) {
-                ds.worker.send({ type: 'raw_input', content: cmdContent });
-                ds.lastMessageAt = Date.now();
-                logger.info(`[${rootId.substring(0, 12)}] Passthrough ${cmd} → worker`);
+                // Mark a new turn so the CLI's response to /model, /clear, /compact, etc.
+                // shows up as a fresh streaming card instead of silently PATCH-ing the
+                // previous turn's card.
+                beginNewTurn(ds, commandContent);
+                ds.worker.send({ type: 'raw_input', content: commandContent });
+                markSessionActivity(ds);
+                logger.info(`[${anchor.substring(0, 12)}] Passthrough ${cmd} → worker`);
             }
             else {
-                sessionReply(rootId, `${cmd} 需要活跃的 CLI 进程，当前话题无运行中的会话。`, 'text', larkAppId);
+                sessionReply(anchor, `${cmd} 需要活跃的 CLI 进程，当前话题无运行中的会话。`, 'text', larkAppId);
             }
             return;
         }
         if (DAEMON_COMMANDS.has(cmd)) {
-            // Oncall owner gate for thread-reply daemon commands
-            const existingDs = activeSessions.get(sessionKey(rootId, larkAppId));
-            const threadChatId = existingDs?.chatId ?? data?.message?.chat_id;
+            // Oncall allowedUsers gate for thread-reply daemon commands
+            const existingDs = activeSessions.get(sessionKey(anchor, larkAppId));
+            const threadChatId = existingDs?.chatId ?? ctxChatId ?? data?.message?.chat_id;
             const threadSenderOpenId = parsed.senderId || data?.sender?.sender_id?.open_id;
-            if (cmd !== '/oncall' && threadChatId && findOncallChat(larkAppId, threadChatId) && !canOperate(larkAppId, threadChatId, threadSenderOpenId)) {
-                sessionReply(rootId, `⚠️ ${cmd} 仅 oncall owner 可执行。`, 'text', larkAppId);
+            if (threadChatId && isChatOncallBoundForAnyBot(threadChatId) && !canOperate(larkAppId, threadChatId, threadSenderOpenId)) {
+                sessionReply(anchor, `⚠️ ${cmd} 仅 allowedUsers 可执行。`, 'text', larkAppId);
                 return;
             }
             // Pass mention-stripped content so /command argument parsing works.
-            handleCommand(cmd, rootId, { ...parsed, content: cmdContent }, commandDeps, larkAppId);
+            handleCommand(cmd, anchor, { ...parsed, content: commandContent }, commandDeps, larkAppId);
             return;
         }
     }
-    logger.info(`Thread reply in ${rootId}: ${content.substring(0, 100)} (resources: ${resources.length})`);
-    let ds = activeSessions.get(sessionKey(rootId, larkAppId));
-    // If another bot already owns this thread, ignore unmentioned replies here as a
+    logger.info(`Reply in ${scope}-scope session ${anchor.substring(0, 12)}: ${content.substring(0, 100)} (resources: ${resources.length})`);
+    let ds = activeSessions.get(sessionKey(anchor, larkAppId));
+    // If another bot already owns this anchor, ignore unmentioned replies here as a
     // second line of defense. Explicit @mentions are still allowed to spin up/take over.
+    // For chat-scope: another bot's session in the same chat is keyed by its own chatId.
+    // For thread-scope: same rootMessageId may have peer sessions across bots.
     if (!ds) {
         const mentionedThisBot = isBotMentioned(larkAppId, data?.message ?? {}, data?.sender?.sender_id?.open_id);
-        const hasOtherBot = [...activeSessions.values()].some(s => s.session.rootMessageId === rootId && s.larkAppId !== larkAppId);
+        const hasOtherBot = [...activeSessions.values()].some(s => {
+            if (s.larkAppId === larkAppId)
+                return false;
+            if (s.scope === 'chat')
+                return s.chatId === ctxChatId && scope === 'chat';
+            return s.session.rootMessageId === anchor;
+        });
         if (hasOtherBot && !mentionedThisBot) {
-            logger.info(`[${larkAppId}] Ignoring thread ${rootId}; another bot already owns it`);
+            logger.info(`[${larkAppId}] Ignoring ${scope}-scope ${anchor}; another bot already owns it`);
             return;
         }
     }
@@ -420,13 +667,13 @@ async function handleThreadReply(data, rootId, larkAppId) {
         parsed.attachments = attachments;
     }
     if (needLogin) {
-        sessionReply(rootId, '⚠️ 部分图片/文件下载失败（缺少 User Token）。请在话题中发送 /login 授权后重新发送。', 'text', effectiveAppId);
+        sessionReply(anchor, '⚠️ 部分图片/文件下载失败（缺少 User Token）。请在话题中发送 /login 授权后重新发送。', 'text', effectiveAppId);
     }
     // Update last message time + last caller (used by `botmux send` to address
     // reply cards to whoever triggered this turn — matters in oncall groups
     // where the caller is often not the session owner).
     if (ds) {
-        ds.lastMessageAt = Date.now();
+        markSessionActivity(ds);
         const callerOpenId = parsed.senderId || data?.sender?.sender_id?.open_id;
         if (callerOpenId && ds.session.lastCallerOpenId !== callerOpenId) {
             ds.session.lastCallerOpenId = callerOpenId;
@@ -437,8 +684,8 @@ async function handleThreadReply(data, rootId, larkAppId) {
     if (ds?.pendingRepo) {
         // Enrich content with attachment hints and mention metadata (same as normal send)
         let enriched = attachments.length > 0
-            ? `${parsed.content}${formatAttachmentsHint(attachments)}`
-            : parsed.content;
+            ? `${promptContent}${formatAttachmentsHint(attachments)}`
+            : promptContent;
         if (parsed.mentions && parsed.mentions.length > 0) {
             const mentionLines = parsed.mentions.map(m => {
                 const idPart = m.openId ? ` → open_id: ${m.openId}` : '';
@@ -449,63 +696,95 @@ async function handleThreadReply(data, rootId, larkAppId) {
         if (!ds.pendingFollowUps)
             ds.pendingFollowUps = [];
         ds.pendingFollowUps.push(enriched);
-        await sessionReply(rootId, '请先在上方卡片中选择仓库，您的消息已暂存，选择后会自动发送。', 'text', larkAppId);
+        await sessionReply(anchor, '请先在上方卡片中选择仓库，您的消息已暂存，选择后会自动发送。', 'text', larkAppId);
         return;
     }
-    // Route to file queue
-    messageQueue.ensureQueue(rootId);
-    messageQueue.appendMessage(rootId, parsed);
+    // Route to file queue (keyed by anchor: rootMessageId for thread, chatId for chat)
+    messageQueue.ensureQueue(anchor);
+    messageQueue.appendMessage(anchor, parsed);
     if (!ds) {
-        // No active session for this thread — auto-create with repo selection
-        if (activeSessions.has(sessionKey(rootId, larkAppId))) {
-            logger.info(`[${larkAppId}] Session already exists for thread ${rootId}, skipping auto-create`);
+        // No active session at this anchor — auto-create. This branch is mostly a
+        // safety net; the dispatcher routes here only when isSessionOwner() returns
+        // true, but races (between check and execution, or session-closed events)
+        // can land us here.
+        if (activeSessions.has(sessionKey(anchor, larkAppId))) {
+            logger.info(`[${larkAppId}] Session already exists for ${scope}-scope ${anchor}, skipping auto-create`);
             return;
         }
-        const chatId = data?.message?.chat_id ?? '';
-        const chatType = (data?.message?.chat_type === 'p2p' ? 'p2p' : 'group');
+        const autoCreateChatId = ctxChatId ?? data?.message?.chat_id ?? '';
+        const autoCreateChatType = ctxChatType ?? (data?.message?.chat_type === 'p2p' ? 'p2p' : 'group');
         const botCfg = getBot(larkAppId).config;
-        logger.info(`No active session for thread ${rootId}, auto-creating new session...`);
+        logger.info(`No active session for ${scope}-scope ${anchor}, auto-creating new session...`);
         refreshCliVersion(botCfg.cliId, botCfg.cliPathOverride);
         const senderOId = data.sender?.sender_id?.open_id;
-        const session = sessionStore.createSession(chatId, rootId, parsed.content.substring(0, 50), chatType);
+        // For thread-scope: rootMessageId = anchor (real thread root).
+        // For chat-scope:   rootMessageId = the message_id that triggered this auto-create
+        //                   (used as audit trail; routing key is chatId).
+        const rootIdForStore = scope === 'thread' ? anchor : parsed.messageId;
+        const session = sessionStore.createSession(autoCreateChatId, rootIdForStore, parsed.content.substring(0, 50), autoCreateChatType);
+        const now = Date.now();
         session.larkAppId = larkAppId;
         session.ownerOpenId = senderOId;
         session.lastCallerOpenId = senderOId;
+        session.lastMessageAt = new Date(now).toISOString();
+        session.scope = scope;
         sessionStore.updateSession(session);
-        // Oncall group: pin working dir from binding, skip repo selection entirely
-        // (mirrors handleNewTopic — auto-create was missing this check).
-        const oncallEntry = findOncallChat(larkAppId, chatId);
+        // Oncall group: pin working dir from the chat-level binding, even if a
+        // sibling bot (running in another daemon) is the one that persisted it.
+        // Defaults auto-bind path mirrors handleNewTopic — keep both call sites
+        // in sync (this is the auto-create branch that fires when routing lands
+        // here without an active session, e.g. chat-scope first-reply paths).
+        let oncallEntry = findOncallChatForAnyBot(autoCreateChatId);
+        if (!oncallEntry) {
+            oncallEntry = await maybeAutoBindDefaultOncall(larkAppId, autoCreateChatId, autoCreateChatType);
+        }
+        // Cross-bot / chat-scope inheritance — see findInheritablePeer comments.
+        const inheritedFrom = !oncallEntry
+            ? findInheritablePeer({
+                scope,
+                anchor,
+                chatId: autoCreateChatId,
+                chatType: autoCreateChatType,
+                selfAppId: larkAppId,
+            })
+            : null;
+        const pinnedWorkingDir = oncallEntry?.workingDir ?? inheritedFrom?.workingDir;
         const newDs = {
             session,
             worker: null,
             workerPort: null,
             workerToken: null,
             larkAppId,
-            chatId,
-            chatType,
-            spawnedAt: Date.now(),
+            chatId: autoCreateChatId,
+            chatType: autoCreateChatType,
+            scope,
+            spawnedAt: Date.parse(session.createdAt) || now,
             cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
-            lastMessageAt: Date.now(),
+            lastMessageAt: now,
             hasHistory: false,
-            pendingRepo: !oncallEntry,
-            pendingPrompt: parsed.content,
+            pendingRepo: !pinnedWorkingDir,
+            pendingPrompt: promptContent,
             pendingAttachments: attachments.length > 0 ? attachments : undefined,
             pendingMentions: parsed.mentions,
             ownerOpenId: senderOId,
             currentTurnTitle: parsed.content.substring(0, 50),
-            workingDir: oncallEntry?.workingDir,
+            workingDir: pinnedWorkingDir,
         };
-        if (oncallEntry) {
-            newDs.session.workingDir = oncallEntry.workingDir;
+        if (pinnedWorkingDir) {
+            newDs.session.workingDir = pinnedWorkingDir;
             sessionStore.updateSession(newDs.session);
         }
-        activeSessions.set(sessionKey(rootId, larkAppId), newDs);
-        // Oncall-bound chat: spawn CLI immediately with the pinned working dir.
-        if (oncallEntry) {
+        activeSessions.set(sessionKey(anchor, larkAppId), newDs);
+        // Pinned (oncall binding or inherited from peer bot in same thread):
+        // spawn CLI immediately, skip repo selection.
+        if (pinnedWorkingDir) {
             const selfBot = getBot(larkAppId);
-            const prompt = buildNewTopicPrompt(parsed.content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
+            const prompt = buildNewTopicPrompt(promptContent, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, autoCreateChatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
             forkWorker(newDs, prompt);
-            logger.info(`[${tag(newDs)}] Oncall-bound chat ${chatId} → workingDir=${oncallEntry.workingDir}, skipped repo select`);
+            const reason = oncallEntry
+                ? `oncall-bound chat ${autoCreateChatId}`
+                : `inherited from peer session ${inheritedFrom.sessionId.substring(0, 8)} (app=${inheritedFrom.larkAppId ?? 'unknown'})`;
+            logger.info(`[${tag(newDs)}] ${reason} → workingDir=${pinnedWorkingDir}, skipped repo select`);
             return;
         }
         // Show repo selection card (same as handleNewTopic)
@@ -515,17 +794,17 @@ async function handleThreadReply(data, rootId, larkAppId) {
             projects = scanMultipleProjects(scanDirs2);
         }
         if (projects.length > 0) {
-            lastRepoScan.set(chatId, projects);
+            lastRepoScan.set(autoCreateChatId, projects);
             const currentCwd = getSessionWorkingDir(newDs);
-            const cardJson = buildRepoSelectCard(projects, currentCwd, rootId);
-            newDs.repoCardMessageId = await sessionReply(rootId, cardJson, 'interactive', larkAppId);
+            const cardJson = buildRepoSelectCard(projects, currentCwd, anchor);
+            newDs.repoCardMessageId = await sessionReply(anchor, cardJson, 'interactive', larkAppId);
             logger.info(`[${tag(newDs)}] Waiting for repo selection (${projects.length} projects)`);
         }
         else {
             // No projects found — skip repo selection, spawn directly
             newDs.pendingRepo = false;
             const selfBot = getBot(larkAppId);
-            const prompt = buildNewTopicPrompt(parsed.content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, chatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
+            const prompt = buildNewTopicPrompt(promptContent, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, autoCreateChatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
             forkWorker(newDs, prompt);
         }
         return;
@@ -533,41 +812,30 @@ async function handleThreadReply(data, rootId, larkAppId) {
     // Send message to worker via IPC
     if (ds.worker && !ds.worker.killed) {
         const dsBotCfgForMsg = getBot(ds.larkAppId).config;
-        const msgContent = buildFollowUpContent(parsed.content, ds.session.sessionId, {
-            attachments,
-            mentions: parsed.mentions,
-            isAdoptMode: !!ds.adoptedFrom,
-            cliId: dsBotCfgForMsg.cliId,
-            cliPathOverride: dsBotCfgForMsg.cliPathOverride,
-        });
-        // Freeze the previous turn's card at "idle" before starting a new turn
-        if (ds.streamCardId && ds.workerPort) {
-            const readUrl = `http://${config.web.externalHost}:${ds.workerPort}`;
-            const dsBotCfg = getBot(ds.larkAppId).config;
-            const prevTitle = ds.currentTurnTitle || ds.session.title || getCliDisplayName(dsBotCfg.cliId);
-            const prevMode = ds.displayMode ?? 'hidden';
-            const frozenCard = buildStreamingCard(ds.session.sessionId, ds.session.rootMessageId, readUrl, prevTitle, ds.lastScreenContent ?? '', 'idle', dsBotCfg.cliId, prevMode, ds.streamCardNonce, ds.currentImageKey);
-            // Freeze through the serialization queue to avoid racing with an in-flight PATCH.
-            // scheduleCardPatch replaces any stale pending item (latest-wins).
-            scheduleCardPatch(ds, frozenCard);
-            // Cache frozen card data so historical cards can still be toggled (expand/collapse)
-            if (ds.streamCardNonce && ds.streamCardId !== CARD_POSTING_SENTINEL) {
-                if (!ds.frozenCards)
-                    ds.frozenCards = new Map();
-                ds.frozenCards.set(ds.streamCardNonce, {
-                    messageId: ds.streamCardId,
-                    content: ds.lastScreenContent ?? '',
-                    title: prevTitle,
-                    displayMode: prevMode,
-                    imageKey: ds.currentImageKey,
-                });
-                saveFrozenCards(ds.session.sessionId, ds.frozenCards);
-            }
-        }
-        // Mark new turn — next screen_update will create a fresh streaming card
-        ds.streamCardPending = true;
-        ds.currentTurnTitle = parsed.content.substring(0, 50);
-        persistStreamCardState(ds);
+        // Adopt mode: the adopted CLI is the user's external process and was
+        // never injected with botmux's skill / system prompt. Sending it the
+        // `<user_message>` / `<botmux_reminder>` / `<session_id>` wrappers
+        // surfaces those tags verbatim in its UI (the user reported Codex
+        // showing raw XML on every Lark message). Use the bridge raw-input
+        // builder for ALL adopt sessions regardless of cliId — transcript
+        // harvest (Claude bridge or Codex bridge) handles the reply path
+        // out-of-band.
+        const isBridge = !!ds.adoptedFrom;
+        const selfBot = getBot(ds.larkAppId);
+        const msgContent = isBridge
+            ? buildBridgeInputContent(promptContent, {
+                attachments,
+                mentions: parsed.mentions,
+                selfMention: { name: selfBot.botName, openId: selfBot.botOpenId },
+            })
+            : buildFollowUpContent(promptContent, ds.session.sessionId, {
+                attachments,
+                mentions: parsed.mentions,
+                isAdoptMode: false,
+                cliId: dsBotCfgForMsg.cliId,
+                cliPathOverride: dsBotCfgForMsg.cliPathOverride,
+            });
+        beginNewTurn(ds, parsed.content);
         ds.worker.send({ type: 'message', content: msgContent });
     }
     else {
@@ -576,104 +844,33 @@ async function handleThreadReply(data, rootId, larkAppId) {
         // card instead of PATCHing the previous turn's card in place.
         logger.info(`[${tag(ds)}] Worker not running, re-forking...`);
         ds.currentTurnTitle = parsed.content.substring(0, 50);
+        // The cosmetic freeze step (above) is gated on a live worker. With no
+        // worker we just park the current card in frozenCards — the upcoming
+        // new POST will recall it. Parking instead of deleting preserves the
+        // "old card stays until a new one is live" invariant: if fork /
+        // worker_ready / POST fails, the user still sees the previous card.
+        parkStreamCard(ds);
         ds.streamCardId = undefined;
         ds.streamCardNonce = undefined;
         persistStreamCardState(ds);
-        forkWorker(ds, parsed.content, ds.hasHistory);
-    }
-}
-function processBotMentionSignal(signal) {
-    // Find the target bot by open_id
-    const targetBot = getAllBots().find(b => b.botOpenId === signal.targetBotOpenId);
-    if (!targetBot) {
-        logger.debug(`[bot-mention] No bot found for open_id ${signal.targetBotOpenId}`);
-        return;
-    }
-    const targetAppId = targetBot.config.larkAppId;
-    const ds = activeSessions.get(sessionKey(signal.rootMessageId, targetAppId));
-    if (ds && ds.worker && !ds.worker.killed) {
-        // Target bot has an active session in this thread — send the message.
-        // Look up sender name from bots-info.json (each daemon only registers its own bot,
-        // so getAllBots() won't find other bots).
-        let senderName = 'Bot';
-        try {
-            const infoPath = join(config.session.dataDir, 'bots-info.json');
-            if (existsSync(infoPath)) {
-                const entries = JSON.parse(readFileSync(infoPath, 'utf-8'));
-                const sender = entries.find(e => e.larkAppId === signal.senderAppId);
-                if (sender)
-                    senderName = sender.botName ?? getCliDisplayName(sender.cliId);
-            }
-        }
-        catch { /* ignore */ }
-        const enrichedParts = [`[来自 ${senderName} 的 @mention]\n${signal.content}`];
-        if (!ds.adoptedFrom) {
-            const mentionBotCfg = getBot(ds.larkAppId).config;
-            const mentionAdapter = createCliAdapterSync(mentionBotCfg.cliId, mentionBotCfg.cliPathOverride);
-            if (!mentionAdapter.injectsSessionContext) {
-                enrichedParts.push(`Session ID: ${ds.session.sessionId}`);
-            }
-        }
-        const enrichedContent = enrichedParts.join('\n\n');
-        ds.lastMessageAt = Date.now();
-        ds.streamCardPending = true;
-        ds.currentTurnTitle = signal.content.substring(0, 50);
-        persistStreamCardState(ds);
-        ds.worker.send({ type: 'message', content: enrichedContent });
-        logger.info(`[bot-mention] Routed message from ${signal.senderAppId} to ${targetAppId} in thread ${signal.rootMessageId}`);
-    }
-    else {
-        logger.debug(`[bot-mention] Target bot ${targetAppId} has no active worker for thread ${signal.rootMessageId}`);
-    }
-}
-function isSignalForMe(signal) {
-    return getAllBots().some(b => b.botOpenId === signal.targetBotOpenId);
-}
-function startBotMentionWatcher() {
-    const signalDir = join(config.session.dataDir, 'bot-mentions');
-    if (!existsSync(signalDir))
-        mkdirSync(signalDir, { recursive: true });
-    // Process any existing signal files (from before daemon started)
-    try {
-        for (const file of readdirSync(signalDir)) {
-            if (!file.endsWith('.json'))
-                continue;
-            const filePath = join(signalDir, file);
-            try {
-                const signal = JSON.parse(readFileSync(filePath, 'utf-8'));
-                if (!isSignalForMe(signal))
-                    continue; // not for this daemon, leave for target
-                unlinkSync(filePath);
-                processBotMentionSignal(signal);
-            }
-            catch (err) {
-                logger.debug(`[bot-mention] Failed to process signal ${file}: ${err}`);
-            }
-        }
+        // Wrap the user message in the same `<user_message>` / `<session_id>` /
+        // `<botmux_reminder>` envelope as live-worker turns. Without this, the
+        // initial prompt that worker queues for the freshly-spawned CLI is the
+        // raw user text — the CLI sees no botmux routing context and stops calling
+        // `botmux send`, posting answers to its own terminal instead. Hits resume
+        // (after /close) and daemon-restart paths; both go through this branch
+        // because worker=null at that point.
+        const dsBotCfgForFork = getBot(ds.larkAppId).config;
+        const selfBot = getBot(ds.larkAppId);
+        const wrappedPrompt = buildReforkPrompt(ds, promptContent, {
+            attachments,
+            mentions: parsed.mentions,
+            cliId: dsBotCfgForFork.cliId,
+            cliPathOverride: dsBotCfgForFork.cliPathOverride,
+            selfMention: { name: selfBot.botName, openId: selfBot.botOpenId },
+        });
+        forkWorker(ds, wrappedPrompt, ds.hasHistory);
     }
-    catch { /* ignore */ }
-    // Watch for new signal files
-    watch(signalDir, (event, filename) => {
-        if (event !== 'rename' || !filename?.endsWith('.json'))
-            return;
-        const filePath = join(signalDir, filename);
-        // Small delay to ensure the file is fully written
-        setTimeout(() => {
-            try {
-                if (!existsSync(filePath))
-                    return; // already processed or deleted
-                const signal = JSON.parse(readFileSync(filePath, 'utf-8'));
-                if (!isSignalForMe(signal))
-                    return; // not for this daemon, leave for target
-                unlinkSync(filePath);
-                processBotMentionSignal(signal);
-            }
-            catch (err) {
-                logger.debug(`[bot-mention] Failed to process signal ${filename}: ${err}`);
-            }
-        }, 50);
-    });
-    logger.info(`[bot-mention] Watching for signals in ${signalDir}`);
 }
 // ─── Main ────────────────────────────────────────────────────────────────────
 export async function startDaemon(botIndex) {
@@ -689,19 +886,70 @@ export async function startDaemon(botIndex) {
     const cfg = botConfigs[idx];
     registerBot(cfg);
     sessionStore.init(cfg.larkAppId);
+    chatFirstSeenStore.init(cfg.larkAppId);
+    // Watch schedules.json for external writes (e.g. `botmux schedule add`
+    // running in a separate node process) so dashboard event bus stays in sync.
+    scheduleStore.startExternalWriteWatcher();
     logger.info(`Bot ${idx}/${botConfigs.length}: ${cfg.larkAppId} (cli: ${cfg.cliId})`);
     writePidFile();
+    // Publish self-descriptor for the dashboard registry. The dashboard sibling
+    // process discovers running daemons by scanning ~/.botmux/data/dashboard-daemons/
+    // and watching for mtime updates (heartbeat) / file removal (shutdown).
+    const ipcPort = config.dashboard.ipcBasePort + idx;
+    const desc = {
+        larkAppId: cfg.larkAppId,
+        botName: cfg.larkAppId,
+        botIndex: idx,
+        ipcPort,
+        pid: process.pid,
+        startedAt: Date.now(),
+        lastHeartbeat: Date.now(),
+        // Strip email-form entries — the dashboard only needs resolved open_ids,
+        // and the email→open_id resolution below will rewrite this field.
+        resolvedAllowedUsers: getBot(cfg.larkAppId).resolvedAllowedUsers.filter(u => !u.includes('@')),
+    };
     // Initialise worker pool with daemon callbacks
     initWorkerPool({
         sessionReply,
         getSessionWorkingDir,
         getActiveCount,
         closeSession(ds) {
-            sessionStore.closeSession(ds.session.sessionId);
-            activeSessions.delete(sessionKey(ds.session.rootMessageId, ds.larkAppId));
+            // Route through the dashboard-aware helper so session.exited / session.update
+            // events fire for withdrawn-message / crash / adopt-exit teardown paths too,
+            // matching the dashboard-driven close.
+            void closeSessionHelper(ds.session.sessionId).catch(() => { });
             logger.info(`[${ds.session.sessionId.substring(0, 8)}] Session auto-closed (message withdrawn)`);
         },
     });
+    // Expose the activeSessions Map (owned by daemon) to worker-pool readers,
+    // so dashboard IPC and other consumers can list/lookup live sessions.
+    setActiveSessionsRegistry(activeSessions);
+    // Seed dashboard IPC botName with the bot's config id; the friendly name from
+    // /bot/v3/info is wired into the registry descriptor (below) but the IPC server
+    // also needs its own copy for SessionRow.botName.
+    setBotName(cfg.larkAppId);
+    setLarkAppId(cfg.larkAppId);
+    // Bind dashboard IPC HTTP server BEFORE publishing the registry descriptor.
+    // Otherwise the dashboard process can race-fetch the IPC port from the
+    // descriptor and hit ECONNREFUSED before we're listening — that left every
+    // newly-started daemon's hydrate failing on dashboard startup. Binds to
+    // 127.0.0.1 only since the dashboard sibling runs on the same host.
+    const ipcHandle = await startIpcServer({ port: ipcPort, host: '127.0.0.1' });
+    logger.info(`[dashboard-ipc] listening on 127.0.0.1:${ipcHandle.port} (bot ${idx})`);
+    // Now that the IPC port is actually listening, publish the descriptor so
+    // the dashboard can discover us and successfully fetch /api/sessions etc.
+    desc.lastHeartbeat = Date.now();
+    writeDaemonDescriptor(desc);
+    const descriptorHeartbeat = setInterval(() => {
+        desc.lastHeartbeat = Date.now();
+        try {
+            writeDaemonDescriptor(desc);
+        }
+        catch { /* best effort */ }
+    }, 30_000);
+    // Don't keep the event loop alive on this interval alone.
+    if (typeof descriptorHeartbeat.unref === 'function')
+        descriptorHeartbeat.unref();
     // Per-bot initialization
     for (const bot of getAllBots()) {
         const cfg = bot.config;
@@ -719,20 +967,58 @@ export async function startDaemon(botIndex) {
                     logger.warn(`[${cfg.larkAppId}] Failed to resolve allowedUsers: ${err.message}`);
                 }
             }
+            // Republish the descriptor with the post-resolution open_ids so the
+            // dashboard's create-group flow can pick this bot as creator using the
+            // operator's scope-correct open_id. Best-effort; the periodic heartbeat
+            // will eventually catch up too.
+            desc.resolvedAllowedUsers = bot.resolvedAllowedUsers.filter(u => !u.includes('@'));
+            try {
+                writeDaemonDescriptor(desc);
+            }
+            catch { /* best effort */ }
         }
-        // Probe bot open_id and persist to bots-info.json
+        // Probe bot open_id and persist to bots-info.json. When the friendly
+        // botName comes back from /bot/v3/info, refresh the dashboard descriptor
+        // so the registry shows "Claude" / "Codex" instead of the raw app id.
         probeBotOpenId(cfg.larkAppId).then(() => {
             writeBotInfoFile(config.session.dataDir);
+            const probedName = bot.botName;
+            if (probedName && probedName !== desc.botName) {
+                desc.botName = probedName;
+                try {
+                    writeDaemonDescriptor(desc);
+                }
+                catch { /* best effort */ }
+            }
         }).catch(err => {
-            logger.warn(`[${cfg.larkAppId}] Bot open_id probe failed: ${err.message}`);
+            // Probe runs in background and is retried by the periodic heartbeat;
+            // a single failure here is not actionable. Surface as debug only.
+            logger.debug(`[${cfg.larkAppId}] Bot open_id probe failed (will retry): ${err.message}`);
+        });
+        // Required-scope check: 启动后 best-effort 校验
+        // im:message.group_at_msg.include_bot:readonly。缺失会 logger.error +
+        // 私信 allowedUsers[0]。校验异步，跑失败不影响 daemon。
+        checkRequiredScopes(cfg.larkAppId).catch(err => {
+            logger.debug(`[${cfg.larkAppId}] required-scope check failed: ${err?.message ?? err}`);
         });
         // Start event dispatcher for this bot
         startLarkEventDispatcher(cfg.larkAppId, cfg.larkAppSecret, {
             handleCardAction: (data, appId) => handleCardAction(data, cardDeps, appId),
-            handleNewTopic: (data, chatId, messageId, chatType, appId) => handleNewTopic(data, chatId, messageId, chatType, appId),
-            handleThreadReply: (data, rootId, appId) => handleThreadReply(data, rootId, appId),
-            isSessionOwner: (rootId, appId) => {
-                return activeSessions.has(sessionKey(rootId, appId));
+            handleNewTopic: (data, ctx) => handleNewTopic(data, ctx),
+            handleThreadReply: (data, ctx) => handleThreadReply(data, ctx),
+            isSessionOwner: (anchor, appId) => activeSessions.has(sessionKey(anchor, appId)),
+            // Chat was converted 普通群 → 话题群 while we held a chat-scope session.
+            // Evict it from the routing map so subsequent inbound messages can land
+            // on a fresh thread-scope session (dispatcher already rerouted this turn
+            // to handleNewTopic). The worker is left running on purpose: the user may
+            // still have its web terminal open, and `/close` is the canonical cleanup
+            // path. Scheduler tasks tied to this session keep their `scope='chat'`
+            // semantics — that's an edge case worth following up on, not blocking
+            // the main fix.
+            onChatModeConverted: (chatId, appId) => {
+                const key = sessionKey(chatId, appId);
+                const evicted = activeSessions.delete(key);
+                logger.info(`[chat-mode-converted] ${chatId.substring(0, 12)} evicted=${evicted}; worker (if any) keeps running until /close`);
             },
         });
     }
@@ -745,17 +1031,38 @@ export async function startDaemon(botIndex) {
     scheduler.setExecuteCallback((task) => executeScheduledTask(task, activeSessions, refreshCliVersion));
     scheduler.setOwnerFilter(cfg.larkAppId, idx === 0);
     scheduler.startScheduler();
-    // Watch for bot-to-bot mention signals from MCP send_to_thread tool.
-    // Lark WSClient does not deliver events for bot-sent messages, so the MCP
-    // tool writes signal files that the daemon picks up and routes internally.
-    startBotMentionWatcher();
-    // Graceful shutdown
-    const shutdown = () => {
+    // Graceful shutdown. Sends SIGTERM (or `{type:'close'}` IPC via killWorker)
+    // to every worker, then waits up to SHUTDOWN_GRACE_MS for them to exit
+    // before sending SIGKILL to stragglers. Without the wait, daemon
+    // `process.exit(0)` races worker signal delivery — and any worker whose
+    // main thread is in a sync code path (e.g. the bridge fingerprint scan
+    // bug fixed in v2.9.2) loses the signal and survives as a ppid=1 orphan
+    // forever (we'd accumulated 841 such orphans across daemon restarts,
+    // consuming ~65 GB of RAM until manually SIGKILL'd).
+    const SHUTDOWN_GRACE_MS = 3000;
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
         logger.info(`Daemon shutting down... (active: ${getActiveCount()})`);
         scheduler.stopScheduler();
+        clearInterval(descriptorHeartbeat);
+        removeDaemonDescriptor(cfg.larkAppId);
+        ipcHandle.close().catch(() => { });
+        const pendingExits = [];
+        const survivors = [];
         for (const [, ds] of activeSessions) {
             if (ds.worker && !ds.worker.killed) {
                 logger.info(`Shutting down worker for session ${ds.session.sessionId}`);
+                const w = ds.worker;
+                // Capture the exit promise BEFORE killWorker nulls ds.worker.
+                if (w.exitCode === null && w.signalCode === null) {
+                    pendingExits.push(new Promise(resolve => {
+                        w.once('exit', () => resolve());
+                    }));
+                    survivors.push(w);
+                }
                 const backendType = ds.larkAppId
                     ? (getBot(ds.larkAppId).config.backendType ?? config.daemon.backendType)
                     : config.daemon.backendType;
@@ -763,7 +1070,7 @@ export async function startDaemon(botIndex) {
                     // Tmux mode: just kill the worker process — tmux session survives for re-attach.
                     // Worker's SIGTERM handler calls backend.kill() which only detaches.
                     try {
-                        ds.worker.kill('SIGTERM');
+                        w.kill('SIGTERM');
                     }
                     catch { /* ignore */ }
                     ds.worker = null;
@@ -775,11 +1082,35 @@ export async function startDaemon(botIndex) {
                 }
             }
         }
+        if (pendingExits.length > 0) {
+            const timeout = new Promise(resolve => setTimeout(resolve, SHUTDOWN_GRACE_MS));
+            await Promise.race([Promise.all(pendingExits), timeout]);
+            let stragglers = 0;
+            for (const w of survivors) {
+                if (w.exitCode === null && w.signalCode === null) {
+                    stragglers++;
+                    try {
+                        w.kill('SIGKILL');
+                    }
+                    catch { /* already dead */ }
+                }
+            }
+            if (stragglers > 0) {
+                logger.warn(`${stragglers}/${survivors.length} worker(s) didn't exit within ${SHUTDOWN_GRACE_MS}ms — SIGKILL'd to prevent ppid=1 orphans.`);
+            }
+        }
         removePidFile();
         process.exit(0);
     };
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', () => { shutdown().catch(err => { logger.error(`shutdown failed: ${err?.message ?? err}`); process.exit(1); }); });
+    process.on('SIGINT', () => { shutdown().catch(err => { logger.error(`shutdown failed: ${err?.message ?? err}`); process.exit(1); }); });
+    // Best-effort cleanup on plain `exit` (e.g. uncaught fatal). No worker
+    // shutdown here since the process is already on its way out — just remove
+    // the descriptor so the dashboard doesn't see a phantom daemon.
+    process.on('exit', () => {
+        clearInterval(descriptorHeartbeat);
+        removeDaemonDescriptor(cfg.larkAppId);
+    });
     logger.info('Daemon is running. Press Ctrl+C to stop.');
 }
 //# sourceMappingURL=daemon.js.map