botmux 2.13.2 → 2.15.0

package/dist/daemon.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { config } from './config.js';
-import { replyMessage, resolveAllowedUsers } from './im/lark/client.js';
+import { replyMessage, resolveAllowedUsers, sendMessage } from './im/lark/client.js';
 import { loadBotConfigs, registerBot, getBot, getAllBots, findOncallChat } from './bot-registry.js';
 import * as sessionStore from './services/session-store.js';
 import * as scheduleStore from './services/schedule-store.js';
@@ -15,7 +15,7 @@ import { parseEventMessage, resolveNonsupportMessage, stripLeadingMentions } fro
 import { expandMergeForward } from './im/lark/merge-forward.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';
@@ -28,6 +28,7 @@ import { isCallbackUrl, handleCallbackUrl } from './utils/user-token.js';
 import { getSessionWorkingDir, getProjectScanDirs, downloadResources, formatAttachmentsHint, buildNewTopicPrompt, buildFollowUpContent, buildBridgeInputContent, 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 { isBotMentionMessageHandled, markBotMentionMessageHandled } from './utils/bot-mention-dedup.js';
 // ─── State ───────────────────────────────────────────────────────────────────
 const activeSessions = new Map();
 // Cache last /repo scan results per chat for /repo <number> fallback
@@ -35,18 +36,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;
             }
@@ -55,7 +69,20 @@ 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 普通群 / p2p. The card layer carries chatId in
+    // its button values, so handleCardAction routes back via sessionKey(chatId).
+    //
+    // 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_')) {
+        return sendMessage(appId, ds?.chatId ?? anchor, content, msgType);
+    }
+    // Thread-scope (or unknown / legacy): reply in thread.
+    return replyMessage(appId, anchor, content, msgType, true);
 }
 // ─── PID file ────────────────────────────────────────────────────────────────
 function getPidFile() {
@@ -187,7 +214,8 @@ const cardDeps = {
     lastRepoScan,
 };
 // ─── Event handling ──────────────────────────────────────────────────────────
-async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkAppId) {
+async function handleNewTopic(data, ctx) {
+    const { chatId, messageId, chatType, scope, anchor, larkAppId } = ctx;
     await resolveNonsupportMessage(data, larkAppId);
     const { parsed, resources } = parseEventMessage(data);
     // Expand merge_forward: fetch sub-messages and collect their resources
@@ -200,28 +228,29 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
     const cmdContent = stripLeadingMentions(content, parsed.mentions);
     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)
     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);
+                await sessionReply(anchor, `⚠️ ${cmd} 仅 oncall owner 可执行。`, 'text', larkAppId);
                 return;
             }
             const session = sessionStore.createSession(chatId, messageId, cmdContent.substring(0, 50), chatType);
             session.larkAppId = larkAppId;
             session.ownerOpenId = senderOpenId;
             session.lastCallerOpenId = senderOpenId;
+            session.scope = scope;
             sessionStore.updateSession(session);
-            activeSessions.set(sessionKey(messageId, larkAppId), {
+            activeSessions.set(sessionKey(anchor, larkAppId), {
                 session,
                 worker: null,
                 workerPort: null,
@@ -229,6 +258,7 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
                 larkAppId,
                 chatId,
                 chatType,
+                scope,
                 spawnedAt: Date.now(),
                 cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
                 lastMessageAt: Date.now(),
@@ -236,7 +266,7 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
                 ownerOpenId: senderOpenId,
             });
             // Pass mention-stripped content so /command argument parsing works.
-            await handleCommand(cmd, messageId, { ...parsed, content: commandContent }, commandDeps, larkAppId);
+            await handleCommand(cmd, anchor, { ...parsed, content: commandContent }, commandDeps, larkAppId);
             return;
         }
     }
@@ -246,18 +276,39 @@ 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);
     }
     refreshCliVersion(botCfg.cliId, botCfg.cliPathOverride);
-    // Create session in pending-repo state — don't spawn CLI yet
+    // Create session in pending-repo state — don't spawn CLI yet.
+    // For thread-scope, rootMessageId == anchor (the thread root).
+    // For chat-scope, rootMessageId stores the seed message_id (audit only);
+    // routing keys off chatId via sessionAnchorId().
     const session = sessionStore.createSession(chatId, messageId, parsed.content.substring(0, 50), chatType);
     session.larkAppId = larkAppId;
     session.ownerOpenId = senderOpenId;
+    session.scope = scope;
     sessionStore.updateSession(session);
-    messageQueue.ensureQueue(messageId);
-    messageQueue.appendMessage(messageId, parsed);
+    messageQueue.ensureQueue(anchor);
+    messageQueue.appendMessage(anchor, parsed);
     // Oncall group: pin working dir from binding, skip repo selection entirely.
     const oncallEntry = findOncallChat(larkAppId, chatId);
+    // Cross-bot inheritance: when a sibling bot already has an active session
+    // anchored here (typical: user @s a second Claude/Aiden in a thread or 普通群
+    // for review), reuse its workingDir and skip the repo card. The same block
+    // exists in handleThreadReply's auto-create branch — both handlers can land
+    // an unowned message after the 4fec43c routing change, so the inheritance
+    // probe has to run in both places.
+    let inheritedFrom = null;
+    if (!oncallEntry) {
+        const peers = scope === 'thread'
+            ? sessionStore.findActiveSessionsByRoot(anchor)
+            : sessionStore.findActiveChatScopeSessionsByChat(chatId);
+        const peer = peers.find(p => p.larkAppId !== larkAppId && !!p.workingDir);
+        if (peer && peer.workingDir) {
+            inheritedFrom = { sessionId: peer.sessionId, larkAppId: peer.larkAppId, workingDir: peer.workingDir };
+        }
+    }
+    const pinnedWorkingDir = oncallEntry?.workingDir ?? inheritedFrom?.workingDir;
     const ds = {
         session,
         worker: null,
@@ -266,29 +317,33 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
         larkAppId,
         chatId,
         chatType,
+        scope,
         spawnedAt: Date.now(),
         cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
         lastMessageAt: Date.now(),
         hasHistory: false,
-        pendingRepo: !oncallEntry,
+        pendingRepo: !pinnedWorkingDir,
         pendingPrompt: content,
         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 });
         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
@@ -300,8 +355,8 @@ 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 {
@@ -313,7 +368,8 @@ async function handleNewTopic(data, chatId, messageId, chatType = 'group', larkA
         logger.info(`Session ${session.sessionId} ready (no projects to select), total active: ${getActiveCount()}`);
     }
 }
-async function handleThreadReply(data, rootId, larkAppId) {
+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
@@ -328,7 +384,9 @@ 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;
         }
@@ -338,40 +396,48 @@ async function handleThreadReply(data, rootId, larkAppId) {
     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: commandContent });
                 ds.lastMessageAt = Date.now();
-                logger.info(`[${rootId.substring(0, 12)}] Passthrough ${cmd} → worker`);
+                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;
+            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);
+                sessionReply(anchor, `⚠️ ${cmd} 仅 oncall owner 可执行。`, 'text', larkAppId);
                 return;
             }
             // Pass mention-stripped content so /command argument parsing works.
-            handleCommand(cmd, rootId, { ...parsed, content: commandContent }, 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;
         }
     }
@@ -382,7 +448,7 @@ 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
@@ -411,39 +477,52 @@ 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);
         session.larkAppId = larkAppId;
         session.ownerOpenId = senderOId;
         session.lastCallerOpenId = senderOId;
+        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);
+        const oncallEntry = findOncallChat(larkAppId, autoCreateChatId);
         // Cross-bot inheritance: when another bot already pinned a working dir for
-        // this thread (typical: Bot A is mid-task and @mentions Bot B for review),
+        // this anchor (typical: Bot A is mid-task and @mentions Bot B for review),
         // inherit it so we can spawn immediately with the @-content as the prompt
         // — same shape as a human-initiated start, no repo selection round-trip.
+        // Thread-scope: peer lookup is by rootMessageId.
+        // Chat-scope (普通群): peer lookup is by chatId among other bots' chat-scope
+        //   sessions in the same chat — same intent, different anchor.
         let inheritedFrom = null;
         if (!oncallEntry) {
-            const peers = sessionStore.findActiveSessionsByRoot(rootId);
+            const peers = scope === 'thread'
+                ? sessionStore.findActiveSessionsByRoot(anchor)
+                : sessionStore.findActiveChatScopeSessionsByChat(autoCreateChatId);
             const peer = peers.find(p => p.larkAppId !== larkAppId && !!p.workingDir);
             if (peer && peer.workingDir) {
                 inheritedFrom = { sessionId: peer.sessionId, larkAppId: peer.larkAppId, workingDir: peer.workingDir };
@@ -456,8 +535,9 @@ async function handleThreadReply(data, rootId, larkAppId) {
             workerPort: null,
             workerToken: null,
             larkAppId,
-            chatId,
-            chatType,
+            chatId: autoCreateChatId,
+            chatType: autoCreateChatType,
+            scope,
             spawnedAt: Date.now(),
             cliVersion: cliVersionCache.get(botCfg.cliId)?.version ?? 'unknown',
             lastMessageAt: Date.now(),
@@ -474,15 +554,15 @@ async function handleThreadReply(data, rootId, larkAppId) {
             newDs.session.workingDir = pinnedWorkingDir;
             sessionStore.updateSession(newDs.session);
         }
-        activeSessions.set(sessionKey(rootId, larkAppId), newDs);
+        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(parsed.content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, autoCreateChatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
             forkWorker(newDs, prompt);
             const reason = oncallEntry
-                ? `oncall-bound chat ${chatId}`
+                ? `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;
@@ -494,17 +574,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(parsed.content, session.sessionId, botCfg.cliId, botCfg.cliPathOverride, attachments, parsed.mentions, await getAvailableBots(larkAppId, autoCreateChatId), undefined, { name: selfBot.botName, openId: selfBot.botOpenId });
             forkWorker(newDs, prompt);
         }
         return;
@@ -539,7 +619,7 @@ async function handleThreadReply(data, rootId, larkAppId) {
             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, !!ds.adoptedFrom, false);
+            const frozenCard = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, prevTitle, ds.lastScreenContent ?? '', 'idle', dsBotCfg.cliId, prevMode, ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false);
             // Freeze through the serialization queue to avoid racing with an in-flight PATCH.
             // scheduleCardPatch replaces any stale pending item (latest-wins).
             scheduleCardPatch(ds, frozenCard);
@@ -588,8 +668,18 @@ function processBotMentionSignal(signal) {
         logger.debug(`[bot-mention] No bot found for open_id ${signal.targetBotOpenId}`);
         return;
     }
+    // Cross-path dedup: WSClient may have already enqueued this turn. messageId
+    // is the canonical key (per-message, immune to ordering between WS push and
+    // fs watch).
+    if (isBotMentionMessageHandled(signal.messageId)) {
+        logger.debug(`[bot-mention] Signal-file path skipping ${signal.messageId.substring(0, 12)}: already handled by WSClient`);
+        return;
+    }
     const targetAppId = targetBot.config.larkAppId;
-    const ds = activeSessions.get(sessionKey(signal.rootMessageId, targetAppId));
+    // Anchor depends on sender's session scope: chat-scope sessions are keyed
+    // by chatId, thread-scope by rootMessageId.
+    const anchor = signal.scope === 'chat' ? signal.chatId : signal.rootMessageId;
+    const ds = activeSessions.get(sessionKey(anchor, 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,
@@ -622,11 +712,12 @@ function processBotMentionSignal(signal) {
         ds.streamCardPending = true;
         ds.currentTurnTitle = signal.content.substring(0, 50);
         persistStreamCardState(ds);
+        markBotMentionMessageHandled(signal.messageId);
         ds.worker.send({ type: 'message', content: enrichedContent });
-        logger.info(`[bot-mention] Routed message from ${signal.senderAppId} to ${targetAppId} in thread ${signal.rootMessageId}`);
+        logger.info(`[bot-mention] Routed message from ${signal.senderAppId} to ${targetAppId} (scope=${signal.scope ?? 'thread'}, anchor=${anchor.substring(0, 12)})`);
     }
     else {
-        logger.debug(`[bot-mention] Target bot ${targetAppId} has no active worker for thread ${signal.rootMessageId}`);
+        logger.debug(`[bot-mention] Target bot ${targetAppId} has no active worker at ${signal.scope ?? 'thread'}-scope anchor ${anchor.substring(0, 12)} — WSClient auto-create path will handle it if @mention was delivered`);
     }
 }
 function isSignalForMe(signal) {
@@ -710,17 +801,6 @@ export async function startDaemon(botIndex) {
         startedAt: Date.now(),
         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();
     // Initialise worker pool with daemon callbacks
     initWorkerPool({
         sessionReply,
@@ -738,14 +818,31 @@ export async function startDaemon(botIndex) {
     // 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 (above) but the IPC server
+    // /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. Binds to 127.0.0.1 only — the dashboard
-    // sibling process is the sole consumer and runs on the same host.
+    // 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;
@@ -783,11 +880,9 @@ export async function startDaemon(botIndex) {
         // 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)),
         });
     }
     // Restore active sessions from previous run