botmux 2.9.1 → 2.9.3

package/dist/core/session-manager.js

@@ -10,7 +10,14 @@ import { createCliAdapterSync } from '../adapters/cli/registry.js';
 import { TmuxBackend } from '../adapters/backend/tmux-backend.js';
 import { getBot, getAllBots } from '../bot-registry.js';
 import { validateAdoptTarget } from './session-discovery.js';
-import { sessionKey } from './types.js';
+import { sessionKey, sessionAnchorId } from './types.js';
+import { markSessionActivity } from './session-activity.js';
+function sessionCreatedAtMs(session) {
+    return session.createdAt ? (Date.parse(session.createdAt) || Date.now()) : Date.now();
+}
+function sessionLastMessageAtMs(session) {
+    return session.lastMessageAt ? (Date.parse(session.lastMessageAt) || sessionCreatedAtMs(session)) : sessionCreatedAtMs(session);
+}
 // ─── Path helpers ────────────────────────────────────────────────────────────
 export function expandHome(p) {
     return p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
@@ -80,7 +87,10 @@ export async function downloadResources(larkAppId, messageId, resources) {
             attachments.push({ type: res.type, path: savePath, name: res.name });
         }
         catch (err) {
-            logger.warn(`Failed to download ${res.type} ${res.key}: ${err.message}`);
+            // Download failure usually means missing User Token scope or a
+            // legitimately revoked attachment — the caller surfaces `needLogin`
+            // to the user. Per-failure log stays at info to aid retries.
+            logger.info(`Failed to download ${res.type} ${res.key}: ${err.message}`);
             if (err.message?.includes('User Token'))
                 needLogin = true;
         }
@@ -109,74 +119,85 @@ export async function getAvailableBots(currentAppId, chatId) {
         return [];
     }
 }
+/** XML-escape a string for use as element text content or attribute value.
+ *  Covers the five XML-mandated entities; sufficient for our use case
+ *  (paths, names, open_ids, bot identifiers) since we never embed raw user
+ *  input in attribute values. */
+function xmlEscape(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
 export function formatAttachmentsHint(attachments) {
     if (!attachments || attachments.length === 0)
         return '';
     let imgN = 0, fileN = 0;
-    const lines = attachments.map(a => {
-        const label = a.type === 'image' ? `[图片 ${++imgN}]` : `[文件 ${++fileN}]`;
-        return `- ${label} (${a.path})`;
+    const items = attachments.map(a => {
+        const tag = a.type === 'image' ? 'image' : 'file';
+        const n = a.type === 'image' ? ++imgN : ++fileN;
+        return `  <${tag} n="${n}" path="${xmlEscape(a.path)}" />`;
     });
-    return `\n\n附件（使用 Read 工具查看，序号与正文中的 [图片 N] / [文件 N] 占位符对应）：\n${lines.join('\n')}`;
+    return `<attachments hint="使用 Read 工具查看，序号与正文中的 [图片 N] / [文件 N] 占位符对应">\n${items.join('\n')}\n</attachments>`;
 }
 export function buildNewTopicPrompt(userMessage, sessionId, cliId, cliPathOverride, attachments, mentions, availableBots, followUps, botIdentity) {
     const adapter = createCliAdapterSync(cliId, cliPathOverride);
     const hints = adapter.systemHints;
-    const noteLines = hints.map(h => `- ${h}`);
-    // Bot identity section — tells the bot who it is so it can distinguish
-    // itself when multiple bots are @mentioned in the same message.
-    let identitySection = '';
+    const routingBlock = hints.length > 0
+        ? `<botmux_routing>\n${hints.join('\n')}\n</botmux_routing>`
+        : '';
+    let identityBlock = '';
     if (botIdentity && (botIdentity.name || botIdentity.openId)) {
-        const lines = [
-            `- 名字：${botIdentity.name ?? '(未知)'}`,
-            `- open_id：${botIdentity.openId ?? '(未知)'}`,
-            '- 同一群里可能有多个机器人同时被 @，消息里会以 `@名字` 和 `open_id` 区分',
-            '- 只执行明确分给自己的那部分，整条消息都指派给别的机器人时保持沉默',
-        ];
-        identitySection = `\n\n你的身份：\n${lines.join('\n')}`;
+        identityBlock = [
+            '<identity>',
+            `  <name>${xmlEscape(botIdentity.name ?? '(未知)')}</name>`,
+            `  <open_id>${xmlEscape(botIdentity.openId ?? '(未知)')}</open_id>`,
+            '  <routing_rules>提醒：让别的 bot 接力干活必须 `botmux send --mention <对方 open_id>`，否则对方 bot 不会被触发。</routing_rules>',
+            '</identity>',
+        ].join('\n');
     }
-    // Mention metadata section
-    let mentionSection = '';
+    let mentionBlock = '';
     if (mentions && mentions.length > 0) {
-        const mentionLines = mentions.map(m => {
-            const idPart = m.openId ? ` → open_id: ${m.openId}` : '';
-            return `- @${m.name}${idPart}`;
+        const items = mentions.map(m => {
+            const oid = m.openId ? ` open_id="${xmlEscape(m.openId)}"` : '';
+            return `  <mention name="${xmlEscape(m.name)}"${oid} />`;
         });
-        mentionSection = `\n\n消息中的 @mention：\n${mentionLines.join('\n')}`;
+        mentionBlock = `<mentions>\n${items.join('\n')}\n</mentions>`;
     }
-    // Available bots section — only show bots NOT already in @mentions
-    let botSection = '';
+    let botBlock = '';
     if (availableBots && availableBots.length > 0) {
         const mentionedOpenIds = new Set(mentions?.map(m => m.openId).filter(Boolean));
         const unmentionedBots = availableBots.filter(b => !mentionedOpenIds.has(b.openId));
         if (unmentionedBots.length > 0) {
-            const botLines = unmentionedBots.map(b => `- ${b.displayName} (open_id: ${b.openId})`);
-            botSection = `\n\n当前群聊中的其他机器人：\n${botLines.join('\n')}\n可通过 botmux send --mention 参数 @mention 它们协作，也可用 botmux bots list 查询。`;
+            const items = unmentionedBots.map(b => `  <bot name="${xmlEscape(b.displayName)}" open_id="${xmlEscape(b.openId)}" />`);
+            botBlock = `<available_bots hint="让这里的某个 bot 接力干活必须 --mention 它的 open_id（botmux send --mention ou_xxx ...），不 --mention 对方 bot 完全收不到消息">\n${items.join('\n')}\n</available_bots>`;
         }
     }
-    // CLIs with injectsSessionContext get Lark context via system prompt,
-    // so pass user messages cleanly without wrapper — same format as follow-ups.
-    const attachHint = formatAttachmentsHint(attachments);
-    const parts = adapter.injectsSessionContext
-        ? [`${userMessage}${attachHint}`]
-        : [`用户发送了：\n---\n${userMessage}${attachHint}\n---`];
-    // Append follow-up messages buffered during repo selection
+    const userBlock = `<user_message>\n${userMessage}\n</user_message>`;
+    const parts = [userBlock];
     if (followUps && followUps.length > 0) {
         for (const fu of followUps) {
-            parts.push(adapter.injectsSessionContext ? fu : `用户追加了：\n---\n${fu}\n---`);
+            parts.push(`<follow_up_message>\n${fu}\n</follow_up_message>`);
         }
     }
+    const attachHint = formatAttachmentsHint(attachments);
+    if (attachHint)
+        parts.push(attachHint);
+    // CLIs with injectsSessionContext (Claude Code) get Lark routing/identity
+    // and session ID via system prompt, so skip those blocks here.
     if (!adapter.injectsSessionContext) {
-        parts.push(`Session ID: ${sessionId}`);
+        parts.push(`<session_id>${xmlEscape(sessionId)}</session_id>`);
+        if (routingBlock)
+            parts.push(routingBlock);
+        if (identityBlock)
+            parts.push(identityBlock);
     }
-    if (noteLines.length > 0)
-        parts.push(noteLines.join('\n'));
-    if (identitySection)
-        parts.push(identitySection.trim());
-    if (mentionSection)
-        parts.push(mentionSection.trim());
-    if (botSection)
-        parts.push(botSection.trim());
+    if (mentionBlock)
+        parts.push(mentionBlock);
+    if (botBlock)
+        parts.push(botBlock);
     return parts.join('\n\n');
 }
 /**
@@ -185,41 +206,141 @@ export function buildNewTopicPrompt(userMessage, sessionId, cliId, cliPathOverri
  * Session ID is omitted for adopt mode and CLIs with injectsSessionContext.
  */
 export function buildFollowUpContent(content, sessionId, opts) {
-    const parts = [
-        opts?.attachments && opts.attachments.length > 0
-            ? `${content}${formatAttachmentsHint(opts.attachments)}`
-            : content,
-    ];
+    const parts = [`<user_message>\n${content}\n</user_message>`];
+    const attachHint = opts?.attachments && opts.attachments.length > 0
+        ? formatAttachmentsHint(opts.attachments)
+        : '';
+    if (attachHint)
+        parts.push(attachHint);
     if (!opts?.isAdoptMode) {
-        // CLIs with injectsSessionContext get session ID via system prompt + MCP auto-detection
+        // CLIs with injectsSessionContext get session ID via system prompt + ancestor-pid auto-detection
         const skipSessionId = opts?.cliId
             ? createCliAdapterSync(opts.cliId, opts.cliPathOverride).injectsSessionContext
             : false;
         if (!skipSessionId) {
-            parts.push(`Session ID: ${sessionId}`);
+            parts.push(`<session_id>${xmlEscape(sessionId)}</session_id>`);
         }
     }
     if (opts?.mentions && opts.mentions.length > 0) {
-        const mentionLines = opts.mentions.map(m => {
-            const idPart = m.openId ? ` → open_id: ${m.openId}` : '';
-            return `- @${m.name}${idPart}`;
+        const items = opts.mentions.map(m => {
+            const oid = m.openId ? ` open_id="${xmlEscape(m.openId)}"` : '';
+            return `  <mention name="${xmlEscape(m.name)}"${oid} />`;
         });
-        parts.push(`消息中的 @mention：\n${mentionLines.join('\n')}`);
-    }
-    // Per-message routing hint — only for CLIs without system prompt context.
-    // CLIs with injectsSessionContext (e.g. Claude Code) already have the
-    // "use botmux send" instruction in --append-system-prompt, no need to repeat.
-    const skipHint = opts?.cliId
-        ? createCliAdapterSync(opts.cliId, opts.cliPathOverride).injectsSessionContext
-        : false;
-    if (!skipHint) {
-        parts.push('[请用 botmux send "消息" - 这个shell工具回复飞书用户，终端输出用户看不到]');
+        parts.push(`<mentions>\n${items.join('\n')}\n</mentions>`);
     }
+    // Per-message routing hint — system prompt routing block can fade in long
+    // sessions, so re-state the core "use botmux send" rule at the tail of every
+    // follow-up regardless of CLI.
+    parts.push('<botmux_reminder>回复必须 botmux send，终端输出用户看不到</botmux_reminder>');
     return parts.join('\n\n');
 }
+/**
+ * Build raw input content for adopt-bridge mode.
+ *
+ * Bridge mode injects the user's text into the existing CLI exactly as the
+ * local user would type it: NO `<session_id>`, NO `<botmux_reminder>`, NO
+ * Skills hint. The model is intentionally unaware of botmux — the daemon
+ * harvests final output via the transcript watcher and forwards it to Lark
+ * out-of-band.
+ *
+ * Attachments and @mentions are surfaced as plain prose so the user's intent
+ * carries over, but the format avoids any wording that would prompt the
+ * model to call `botmux send` / route through botmux tooling.
+ */
+export function buildBridgeInputContent(content, opts) {
+    const selfMention = opts?.selfMention;
+    const selfNames = new Set();
+    if (selfMention?.name)
+        selfNames.add(selfMention.name);
+    for (const m of opts?.mentions ?? []) {
+        if (selfMention?.openId && m.openId === selfMention.openId)
+            selfNames.add(m.name);
+        if (selfMention?.name && m.name === selfMention.name)
+            selfNames.add(m.name);
+    }
+    const isSelfMention = (m) => {
+        // openId is authoritative when both sides have it — avoids classifying
+        // a different bot as self in the (theoretical) case where two bots in
+        // the same chat share a display name.
+        if (selfMention?.openId && m.openId) {
+            return m.openId === selfMention.openId;
+        }
+        // At least one side is missing openId (cold-start window before
+        // probeBotOpenId returns, or a mention without openId): fall back to
+        // name match.
+        return !!selfMention?.name && selfNames.has(m.name);
+    };
+    const stripLeadingSelfMentions = (s) => {
+        if (selfNames.size === 0)
+            return s;
+        let out = s.trimStart();
+        const tags = [...selfNames]
+            .sort((a, b) => b.length - a.length)
+            .map(name => `@${name}`);
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const tag of tags) {
+                if (!out.startsWith(tag))
+                    continue;
+                const next = out.charAt(tag.length);
+                // Avoid stripping prefixes like "@CodexFoo" when the bot name is
+                // "Codex"; Lark-rendered mentions are followed by whitespace or EOL.
+                if (next && !/\s/.test(next))
+                    continue;
+                out = out.slice(tag.length).trimStart();
+                changed = true;
+                break;
+            }
+        }
+        return out;
+    };
+    const parts = [stripLeadingSelfMentions(content)];
+    if (opts?.attachments && opts.attachments.length > 0) {
+        const lines = opts.attachments.map(a => `- ${a.name} (${a.path})`);
+        parts.push(`\n[附件]\n${lines.join('\n')}`);
+    }
+    const mentions = opts?.mentions?.filter(m => !isSelfMention(m)) ?? [];
+    if (mentions.length > 0) {
+        const lines = mentions.map(m => `- @${m.name}`);
+        parts.push(`\n[@提及]\n${lines.join('\n')}`);
+    }
+    return parts.join('\n');
+}
 // ─── Stream-card state persistence ───────────────────────────────────────────
 /** Sentinel value (CARD_POSTING_SENTINEL from worker-pool) we must skip — it marks an in-flight POST, not a real message_id. */
 const STREAM_CARD_SENTINEL = '__posting__';
+/**
+ * Build the prompt that gets piped into a freshly-spawned CLI when an existing
+ * (non-bridge) session re-forks its worker. Hits the `worker=null` re-fork
+ * branch in handleThreadReply: resume after /close, daemon-restart + new
+ * message, and any other path that lands a new turn without a live worker.
+ *
+ * Without wrapping, the worker would queue the user's raw text as the initial
+ * prompt — the CLI sees no `<user_message>` / `<botmux_reminder>` envelope
+ * and answers in its own terminal instead of calling `botmux send`.  This
+ * helper centralises the wrap so both daemon.ts and tests agree on the shape.
+ *
+ * Adopt-bridge sessions go through `buildBridgeInputContent` instead — see
+ * the buildBridgeInputContent docstring for why bridge prompts intentionally
+ * skip botmux routing tags.
+ */
+export function buildReforkPrompt(ds, content, opts) {
+    if (ds.adoptedFrom) {
+        return buildBridgeInputContent(content, {
+            attachments: opts?.attachments,
+            mentions: opts?.mentions,
+            selfMention: opts?.selfMention,
+        });
+    }
+    return buildFollowUpContent(content, ds.session.sessionId, {
+        attachments: opts?.attachments,
+        mentions: opts?.mentions,
+        isAdoptMode: false,
+        cliId: opts?.cliId,
+        cliPathOverride: opts?.cliPathOverride,
+    });
+}
 /**
  * Copy current streaming-card fields from `ds` into the persisted Session and save.
  * Lets the existing card be PATCHed on next screen_update after a daemon restart,
@@ -256,6 +377,9 @@ export function restoreActiveSessions(activeSessions) {
     killStalePids(active);
     logger.info(`Registering ${active.length} active session(s) (no CLI spawn until new messages arrive)...`);
     for (const session of active) {
+        // Restored sessions persisted before the scope field was added default to
+        // 'thread' — that matches the legacy thread-only behaviour.
+        const scope = session.scope === 'chat' ? 'chat' : 'thread';
         // Adopt sessions: restore if original CLI is still alive, otherwise close
         if (session.title?.startsWith('Adopt:') && session.adoptedFrom) {
             const adopted = session.adoptedFrom;
@@ -265,7 +389,6 @@ export function restoreActiveSessions(activeSessions) {
                 continue;
             }
             // Original CLI still alive — re-register and fork adopt worker
-            messageQueue.ensureQueue(session.rootMessageId);
             const larkAppId = session.larkAppId ?? getAllBots()[0]?.config.larkAppId ?? '';
             const ds = {
                 session,
@@ -275,9 +398,10 @@ export function restoreActiveSessions(activeSessions) {
                 larkAppId,
                 chatId: session.chatId,
                 chatType: session.chatType ?? 'group',
-                spawnedAt: Date.now(),
+                scope,
+                spawnedAt: sessionCreatedAtMs(session),
                 cliVersion: getCurrentCliVersion(),
-                lastMessageAt: Date.now(),
+                lastMessageAt: sessionLastMessageAtMs(session),
                 hasHistory: false,
                 workingDir: adopted.cwd,
                 adoptedFrom: adopted,
@@ -289,9 +413,11 @@ export function restoreActiveSessions(activeSessions) {
                 currentImageKey: session.currentImageKey,
                 currentTurnTitle: session.currentTurnTitle,
             };
-            activeSessions.set(sessionKey(session.rootMessageId, larkAppId), ds);
-            forkAdoptWorker(ds);
-            logger.info(`[${session.sessionId.substring(0, 8)}] Restored adopt session (target: ${adopted.tmuxTarget})`);
+            const anchor = sessionAnchorId(ds);
+            messageQueue.ensureQueue(anchor);
+            activeSessions.set(sessionKey(anchor, larkAppId), ds);
+            forkAdoptWorker(ds, { restoredFromMetadata: true });
+            logger.info(`[${session.sessionId.substring(0, 8)}] Restored adopt session (target: ${adopted.tmuxTarget}, scope: ${scope})`);
             continue;
         }
         // Adopt sessions without persisted metadata — close (legacy)
@@ -300,9 +426,8 @@ export function restoreActiveSessions(activeSessions) {
             sessionStore.closeSession(session.sessionId);
             continue;
         }
-        messageQueue.ensureQueue(session.rootMessageId);
         const larkAppId = session.larkAppId ?? getAllBots()[0]?.config.larkAppId ?? '';
-        activeSessions.set(sessionKey(session.rootMessageId, larkAppId), {
+        const ds = {
             session,
             worker: null,
             workerPort: null,
@@ -310,9 +435,10 @@ export function restoreActiveSessions(activeSessions) {
             larkAppId,
             chatId: session.chatId,
             chatType: session.chatType ?? 'group',
-            spawnedAt: Date.now(),
+            scope,
+            spawnedAt: sessionCreatedAtMs(session),
             cliVersion: getCurrentCliVersion(),
-            lastMessageAt: Date.now(),
+            lastMessageAt: sessionLastMessageAtMs(session),
             hasHistory: true, // restored sessions have prior CLI history
             workingDir: session.workingDir,
             // Restore persisted streaming-card state — next screen_update will PATCH
@@ -325,8 +451,11 @@ export function restoreActiveSessions(activeSessions) {
             displayMode: session.displayMode ?? (session.streamExpanded ? 'screenshot' : 'hidden'),
             currentImageKey: session.currentImageKey,
             currentTurnTitle: session.currentTurnTitle,
-        });
-        logger.debug(`Registered session ${session.sessionId} (thread: ${session.rootMessageId})`);
+        };
+        const anchor = sessionAnchorId(ds);
+        messageQueue.ensureQueue(anchor);
+        activeSessions.set(sessionKey(anchor, larkAppId), ds);
+        logger.debug(`Registered session ${session.sessionId} (scope: ${scope}, anchor: ${anchor})`);
     }
     // Tmux mode: auto-fork workers for sessions with surviving tmux sessions
     if (config.daemon.backendType === 'tmux') {
@@ -340,46 +469,199 @@ export function restoreActiveSessions(activeSessions) {
     }
     logger.info(`Restored ${active.length} session(s)${config.daemon.backendType === 'tmux' ? '' : ', waiting for messages to resume'}`);
 }
+/**
+ * Reactivate a single closed session — used by the "▶️ 恢复会话" card button
+ * and the `botmux resume <id>` CLI command. Mirrors the per-session branch
+ * of `restoreActiveSessions` but operates on one record by id and without
+ * killing stale pids (the `/close` flow that produced this closed record
+ * already killed them).
+ *
+ * Returns `{ ok: true, ds }` on success; structured error otherwise so callers
+ * (HTTP IPC, card handler) can surface a precise message.
+ *
+ *   - 'not_found'        — sessionId doesn't exist in any session file
+ *   - 'not_closed'       — session is still active or in some other state
+ *   - 'anchor_occupied'  — another active session already owns this anchor
+ *                          (e.g. user kept typing after /close, auto-creating
+ *                          a fresh thread session); refuse rather than clobber
+ *   - 'adopt_unsupported' — adopt sessions are torn down by /close and have
+ *                          no resume semantics
+ */
+export function resumeSession(sessionId, activeSessions) {
+    const session = sessionStore.getSession(sessionId);
+    if (!session)
+        return { ok: false, error: 'not_found' };
+    if (session.status !== 'closed')
+        return { ok: false, error: 'not_closed' };
+    // Adopt sessions don't survive /close — the user's tmux pane and original
+    // CLI pid have already moved on, and bringing the bridge back without a live
+    // pane is meaningless.
+    if (session.title?.startsWith('Adopt:') || session.adoptedFrom) {
+        return { ok: false, error: 'adopt_unsupported' };
+    }
+    const scope = session.scope === 'chat' ? 'chat' : 'thread';
+    const larkAppId = session.larkAppId ?? getAllBots()[0]?.config.larkAppId ?? '';
+    const anchor = scope === 'thread' ? session.rootMessageId : session.chatId;
+    const key = sessionKey(anchor, larkAppId);
+    const existing = activeSessions.get(key);
+    if (existing) {
+        return { ok: false, error: 'anchor_occupied', activeSessionId: existing.session.sessionId };
+    }
+    // Belt-and-suspenders: also scan persisted sessions for any *other* active
+    // session pinned to the same (larkAppId, scope, anchor). The in-memory Map
+    // is the authoritative routing source for a running daemon, but it's only
+    // hydrated for sessions that survived restoreActiveSessions. Cross-process
+    // and partial-load situations (e.g. another bot's daemon writes a session
+    // file but our Map hasn't caught up, or a closed session was orphaned by a
+    // crash that left a sibling session active in the same anchor) can leave a
+    // store-level conflict invisible to the Map check above. Refuse instead of
+    // overwriting the routing key.
+    const conflict = sessionStore.listSessions().find(s => s.sessionId !== sessionId
+        && s.status === 'active'
+        && (s.larkAppId ?? '') === larkAppId
+        && (s.scope === 'chat' ? 'chat' : 'thread') === scope
+        && (scope === 'thread' ? s.rootMessageId === anchor : s.chatId === anchor));
+    if (conflict) {
+        return { ok: false, error: 'anchor_occupied', activeSessionId: conflict.sessionId };
+    }
+    // Reactivate in store — clear closedAt so dashboard rows don't keep showing
+    // the stale close timestamp on the now-active session.
+    session.status = 'active';
+    session.closedAt = undefined;
+    session.lastMessageAt = new Date().toISOString();
+    sessionStore.updateSession(session);
+    const now = Date.now();
+    const ds = {
+        session,
+        worker: null,
+        workerPort: null,
+        workerToken: null,
+        larkAppId,
+        chatId: session.chatId,
+        chatType: session.chatType ?? 'group',
+        scope,
+        spawnedAt: sessionCreatedAtMs(session),
+        cliVersion: getCurrentCliVersion(),
+        lastMessageAt: now,
+        hasHistory: true, // resumed sessions carry CLI history (--resume on next fork)
+        workingDir: session.workingDir,
+        ownerOpenId: session.ownerOpenId,
+        streamCardId: session.streamCardId,
+        streamCardNonce: session.streamCardNonce,
+        displayMode: session.displayMode ?? (session.streamExpanded ? 'screenshot' : 'hidden'),
+        currentImageKey: session.currentImageKey,
+        currentTurnTitle: session.currentTurnTitle,
+    };
+    messageQueue.ensureQueue(anchor);
+    activeSessions.set(key, ds);
+    logger.info(`Resumed session ${sessionId.substring(0, 8)} (scope: ${scope}, anchor: ${anchor.substring(0, 12)})`);
+    return { ok: true, ds };
+}
 // ─── Scheduled task execution ────────────────────────────────────────────────
 export async function executeScheduledTask(task, activeSessions, refreshCliVersion) {
     // Resolve which bot to use — prefer the task's original bot so replies come from
     // the same account the user set up the schedule with.
     const allBots = getAllBots();
     if (allBots.length === 0) {
-        logger.warn('No bots configured, skipping scheduled task');
+        // Expected at startup before bot configs finish loading; scheduler will
+        // re-fire on the next cron tick. Not actionable.
+        logger.debug('No bots configured, skipping scheduled task');
         return;
     }
     const bot = (task.larkAppId && allBots.find(b => b.config.larkAppId === task.larkAppId)) ||
         allBots[0];
     const larkAppId = bot.config.larkAppId;
-    const { sendMessage, replyMessage } = await import('../im/lark/client.js');
-    // Decide where to route: preferred path is to reply inside the original thread.
-    // Fallback (legacy tasks without rootMessageId): post a new top-level message.
-    let threadRootId;
+    const { getChatMode, sendMessage, replyMessage } = await import('../im/lark/client.js');
+    // Scope resolution — explicit task.scope wins; otherwise fall back to legacy
+    // semantics (rootMessageId present → thread, absent → chat). Restoring an
+    // older schedule without scope keeps current behaviour.
+    const scope = task.scope === 'chat'
+        ? 'chat'
+        : task.scope === 'thread'
+            ? 'thread'
+            : (task.rootMessageId ? 'thread' : 'chat');
+    // Decide where to route the "🕐 task started" notification and where the
+    // session conversation lands.
+    //
+    // Thread-scope (legacy and current default):
+    //   - cross-thread (creator != target): notify creator's thread; deliver
+    //     execution into target rootMessageId
+    //   - same-thread:                       notify into the bound thread,
+    //     which doubles as the session anchor
+    //   - missing rootMessageId:             fall back to a fresh top-level
+    //     post in the chat (one-shot session)
+    //
+    // Chat-scope (auto-adopt / 普通群): post the start notification straight to
+    // the chat without reply_in_thread; the chat IS the session anchor.
+    let anchor;
     let isContinuation = false;
-    if (task.rootMessageId) {
-        try {
-            // Reply in the original thread — the returned reply message id is just an
-            // anchor for this run; the thread's root remains task.rootMessageId, which
-            // is what the session/card system keys off.
-            await replyMessage(larkAppId, task.rootMessageId, `🕐 定时任务「${task.name}」开始执行`, 'text', true);
-            threadRootId = task.rootMessageId;
-            isContinuation = true;
+    if (scope === 'chat') {
+        // A group may have been converted from 普通群 to 话题群 after the schedule
+        // was created. In topic mode, a top-level sendMessage creates a new topic;
+        // keep scheduled continuations in the original thread when we have one.
+        const chatMode = await getChatMode(larkAppId, task.chatId, { forceRefresh: true });
+        if (chatMode === 'topic' && task.rootMessageId) {
+            try {
+                await replyMessage(larkAppId, task.rootMessageId, `🕐 定时任务「${task.name}」开始执行`, 'text', true);
+                anchor = task.rootMessageId;
+                isContinuation = true;
+            }
+            catch (err) {
+                logger.warn(`[scheduler] Failed to reply in converted topic chat ${task.rootMessageId} (${err.message}); falling back to new thread`);
+                anchor = await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+            }
         }
-        catch (err) {
-            logger.warn(`[scheduler] Failed to reply in original thread ${task.rootMessageId} (${err.message}); falling back to new thread`);
-            threadRootId = await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+        else if (task.creatorRootMessageId && task.creatorChatId !== task.chatId) {
+            const creatorAppId = task.creatorLarkAppId ?? larkAppId;
+            replyMessage(creatorAppId, task.creatorRootMessageId, `🕐 定时任务「${task.name}」已在目标群聊触发`, 'text', true).catch((err) => {
+                logger.warn(`[scheduler] Failed to notify creator thread ${task.creatorRootMessageId} (${err.message})`);
+            });
+        }
+        else {
+            // Same-chat: post the start banner to the chat as a plain message.
+            try {
+                await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+            }
+            catch (err) {
+                logger.warn(`[scheduler] Failed to post start banner in chat ${task.chatId} (${err.message})`);
+            }
         }
+        anchor = task.chatId;
+        isContinuation = !!activeSessions.get(sessionKey(anchor, larkAppId));
     }
     else {
-        threadRootId = await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+        // thread-scope path (existing logic)
+        const isCrossThread = !!task.creatorRootMessageId &&
+            !!task.rootMessageId &&
+            task.creatorRootMessageId !== task.rootMessageId;
+        if (isCrossThread) {
+            const creatorAppId = task.creatorLarkAppId ?? larkAppId;
+            replyMessage(creatorAppId, task.creatorRootMessageId, `🕐 定时任务「${task.name}」已在目标话题触发`, 'text', true).catch((err) => {
+                logger.warn(`[scheduler] Failed to notify creator thread ${task.creatorRootMessageId} (${err.message})`);
+            });
+            anchor = task.rootMessageId;
+            isContinuation = true;
+        }
+        else if (task.rootMessageId) {
+            try {
+                await replyMessage(larkAppId, task.rootMessageId, `🕐 定时任务「${task.name}」开始执行`, 'text', true);
+                anchor = task.rootMessageId;
+                isContinuation = true;
+            }
+            catch (err) {
+                logger.warn(`[scheduler] Failed to reply in original thread ${task.rootMessageId} (${err.message}); falling back to new thread`);
+                anchor = await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+            }
+        }
+        else {
+            anchor = await sendMessage(larkAppId, task.chatId, `🕐 定时任务「${task.name}」开始执行`);
+        }
     }
     refreshCliVersion(bot.config.cliId, bot.config.cliPathOverride);
-    // If a live session already exists for this thread (user was just chatting in it),
-    // inject the prompt as a follow-up message rather than spawning a fresh worker.
-    const existing = activeSessions.get(sessionKey(threadRootId, larkAppId));
+    // Inject into a live session if one already exists at this anchor.
+    const existing = activeSessions.get(sessionKey(anchor, larkAppId));
     if (isContinuation && existing?.worker && !existing.worker.killed) {
-        existing.lastMessageAt = Date.now();
+        markSessionActivity(existing);
         try {
             existing.worker.send({ type: 'message', content: task.prompt });
             logger.info(`[scheduler] Task "${task.name}" injected into live session ${existing.session.sessionId}`);
@@ -389,12 +671,19 @@ export async function executeScheduledTask(task, activeSessions, refreshCliVersi
             logger.warn(`[scheduler] Failed to inject into live session (${err.message}); spawning fresh worker`);
         }
     }
-    // Otherwise create a new session bound to the original thread root so all the
-    // worker's replies continue to land under that topic in Lark.
-    const session = sessionStore.createSession(task.chatId, threadRootId, `[定时] ${task.name}`);
+    // Spawn a fresh session bound to the chosen anchor.
+    // Thread-scope: rootMessageId = anchor. Chat-scope: rootMessageId stores the
+    // chatId-as-seed for audit (sessionAnchorId() returns chatId via scope). If a
+    // formerly chat-scope task was redirected into a converted topic chat, promote
+    // the runtime session to thread-scope so follow-up replies stay in-thread.
+    const runtimeScope = scope === 'chat' && anchor !== task.chatId ? 'thread' : scope;
+    const session = sessionStore.createSession(task.chatId, anchor, `[定时] ${task.name}`);
+    const now = Date.now();
     session.larkAppId = larkAppId;
+    session.scope = runtimeScope;
+    session.lastMessageAt = new Date(now).toISOString();
     sessionStore.updateSession(session);
-    messageQueue.ensureQueue(threadRootId);
+    messageQueue.ensureQueue(anchor);
     const prompt = buildNewTopicPrompt(task.prompt, session.sessionId, bot.config.cliId, bot.config.cliPathOverride, undefined, undefined, undefined, undefined, { name: bot.botName, openId: bot.botOpenId });
     const ds = {
         session,
@@ -404,14 +693,15 @@ export async function executeScheduledTask(task, activeSessions, refreshCliVersi
         larkAppId,
         chatId: task.chatId,
         chatType: task.chatType === 'p2p' ? 'p2p' : 'group',
-        spawnedAt: Date.now(),
+        scope: runtimeScope,
+        spawnedAt: sessionCreatedAtMs(session),
         cliVersion: getCurrentCliVersion(),
-        lastMessageAt: Date.now(),
-        hasHistory: isContinuation, // continuation sessions inherit the old thread's context
+        lastMessageAt: now,
+        hasHistory: isContinuation,
         workingDir: task.workingDir,
     };
-    activeSessions.set(sessionKey(threadRootId, larkAppId), ds);
+    activeSessions.set(sessionKey(anchor, larkAppId), ds);
     forkWorker(ds, prompt);
-    logger.info(`[scheduler] Task "${task.name}" spawned (session: ${session.sessionId}, thread: ${threadRootId}, continuation: ${isContinuation})`);
+    logger.info(`[scheduler] Task "${task.name}" spawned (session: ${session.sessionId}, scope: ${scope}, anchor: ${anchor}, continuation: ${isContinuation})`);
 }
 //# sourceMappingURL=session-manager.js.map