team-anya-cli 0.1.4 → 0.1.6

package/apps/server/dist/franky/franky-orchestrator.js

@@ -0,0 +1,450 @@
+import { readFile, mkdir, writeFile, copyFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getTopic, insertAuditEvent, insertCCSession, updateCCSessionEnded, upsertTopic } from '@team-anya/db';
+import { FRANKY_DEFAULT_SCOPE } from '@team-anya/core';
+import { startFrankyMcpServer } from './franky-mcp-server.js';
+const execFile = promisify(execFileCb);
+// ── FrankyOrchestrator ──
+/**
+ * FrankyOrchestrator：专项协作者编排层
+ *
+ * 职责：
+ * - 管理每个 Topic 对应的 Franky CC 实例（最多一个）
+ * - 消息驱动：用户发消息时，实例存在则注入消息，不存在则自动创建
+ * - 监听 CC 实例的 result / exited / crash 事件
+ * - Idle 超时回收（预留接口，Phase 3 细化）
+ *
+ * 与 YorOrchestrator 的核心区别：
+ * - Yor：一次性任务执行（brief -> 执行 -> deliver -> 销毁）
+ * - Franky：持续协作（专项开启 -> 消息驱动对话 -> 专项关闭）
+ */
+export class FrankyOrchestrator {
+    broker;
+    config;
+    instances = new Map(); // key = topicId
+    spawning = new Map(); // 防止并发 spawn
+    logger;
+    idleCheckInterval = null;
+    idleTimeoutMs;
+    constructor(broker, config) {
+        this.broker = broker;
+        this.config = config;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+        this.idleTimeoutMs = config.idleTimeoutMs ?? 30 * 60 * 1000; // 默认 30 分钟
+        // 启动 idle 检查定时器
+        this.idleCheckInterval = setInterval(() => this.checkIdleInstances(), 5 * 60 * 1000);
+        // 监听 CC session ID 事件（Franky 实例）
+        this.broker.on('instance.sessionId', (instanceId, cliSessionId) => {
+            const brokerInstance = this.broker.getInstance(instanceId);
+            if (brokerInstance?.role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                insertCCSession(this.config.db, {
+                    session_id: cliSessionId,
+                    role: 'franky',
+                    instance_id: instanceId,
+                    task_id: topicId,
+                    project_path: brokerInstance.config.workingDir,
+                });
+                this.logger.info(`[FrankyOrchestrator] 记录 CC session: ${cliSessionId} (topic: ${topicId})`);
+            }
+        });
+        // 监听 CC 实例事件
+        this.broker.on('instance.result', (instanceId, role, _result) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                const instance = this.instances.get(topicId);
+                if (instance)
+                    instance.lastActivityAt = new Date();
+                this.logger.info(`[FrankyOrchestrator] 实例 ${instanceId} 执行完成 (topic: ${topicId})`);
+            }
+        });
+        this.broker.on('instance.exited', (instanceId, role) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                // 更新 cc_sessions.ended_at
+                const brokerInstance = this.broker.getInstance(instanceId);
+                if (brokerInstance?.cliSessionId) {
+                    updateCCSessionEnded(this.config.db, brokerInstance.cliSessionId);
+                }
+                this.logger.info(`[FrankyOrchestrator] 实例 ${instanceId} 已退出 (topic: ${topicId})`);
+                this.cleanupInstance(topicId);
+            }
+        });
+        this.broker.on('instance.crash', (instanceId, role, error) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                // 更新 cc_sessions.ended_at
+                const brokerInstance = this.broker.getInstance(instanceId);
+                if (brokerInstance?.cliSessionId) {
+                    updateCCSessionEnded(this.config.db, brokerInstance.cliSessionId);
+                }
+                this.logger.error(`[FrankyOrchestrator] 实例 ${instanceId} 崩溃 (topic: ${topicId}):`, error);
+                this.cleanupInstance(topicId);
+            }
+        });
+    }
+    /**
+     * 向专项发送消息。如果 Franky 实例不存在，自动创建。
+     */
+    async sendMessage(topicId, message) {
+        let instance = this.instances.get(topicId);
+        if (!instance) {
+            // 防止并发 spawn：多条消息同时到达时共享同一个 spawn promise
+            let pending = this.spawning.get(topicId);
+            if (!pending) {
+                pending = this.spawnForTopic(topicId);
+                this.spawning.set(topicId, pending);
+                try {
+                    instance = await pending;
+                }
+                finally {
+                    this.spawning.delete(topicId);
+                }
+            }
+            else {
+                instance = await pending;
+            }
+        }
+        // 格式化用户消息为 prompt
+        const prompt = this.formatUserMessage(message);
+        // 注入消息到 CC 实例
+        try {
+            this.broker.sendPrompt(instance.instanceId, prompt);
+            instance.lastActivityAt = new Date();
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] 发送消息失败 (topic: ${topicId}):`, err);
+            // 实例可能已死，清理后重试一次
+            this.cleanupInstance(topicId);
+            const newInstance = await this.spawnForTopic(topicId);
+            this.broker.sendPrompt(newInstance.instanceId, prompt);
+        }
+    }
+    /**
+     * 关闭指定 Topic 的 Franky 实例
+     */
+    async closeTopic(topicId) {
+        await this.cleanupInstance(topicId);
+        this.logger.info(`[FrankyOrchestrator] 关闭专项 ${topicId} 的 Franky 实例`);
+    }
+    /**
+     * 获取所有活跃的 Franky 实例状态
+     */
+    status() {
+        return [...this.instances.values()].map(i => ({
+            topicId: i.topicId,
+            instanceId: i.instanceId,
+            lastActivityAt: i.lastActivityAt.toISOString(),
+        }));
+    }
+    /**
+     * 优雅关闭所有实例
+     */
+    async shutdown() {
+        if (this.idleCheckInterval) {
+            clearInterval(this.idleCheckInterval);
+            this.idleCheckInterval = null;
+        }
+        const topicIds = [...this.instances.keys()];
+        for (const topicId of topicIds) {
+            await this.cleanupInstance(topicId);
+        }
+    }
+    // ── 私有方法 ──
+    /**
+     * 为指定 Topic 创建 Franky CC 实例
+     */
+    async spawnForTopic(topicId) {
+        const topic = getTopic(this.config.db, topicId);
+        if (!topic)
+            throw new Error(`专项 ${topicId} 不存在`);
+        const instanceId = `franky:${topicId}`;
+        const frankyRoot = join(this.config.workspacePath, 'franky');
+        const topicWorkDir = join(frankyRoot, 'topics', topicId);
+        // 确保 topic 目录存在
+        await mkdir(topicWorkDir, { recursive: true });
+        // 准备 git worktree（如果关联了项目）
+        const worktreeResult = await this.prepareWorktrees(topic, topicWorkDir);
+        // 复制启动文件到 topic 目录（CLAUDE.md 的相对路径基于 topicWorkDir）
+        await this.prepareTopicWorkspace(frankyRoot, topicWorkDir);
+        // 生成/重建 context.md
+        const contextPath = join(topicWorkDir, 'context.md');
+        const isRebuild = existsSync(contextPath);
+        if (isRebuild) {
+            // 重建模式：从 DB + checkpoints + message_log 重建上下文
+            try {
+                const { writeTopicContext } = await import('./context-builder.js');
+                await writeTopicContext({ db: this.config.db, workspacePath: this.config.workspacePath, logger: this.logger }, topicId);
+                this.logger.info(`[FrankyOrchestrator] 重建 context.md (topic: ${topicId})`);
+            }
+            catch (err) {
+                this.logger.error(`[FrankyOrchestrator] context.md 重建失败，使用现有文件:`, err);
+            }
+        }
+        else {
+            // 新建模式：生成初始 context（含 worktree 信息）
+            await this.generateInitialContext(topic, contextPath, worktreeResult?.worktreeInfo);
+        }
+        // 如果创建了 worktree，回写 workspace_path 和 branch_name 到 DB
+        if (worktreeResult) {
+            upsertTopic(this.config.db, {
+                id: topic.id,
+                title: topic.title,
+                status: topic.status,
+                description: topic.description ?? undefined,
+                project_id: topic.project_id ?? undefined,
+                thread_id: topic.thread_id ?? undefined,
+                root_message_id: topic.root_message_id ?? undefined,
+                chat_id: topic.chat_id ?? undefined,
+                created_by: topic.created_by ?? undefined,
+                workspace_path: topicWorkDir,
+                branch_name: worktreeResult.branchName,
+            });
+        }
+        // 启动 Franky MCP Server
+        const mcpDeps = {
+            db: this.config.db,
+            workspacePath: topicWorkDir,
+            topicId,
+            replyToThreadId: topic.thread_id ?? undefined,
+            channelRegistry: this.config.channelRegistry,
+            onMessageSent: this.config.onMessageSent,
+            onTopicClosed: (tid) => this.closeTopic(tid),
+            onTopicEscalated: this.config.onTopicEscalated,
+            logger: this.logger,
+        };
+        const mcpServer = await startFrankyMcpServer(mcpDeps);
+        // 准备启动 prompt（读取 context.md）
+        let startupPrompt;
+        try {
+            startupPrompt = await readFile(contextPath, 'utf-8');
+        }
+        catch {
+            startupPrompt = `# 专项: ${topic.title}\n\n目标: ${topic.description ?? '（未设定）'}`;
+        }
+        // 通过 CCBroker 启动实例
+        const logFile = join(topicWorkDir, `cc-backend.log`);
+        await this.broker.spawn({
+            id: instanceId,
+            role: 'franky',
+            backendConfig: {
+                type: 'claude-code',
+                binary: this.config.binary,
+                workingDir: topicWorkDir,
+                permissionMode: 'bypassPermissions',
+                mcpServers: [{ name: 'franky-tools', url: mcpServer.url }],
+            },
+            scope: FRANKY_DEFAULT_SCOPE,
+            mcpServer,
+            logFile,
+        });
+        // 发送启动 prompt
+        this.broker.sendPrompt(instanceId, startupPrompt);
+        const instance = {
+            topicId,
+            instanceId,
+            mcpServer,
+            lastActivityAt: new Date(),
+        };
+        this.instances.set(topicId, instance);
+        insertAuditEvent(this.config.db, {
+            event_type: 'franky_spawned',
+            actor: 'system',
+            summary: `启动 Franky 实例: ${topicId}`,
+            detail: JSON.stringify({ instanceId, topicId }),
+        });
+        this.logger.info(`[FrankyOrchestrator] 启动 Franky 实例 ${instanceId} (topic: ${topicId})`);
+        return instance;
+    }
+    /**
+     * 准备 git worktree（如果 topic 关联了项目）
+     *
+     * 与 Yor 的 task-dispatch 类似，但额外处理 respawn 场景：
+     * - worktree 目录已存在时跳过创建（复用）
+     * - 分支已存在时不带 -b 参数附加
+     * - 创建失败时 graceful degradation（不阻塞 spawn）
+     */
+    async prepareWorktrees(topic, topicWorkDir) {
+        if (!topic.project_id || !this.config.getProjectConfig)
+            return null;
+        let projectConfig;
+        try {
+            projectConfig = await this.config.getProjectConfig(topic.project_id);
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] 获取项目配置失败 (${topic.project_id}):`, err);
+            return null;
+        }
+        if (projectConfig.mode !== 'project' || !projectConfig.repos?.length)
+            return null;
+        const branchName = topic.branch_name ?? `feat/topic-${topic.id}`;
+        const lines = ['## 代码工作区', ''];
+        const createdWorktrees = [];
+        for (const repo of projectConfig.repos) {
+            const wtPath = join(topicWorkDir, repo.name);
+            const defaultBranch = repo.default_branch ?? 'main';
+            if (existsSync(wtPath)) {
+                this.logger.info(`[FrankyOrchestrator] worktree 已存在，复用: ${wtPath}`);
+            }
+            else {
+                try {
+                    await execFile('git', ['-C', repo.repo_path, 'fetch', 'origin']);
+                    // 检查分支是否已存在（之前创建后被手动清理 worktree 的场景）
+                    let branchExists = false;
+                    try {
+                        const { stdout } = await execFile('git', ['-C', repo.repo_path, 'branch', '--list', branchName]);
+                        branchExists = stdout.trim().length > 0;
+                    }
+                    catch { /* ignore */ }
+                    if (branchExists) {
+                        await execFile('git', ['-C', repo.repo_path, 'worktree', 'add', wtPath, branchName]);
+                    }
+                    else {
+                        await execFile('git', ['-C', repo.repo_path, 'worktree', 'add', wtPath, '-b', branchName, `origin/${defaultBranch}`]);
+                    }
+                    createdWorktrees.push({ repoPath: repo.repo_path, wtPath });
+                    this.logger.info(`[FrankyOrchestrator] worktree 已创建: ${wtPath} (branch: ${branchName})`);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    this.logger.error(`[FrankyOrchestrator] worktree 创建失败 (${repo.name}): ${msg}`);
+                    // 回滚已创建的 worktree
+                    for (const wt of createdWorktrees) {
+                        try {
+                            await execFile('git', ['-C', wt.repoPath, 'worktree', 'remove', wt.wtPath, '--force']);
+                        }
+                        catch { /* ignore rollback failure */ }
+                    }
+                    return null;
+                }
+            }
+            lines.push(`- \`${repo.name}/\` → 分支 \`${branchName}\`，路径 \`${wtPath}\``);
+        }
+        lines.push('');
+        lines.push('> 代码在上述 worktree 子目录中，git 操作请进入对应子目录执行。');
+        return { branchName, worktreeInfo: lines.join('\n') };
+    }
+    /**
+     * 准备 topic 工作目录：复制启动文件，使 CLAUDE.md 的相对路径正确解析
+     *
+     * 目录结构：
+     *   topics/TOPIC-xxx/           ← workingDir（CC 实例在此启动）
+     *     ├── CLAUDE.md             ← 复制自 franky/CLAUDE.md
+     *     ├── PROFILE.md            ← 复制自 franky/PROFILE.md
+     *     ├── PLAYBOOK.md           ← 复制自 franky/PLAYBOOK.md
+     *     ├── ../CHARTER.md         ← topics/CHARTER.md（复制自 office/CHARTER.md）
+     *     ├── ../PROTOCOL.md        ← topics/PROTOCOL.md
+     *     ├── ../TOOLS.md           ← topics/TOOLS.md
+     *     └── context.md            ← 系统生成
+     */
+    async prepareTopicWorkspace(frankyRoot, topicWorkDir) {
+        const officeRoot = this.config.workspacePath;
+        const topicsDir = join(frankyRoot, 'topics');
+        // CLAUDE.md 中 `../CHARTER.md` 从 topic dir 解析到 topics/ 目录
+        const parentFiles = ['CHARTER.md', 'PROTOCOL.md', 'TOOLS.md'];
+        for (const file of parentFiles) {
+            const src = join(officeRoot, file);
+            const dest = join(topicsDir, file);
+            if (existsSync(src))
+                await copyFile(src, dest);
+        }
+        // CLAUDE.md 中 `PROFILE.md` / `PLAYBOOK.md` 在 topic dir 同级
+        const localFiles = ['CLAUDE.md', 'PROFILE.md', 'PLAYBOOK.md'];
+        for (const file of localFiles) {
+            const src = join(frankyRoot, file);
+            const dest = join(topicWorkDir, file);
+            if (existsSync(src))
+                await copyFile(src, dest);
+        }
+    }
+    /**
+     * 生成初始 context.md
+     */
+    async generateInitialContext(topic, contextPath, worktreeInfo) {
+        const lines = [
+            `# 专项上下文：${topic.title} (${topic.id})`,
+            '',
+            '## 目标',
+            topic.description ?? '（用户未设定详细描述）',
+            '',
+            '## 通讯信息',
+            ...(topic.chat_id ? [`- 群聊 ID：\`${topic.chat_id}\``] : []),
+            ...(topic.root_message_id ? [`- 话题根消息 ID：\`${topic.root_message_id}\``] : []),
+            ...(topic.thread_id ? [`- 话题 ID：\`${topic.thread_id}\`（仅供参考，channel.send 的 reply_to 请用根消息 ID）`] : []),
+            '',
+            '## 项目信息',
+            `- 专项 ID：${topic.id}`,
+            ...(topic.project_id ? [`- 关联项目：${topic.project_id}`] : []),
+            ...(topic.branch_name ? [`- 分支：${topic.branch_name}`] : []),
+            '',
+        ];
+        if (worktreeInfo) {
+            lines.push(worktreeInfo);
+            lines.push('');
+        }
+        await writeFile(contextPath, lines.join('\n'), 'utf-8');
+    }
+    /**
+     * 格式化用户消息为 CC prompt
+     */
+    formatUserMessage(message) {
+        const sender = message.senderName ?? message.sender ?? '用户';
+        return `[${sender}]: ${message.content}`;
+    }
+    /**
+     * 检查并回收空闲实例
+     */
+    async checkIdleInstances() {
+        const now = Date.now();
+        for (const [topicId, instance] of this.instances) {
+            const idle = now - instance.lastActivityAt.getTime();
+            if (idle > this.idleTimeoutMs) {
+                this.logger.info(`[FrankyOrchestrator] 回收空闲实例 ${instance.instanceId} (idle: ${Math.round(idle / 60000)}min)`);
+                await this.cleanupInstance(topicId);
+            }
+        }
+    }
+    /**
+     * 清理指定 Topic 的 Franky 实例
+     */
+    async cleanupInstance(topicId) {
+        const instance = this.instances.get(topicId);
+        if (!instance)
+            return;
+        try {
+            await instance.mcpServer.close();
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] MCP server 关闭失败:`, err);
+        }
+        try {
+            await this.broker.dispose(instance.instanceId);
+        }
+        catch {
+            // 可能已经退出
+        }
+        this.instances.delete(topicId);
+    }
+    /**
+     * 通过 instanceId 反查 topicId
+     */
+    findTopicByInstanceId(instanceId) {
+        for (const [topicId, instance] of this.instances) {
+            if (instance.instanceId === instanceId)
+                return topicId;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=franky-orchestrator.js.map

package/apps/server/dist/franky/index.js

@@ -0,0 +1,5 @@
+export { FrankyOrchestrator } from './franky-orchestrator.js';
+export { startFrankyMcpServer } from './franky-mcp-server.js';
+export { FrankyTopicRouter } from './topic-router.js';
+export { buildTopicContext, writeTopicContext } from './context-builder.js';
+//# sourceMappingURL=index.js.map

package/apps/server/dist/franky/topic-router.js

@@ -0,0 +1,16 @@
+/**
+ * TopicRouter 实现：将消息路由给对应 Topic 的 Franky 实例
+ */
+export class FrankyTopicRouter {
+    orchestrator;
+    logger;
+    constructor(orchestrator, logger) {
+        this.orchestrator = orchestrator;
+        this.logger = logger ?? { info: console.log, error: console.error };
+    }
+    async routeToTopic(topicId, msg) {
+        this.logger.info(`[TopicRouter] 路由消息到专项 ${topicId}: ${msg.sender}`);
+        await this.orchestrator.sendMessage(topicId, msg);
+    }
+}
+//# sourceMappingURL=topic-router.js.map

package/apps/server/dist/gateway/feishu-sender.js

@@ -135,6 +135,7 @@ export class FeishuSender {
             data: {
                 content: JSON.stringify({ text: params.text }),
                 msg_type: 'text',
+                ...(params.replyInThread ? { reply_in_thread: true } : {}),
             },
         });
         if (response.code !== 0) {
@@ -142,6 +143,25 @@ export class FeishuSender {
         }
         return response.data?.message_id ?? 'unknown';
     }
+    /**
+     * 获取回复消息的 thread_id（创建话题后从响应中提取）
+     */
+    async sendReplyInThread(params) {
+        const response = await this.client.im.message.reply({
+            path: { message_id: params.replyToMessageId },
+            data: {
+                content: JSON.stringify({ text: params.text }),
+                msg_type: 'text',
+                reply_in_thread: true,
+            },
+        });
+        if (response.code !== 0) {
+            throw new Error(`飞书创建话题失败: ${response.msg || `code ${response.code}`}`);
+        }
+        const messageId = response.data?.message_id ?? 'unknown';
+        const threadId = response.data?.thread_id ?? null;
+        return { messageId, threadId };
+    }
     // ── 图片上传与发送 ──
     /**
      * 上传图片到飞书（获取 image_key）
@@ -265,13 +285,39 @@ export class FeishuSender {
         return response.data?.message_id ?? 'unknown';
     }
     // ── 表情回复（Reaction）──
+    /** "处理中"指示 emoji，收到消息时添加，回复后移除 */
+    static TYPING_EMOJI = 'OneSecond';
+    /** 待清除的 typing reaction，key 为 chatId */
+    pendingTypingReactions = new Map();
+    /**
+     * 给消息添加"处理中"表情，并记录到 pending 映射
+     *
+     * 收到消息后立即调用，大模型回复或出错时通过 clearTypingReaction 移除。
+     */
+    async addTypingReaction(chatId, messageId) {
+        const reactionId = await this.addReaction(messageId, FeishuSender.TYPING_EMOJI);
+        if (reactionId) {
+            this.pendingTypingReactions.set(chatId, { messageId, reactionId });
+        }
+    }
+    /**
+     * 清除指定群聊的"处理中"表情
+     *
+     * 在大模型回复、冷启动回复、或出错回复时调用。
+     */
+    async clearTypingReaction(chatId) {
+        const pending = this.pendingTypingReactions.get(chatId);
+        if (!pending)
+            return;
+        this.pendingTypingReactions.delete(chatId);
+        await this.deleteReaction(pending.messageId, pending.reactionId);
+    }
     /**
      * 给消息添加表情回复
      *
-     * 用于收到用户消息后立即反馈"已收到"，无需等待 Agent 处理完成。
      * 调用飞书 POST /im/v1/messages/{message_id}/reactions
      */
-    async addReaction(messageId, emojiType = 'OnIt') {
+    async addReaction(messageId, emojiType) {
         try {
             const response = await this.client.im.messageReaction.create({
                 path: { message_id: messageId },
@@ -290,6 +336,24 @@ export class FeishuSender {
             return null;
         }
     }
+    /**
+     * 删除消息上的表情回复
+     *
+     * 调用飞书 DELETE /im/v1/messages/{message_id}/reactions/{reaction_id}
+     */
+    async deleteReaction(messageId, reactionId) {
+        try {
+            const response = await this.client.im.messageReaction.delete({
+                path: { message_id: messageId, reaction_id: reactionId },
+            });
+            if (response.code !== 0) {
+                console.warn(`[feishu-sender] 删除表情回复失败: ${response.msg || `code ${response.code}`}`);
+            }
+        }
+        catch (err) {
+            console.warn('[feishu-sender] 删除表情回复异常:', err);
+        }
+    }
     // ── 出站场景 ──
     async sendBlockedAlert(params) {
         // 用自然语言，不用制式模板

package/apps/server/dist/gateway/feishu-ws.js

@@ -28,6 +28,7 @@ export async function parseFeishuMessage(event, eventId, downloader) {
             ...(event.header?.create_time ? { event_create_time: event.header.create_time } : {}),
             ...(msg.parent_id ? { parent_message_id: msg.parent_id } : {}),
             ...(msg.root_id ? { root_message_id: msg.root_id } : {}),
+            ...(msg.thread_id ? { thread_id: msg.thread_id } : {}),
         },
     };
 }
@@ -181,10 +182,10 @@ export class FeishuWSClient {
                         return;
                     const eventId = event.header?.event_id;
                     const message = await parseFeishuMessage(event, eventId, this.mediaDownloader);
-                    // 立即添加表情回复（fire-and-forget，不阻断消息处理）
-                    if (this.feishuSender && event.message.message_id) {
-                        this.feishuSender.addReaction(event.message.message_id, 'OnIt').catch(err => {
-                            this.log.warn({ err }, '表情回复失败');
+                    // 立即添加"处理中"表情（fire-and-forget，大模型回复后会自动移除）
+                    if (this.feishuSender && event.message.message_id && event.message.chat_id) {
+                        this.feishuSender.addTypingReaction(event.message.chat_id, event.message.message_id).catch(err => {
+                            this.log.warn({ err }, 'typing 表情添加失败');
                         });
                     }
                     // 解析发送者名称（异步，不阻断消息处理）

package/apps/server/dist/gateway/message-intake.js

@@ -1,11 +1,11 @@
-import { insertMessageLog } from '@team-anya/db';
+import { insertMessageLog, getTopicByThreadId } from '@team-anya/db';
 export class MessageIntake {
     deps;
     constructor(deps) {
         this.deps = deps;
     }
     /**
-     * 处理新消息：最小检测 + 透传给 Loid
+     * 处理新消息：审计记录 → 命令拦截 → Topic 路由 → Loid
      */
     async handle(message) {
         const logger = this.deps.logger;
@@ -40,9 +40,26 @@ export class MessageIntake {
                 return;
             }
         }
-        // 2. 构建上下文（含产品/项目注册表）
+        // 2. Topic 路由分叉（严格 thread_id 匹配，omt_ 前缀）
+        if (this.deps.topicRouter) {
+            const threadId = message.metadata?.thread_id;
+            if (threadId) {
+                try {
+                    const topic = getTopicByThreadId(this.deps.db, threadId);
+                    if (topic) {
+                        logger?.info(`[MessageIntake] 路由到专项 ${topic.id}: ${message.sender}@${threadId}`);
+                        await this.deps.topicRouter.routeToTopic(topic.id, message);
+                        return;
+                    }
+                }
+                catch (err) {
+                    logger?.error('[MessageIntake] Topic 路由查询失败，降级走 Loid:', err);
+                }
+            }
+        }
+        // 3. 构建上下文（含产品/项目注册表）
         const context = await this.deps.contextBuilder.buildMessageContext(message);
-        // 3. 透传给 Loid（完全自主判断）
+        // 4. 透传给 Loid（完全自主判断）
         logger?.info(`[MessageIntake] 转发消息给 Loid: ${message.sender}@${message.chatId ?? 'DM'}`);
         await this.deps.loidBrain.handleNewMessage(context);
     }

package/apps/server/dist/loid/brain.js

@@ -45,6 +45,7 @@ export class LoidBrain {
             logger: this.config.logger,
         }, {
             db: this.deps.mcpDeps.db,
+            feishuSender: this.deps.feishuSender,
         });
         this.ready = true;
         this.config.logger?.info('LoidBrain 已初始化 (Session 模式)');

package/apps/server/dist/loid/mcp-server.js

@@ -13,6 +13,7 @@ function createMcpServer(deps) {
         channelRegistry: deps.channelRegistry,
         logger: deps.logger,
         onMessageSent: deps.onMessageSent,
+        threadCreator: deps.threadCreator,
         yorOrchestrator: deps.yorOrchestrator,
         getProjectConfig: deps.getProjectConfig,
         onProjectChanged: deps.onProjectChanged,