team-anya-cli 0.1.5 → 0.1.7

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）

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 } : {}),
         },
     };
 }

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/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,

package/apps/server/dist/loid/session-manager.js

@@ -9,16 +9,6 @@ export class LoidSessionManager {
     config;
     deps;
     logger;
-    /** 冷启动时随机回复的话术池 */
-    static COLD_START_REPLIES = [
-        '稍等，我先理一下思路',
-        '好，我想想',
-        '让我看看',
-        '收到，稍等一下',
-        '我先看看上下文',
-        '好的，等我一下',
-    ];
-    lastColdStartIndex = -1;
     /** 崩溃恢复中的话术池（像同事重启电脑一样自然） */
     static CRASH_RECOVERY_REPLIES = [
         '抱歉，刚才脑子卡了一下，我重新捋一下',
@@ -48,11 +38,6 @@ export class LoidSessionManager {
         } while (idx === lastIndex && pool.length > 1);
         return { text: pool[idx], index: idx };
     }
-    pickColdStartReply() {
-        const { text, index } = this.pickRandom(LoidSessionManager.COLD_START_REPLIES, this.lastColdStartIndex);
-        this.lastColdStartIndex = index;
-        return text;
-    }
     pickCrashRecoveryReply() {
         const { text, index } = this.pickRandom(LoidSessionManager.CRASH_RECOVERY_REPLIES, this.lastCrashRecoveryIndex);
         this.lastCrashRecoveryIndex = index;
@@ -80,22 +65,6 @@ export class LoidSessionManager {
             // session 已销毁，删除并新建
             this.sessions.delete(key);
         }
-        // 冷启动：先回复一句话，让用户知道系统在处理
-        const messageId = ctx.message.metadata?.message_id;
-        if (this.deps.feishuSender && messageId) {
-            const reply = this.pickColdStartReply();
-            this.deps.feishuSender.sendReply({
-                text: reply,
-                replyToMessageId: messageId,
-            }).then(() => {
-                // 冷启动回复成功后，移除"处理中"表情
-                this.deps.feishuSender.clearTypingReaction(key).catch(() => { });
-            }).catch(err => {
-                this.logger.error('[SessionManager] 冷启动回复失败:', err);
-                // 即使回复失败也清除 typing reaction
-                this.deps.feishuSender.clearTypingReaction(key).catch(() => { });
-            });
-        }
         // 新建 session
         try {
             const session = await this.createSession(key);