@yvhitxcel/opencode-remote 0.15.1 → 0.16.0

package/README.md

@@ -2,12 +2,28 @@
 
 通过微信、Telegram、飞书等平台随时随地控制 OpenCode。
 
+## 为什么这么爽？
+
+**输入一个字母 `z`，14 位 AI 专家帮你审项目。** 架构师、安全研究员、测试工程师、运维……每人给出犀利点评，技术经理汇总 P0-P2 任务清单。你在手机上躺着看就行。
+
+```bash
+# 安装
+npm install -g @yvhitxcel/opencode-remote
+
+# 开干
+opencode-remote telegram
+# → 输入 /z 叫专家团队
+# → 输入 z 让专家分析项目
+# → AI 自动干活，你喝茶
+```
+
 ## 功能特性
 
-- **多平台支持** — 微信、飞书、Telegram
-- **多 AI Agent** — OpenCode、Claude Code、Codex、GitHub Copilot
-- **会话管理** — 多会话并行，自动保存与恢复
-- **智能循环任务** — 长时间任务自动循环执行
+- **🤖 专家评审系统** — `/z` 一键召唤 14 位 AI 专家，自动分析、投票、出方案
+- **📱 多平台支持** — 微信、飞书、Telegram
+- **🧠 多 AI Agent** — OpenCode、Claude Code、Codex、GitHub Copilot
+- **🔄 循环任务** — `/loop` 让 AI 持续干活
+- **🔍 一键诊断** — `/diagnose` 检查各组件状态
 
 ## 安装
 
@@ -17,15 +33,42 @@ npm install -g opencode-remote
 
 ## 快速开始
 
+推荐路径：**Telegram（5分钟）→ 微信（10分钟）→ 飞书（30分钟）**
+
 ```bash
-# 微信
+# 1. 安装
+npm install -g @yvhitxcel/opencode-remote
+
+# 2. 启动 Telegram（最快上手，无需配置）
+opencode-remote telegram
+# 在 Telegram 里搜索你的 bot，发送 /start
+
+# 3. 微信（需要 iLink 平台账号）
 opencode-remote weixin
+# 扫码登录后即可使用
 
-# 飞书
+# 4. 飞书（需要企业版账号）
 opencode-remote feishu
+```
 
-# Telegram
-opencode-remote telegram
+## 首次使用
+
+1. 安装后运行 `opencode-remote telegram`
+2. 在 Telegram 里找到你的 bot，发送 `/start`
+3. 发送 `/help` 查看所有命令
+4. 发送一条消息给 AI，比如"你好"
+5. **发送 `/z` 启动专家模式，然后发送 `z` —— 14 位 AI 专家开始分析你的项目**
+
+> 💡 所有核心功能（对话、会话管理、AI 模型切换、专家评审）无需任何配置。只有 `/upload` 上传才需要七牛云。
+
+## 手机开发工作流
+
+把 `weixin.bat` 复制到项目根目录，双击运行，扫码登录后即可在手机上通过微信开发该项目。
+
+```bash
+# 或者手动指定目录
+cd 你的项目
+opencode-remote
 ```
 
 ## 平台兼容性
@@ -90,10 +133,37 @@ opencode-remote
 
 **七牛云是可选的**，不配也能用全部核心功能。只有上传构建产物才需要配置。
 
+## 常见问题
+
+**Q: 为什么有些命令不能用？**
+A: 先运行 `/diagnose` 检查各组件状态。Telegram 功能最全，微信和飞书部分命令需要额外配置。
+
+**Q: 微信怎么登录？**
+A: 运行 `opencode-remote weixin`，终端会显示二维码，用微信扫码即可。
+
+**Q: 专家评审怎么用？**
+A: 发 `z` 或 `叫全部专家`，AI 自动扫项目、组队评审、出 P0/P1 修复方案，**然后自动修代码**。评审过程包括三级质量保障：脑内路径追踪、服务端模拟验证、对抗评审。
+
+**Q: `/z` 什么时候用？**
+A: 任何时候。发一个 `z` 让 AI 评审当前项目，发 `z 帮我看看这个bug` 聚焦具体问题。先 `/z` 设置自定义 prompt 再发问题也行。
+
+**Q: `/z` 自动修代码会改坏吗？**
+A: **强烈建议在 git 仓库中使用。** 如果改坏了可以 `git checkout .` 回滚。没有 git 的项目，AI 改完不可逆。不确定的话先发 `/z off` 关闭自动执行，只看报告不改代码。
+
+**Q: 需要自己的服务器吗？**
+A: 需要一台电脑运行 bot，手机上通过 IM 控制。OpenCode 也运行在这台电脑上。
+
+**Q: 如何更新？**
+A: `npm update -g @yvhitxcel/opencode-remote`
+
 ## 系统要求
 
 - Node.js >= 18.0.0
 
+## 致谢
+
+本项目基于 [opencode-remote-control](https://github.com/ceociocto/opencode-remote-control) 开发。
+
 ## 许可证
 
 MIT License

package/dist/core/auth.js

@@ -1,119 +1,52 @@
-// Authorization management for OpenCode Remote Control
-// First user to send /start becomes the owner automatically
-const authState = {
-    telegramOwner: null,
-    feishuOwner: null,
-    weixinOwner: null,
-};
-// Auth file path for persistence
 import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-const AUTH_DIR = join(homedir(), '.opencode-remote');
-const AUTH_FILE = join(AUTH_DIR, 'auth.json');
-function ensureAuthDir() {
-    if (!existsSync(AUTH_DIR)) {
-        mkdirSync(AUTH_DIR, { recursive: true });
-    }
-}
-function loadAuth() {
-    try {
-        if (existsSync(AUTH_FILE)) {
-            const data = JSON.parse(readFileSync(AUTH_FILE, 'utf-8'));
-            authState.telegramOwner = data.telegramOwner || null;
-            authState.feishuOwner = data.feishuOwner || null;
-            authState.weixinOwner = data.weixinOwner || null;
-        }
-    }
-    catch (error) {
-        console.warn('Failed to load auth state, starting fresh:', error);
-    }
-}
-function saveAuth() {
-    try {
-        ensureAuthDir();
-        writeFileSync(AUTH_FILE, JSON.stringify(authState, null, 2));
-    }
-    catch (error) {
-        console.error('Failed to save auth state:', error);
-    }
-}
-// Initialize on module load
-loadAuth();
+
+const OWNER_KEY = { telegram: 'telegramOwner', feishu: 'feishuOwner', weixin: 'weixinOwner' };
+const AUTH_FILE = join(homedir(), '.opencode-remote', 'auth.json');
+
+const state = { telegramOwner: null, feishuOwner: null, weixinOwner: null };
+
+function load() {
+  try {
+    if (existsSync(AUTH_FILE)) {
+      const d = JSON.parse(readFileSync(AUTH_FILE, 'utf-8'));
+      for (const k of Object.keys(OWNER_KEY)) state[OWNER_KEY[k]] = d[OWNER_KEY[k]] || null;
+    }
+  } catch (e) { console.warn('[auth] load failed:', e.message); }
+}
+function save() {
+  try {
+    const dir = join(homedir(), '.opencode-remote');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(state, null, 2));
+  } catch (e) { console.error('[auth] save failed:', e.message); }
+}
+load();
+
 export function isAuthorized(platform, userId) {
-    if (platform === 'telegram') {
-        return authState.telegramOwner === userId;
-    }
-    else if (platform === 'feishu') {
-        return authState.feishuOwner === userId;
-    }
-    else {
-        return authState.weixinOwner === userId;
-    }
+  const key = OWNER_KEY[platform];
+  return key ? state[key] === userId : false;
 }
 export function hasOwner(platform) {
-    if (platform === 'telegram') {
-        return authState.telegramOwner !== null;
-    }
-    else if (platform === 'feishu') {
-        return authState.feishuOwner !== null;
-    }
-    else {
-        return authState.weixinOwner !== null;
-    }
-}
-export function claimOwnership(platform, userId) {
-    if (platform === 'telegram') {
-        if (authState.telegramOwner) {
-            if (authState.telegramOwner === userId) {
-                return { success: true, message: 'already_owner' };
-            }
-            return { success: false, message: 'already_claimed' };
-        }
-        authState.telegramOwner = userId;
-        saveAuth();
-        return { success: true, message: 'claimed' };
-    }
-    else if (platform === 'feishu') {
-        if (authState.feishuOwner) {
-            if (authState.feishuOwner === userId) {
-                return { success: true, message: 'already_owner' };
-            }
-            return { success: false, message: 'already_claimed' };
-        }
-        authState.feishuOwner = userId;
-        saveAuth();
-        return { success: true, message: 'claimed' };
-    }
-    else {
-        // weixin
-        if (authState.weixinOwner) {
-            if (authState.weixinOwner === userId) {
-                return { success: true, message: 'already_owner' };
-            }
-            return { success: false, message: 'already_claimed' };
-        }
-        authState.weixinOwner = userId;
-        saveAuth();
-        return { success: true, message: 'claimed' };
-    }
+  const key = OWNER_KEY[platform];
+  return key ? state[key] !== null : false;
 }
 export function getOwner(platform) {
-    if (platform === 'telegram') {
-        return authState.telegramOwner;
-    }
-    else if (platform === 'feishu') {
-        return authState.feishuOwner;
-    }
-    else {
-        return authState.weixinOwner;
-    }
+  const key = OWNER_KEY[platform];
+  return key ? state[key] : null;
+}
+export function claimOwnership(platform, userId) {
+  const key = OWNER_KEY[platform];
+  if (!key) return { success: false, message: 'unknown_platform' };
+  if (state[key]) {
+    if (state[key] === userId) return { success: true, message: 'already_owner' };
+    return { success: false, message: 'already_claimed' };
+  }
+  state[key] = userId;
+  save();
+  return { success: true, message: 'claimed' };
 }
-// For debugging/display
 export function getAuthStatus() {
-    return {
-        telegram: authState.telegramOwner !== null,
-        feishu: authState.feishuOwner !== null,
-        weixin: authState.weixinOwner !== null,
-    };
+  return { telegram: !!state.telegramOwner, feishu: !!state.feishuOwner, weixin: !!state.weixinOwner };
 }

package/dist/core/router.js

@@ -7,7 +7,6 @@ export const COMMAND_ALIASES = {
     help: ['help', 'h', '?'],
     status: ['status'],
     reset: ['reset'],
-    stop: ['stop'],
     restart: ['restart'],
     sessions: ['sessions', 'sw'],
     delsessions: ['delsessions', 'del'],
@@ -25,7 +24,116 @@ export const COMMAND_ALIASES = {
     copilot: ['copilot'],
     agents: ['agents'],
     model: ['model'],
-    expert: ['expert', 'z', 'review'],
+    expert: ['expert', 'z', 'Z', 'review'],
+};
+
+export const EXPERT_SYSTEM_PROMPT = `你是一个专家评审系统。用户消息含触发词（z/c/叫全部专家/专家点评）时启动评审，前后可带具体问题则聚焦该问题。
+
+## 角色（14 位）
+1. 架构师 — 代码架构、模块划分、依赖管理
+2. 后端工程师 — 稳定性、错误处理、性能
+3. 测试工程师 — 测试覆盖、可测性
+4. VC / 投资人 — 值不值得投
+5. 开源社区经理 — 新人能不能上车
+6. Flutter 开发者 — 移动端好不好用
+7. SRE / 运维 — 能不能上线
+8. 安全研究员 — 有没有洞
+9. AI 研究员 — agent loop 质量
+10. 用户支持 — 用户卡在哪
+11. 技术写作者 — 文档好不好写
+12. 竞品分析师 — 市场定位
+13. Git 专家 — commit 质量、分支管理、历史整洁度、回滚安全
+14. **技术经理（最后出场）** — 汇总以上 13 位意见，给出 P0-P2 分级的可执行任务清单
+
+## 执行流程
+
+### 第 1 步：1-13 号专家点评
+每人最多 200 字。**言辞必须苛刻、犀利、严谨。不讨好，不委婉。不投票。**
+- 如果某条意见在上轮已提过但未修复，必须指出"上轮已提过，未落实"
+- 格式: \`[意见] 内容 / [上轮已提: N]\`
+
+### 第 2 步：技术经理提出 15 条问题
+基于以上 13 位意见，输出 1) 2) ... 15) 清单。
+- **1-5 为 P0（红色🔴）**，6-10 为 P1（黄色🟡），11-15 为 P2（蓝色🔵）
+- 每条包含一句话描述（做什么），不展开
+- 小 bug 合并同类项，一条 = 一个可执行动作
+- **每条必须标注对应的专家意见编号**（格式: \`1) xxx [来源: 3,7,11]\`）
+- **不含投票结果。不含投票结果。不含投票结果。**
+
+### 第 3 步：1-13 号专家投票
+每人从 15 条中选 3 条最关键的。格式：\`-> 三票：1, 7, 12\`
+- **投票时必须检查自己上轮的意见是否已落实，如未落实则优先投票给相关条目**
+
+### 第 4 步：技术经理公布结果
+得票统计，汇入 P0-P2，标记得票数。
+- **P0 🔴 1) xxx ( 票）[来源: 3,7] — 说明**
+- **P1 🟡 7) xxx ( 票）[来源: 1,5] — 说明**
+
+### 第 5 步：自动执行
+对 P0（票数 ≥ 3）按得票从高到低逐个自动执行修复。
+
+## 三级质量保障（嵌入评审全程）
+
+### 1. 脑内执行路径追踪
+在评审和修复代码时，**在脑中逐条执行关键路径**：变量怎么赋值、条件怎么分支、循环怎么迭代、异常怎么传播。不只看代码静态结构，要模拟运行时行为。发现逻辑断点、边界遗漏、状态覆盖不全立即提出。
+
+### 2. 服务端模拟验证
+对评审中发现的 P0/P1 问题，在修复后**自动执行模拟验证**：
+- 跑 \`npm run lint\` 检查语法和模块图
+- 跑 \`node --test\` 验证单元测试
+- 对修改的文件做 \`node --check\` 语法校验
+- 如果项目有 CI 脚本，触发本地等效检查
+- 验证结果写入执行总结
+
+### 3. LLM 对抗评审
+修复完成后，**以对抗视角重新审视自己的修改**："这段修改有没有引入新 bug？有没有遗漏边界情况？变更是否最小？会不会破坏现有功能？"
+- 如果发现自己的修改有问题→回退重做
+- 如果确认无误→在总结中标注"已通过对抗评审"
+
+## 核心三要素
+1. **吃透代码再动手** — 不靠猜测修复 bug
+2. **追到根因** — 用户反馈的现象要追到代码根因
+3. **改完必须验证** — 先跑测试跑 lint 再交付
+
+## 四项基本原则（硬约束）
+
+1. **一次性做好，不重复返工** — 同一个模块的同类问题最多修两轮。第三轮还提同类问题说明方案不对，技术经理必须输出"换方案"而非"继续修"。
+
+2. **以用户价值为导向** — P0 排序：用户能不能跑起来 > 会不会崩 > 好不好用。内部代码质量默认不进 P0。
+
+3. **对用户友好** — 每次评审必须包含"首次使用视角"。P0 必须至少有一条直接回应首次使用视角。**若没有，整轮评审无效。**
+
+4. **快速迭代，先上线** — R4 开始技术经理必须回答"是否可以发布？最短路径是什么？" 是则只保留阻塞发布的问题。
+
+## 规则
+- 言辞苛刻犀利，不讨好，不委婉
+- 节约 token：摘要不超过 400 字，不贴源码
+- 上轮已提过且已修的问题本轮不得再提（除非验收不合格）
+- 技术经理的 15 条必须标注来源，**没有对应来源的问题不得出现**`;
+
+const COMMAND_HELP = {
+    start: '认领所有权',
+    help: '显示帮助',
+    status: '连接状态',
+    reset: '重置会话',
+    restart: '重启 Bot',
+    sessions: '浏览会话',
+    delsessions: '删除会话',
+    loop: '循环任务',
+    edit: '编辑消息',
+    diagnose: '系统诊断',
+    refresh: '刷新上下文',
+    copy: '复制回复',
+    revert: '撤销消息',
+    upload: '上传文件',
+    delete: '删除上传文件',
+    oc: '使用 OpenCode',
+    cc: '使用 Claude Code',
+    cx: '使用 Codex',
+    copilot: '使用 Copilot',
+    agents: '查看 Agent',
+    model: '切换模型',
+    expert: '专家评审(z/叫全部专家)',
 };
 
 const COMMAND_MAP = {};
@@ -35,6 +143,46 @@ for (const [cmd, aliases] of Object.entries(COMMAND_ALIASES)) {
     }
 }
 
+/**
+ * 保持 typing 指示器常亮。每 8 秒刷新一次，30 秒无活动自熄。
+ * 调用 poke 刷新计时，done 手动关闭。
+ * 放在 core 层避免被各平台 handler 误删。
+ */
+export function startTypingPing(adapter, threadId) {
+    let lastActivity = Date.now();
+    const timer = setInterval(() => {
+        adapter.sendTypingIndicator(threadId).catch(() => {});
+        if (Date.now() - lastActivity > 30000) clearInterval(timer);
+    }, 3000);
+    return {
+        poke: () => { lastActivity = Date.now(); },
+        done: () => { clearInterval(timer); },
+    };
+}
+
+export function getHelpText() {
+    const lines = ['📖 指令\n'];
+    const groups = [
+        ['🟢 常用', ['start', 'help', 'status', 'reset', 'copy', 'revert', 'diagnose']],
+        ['🔄 任务', ['loop', 'refresh', 'restart']],
+        ['📂 会话', ['sessions', 'delsessions']],
+        ['🤖 AI', ['model', 'agents', 'oc', 'cc']],
+        ['⬆️ 文件', ['upload', 'delete']],
+        ['🧠 专家', ['expert']],
+    ];
+    for (const [title, cmds] of groups) {
+        lines.push(title);
+        for (const cmd of cmds) {
+            const aliases = COMMAND_ALIASES[cmd];
+            const aliasStr = aliases.length > 1 ? ` (${aliases.slice(1).join(', ')})` : '';
+            lines.push(`  /${cmd}${aliasStr} — ${COMMAND_HELP[cmd] || cmd}`);
+        }
+        lines.push('');
+    }
+    lines.push('💬 直接发消息给 AI!');
+    return lines.join('\n');
+}
+
 export function detectCommand(text) {
     const trimmed = text.trim();
     if (trimmed === 'h' || trimmed === '?') {
@@ -106,33 +254,7 @@ export async function routeMessage(parsed, ctx) {
         case 'command': {
             switch (parsed.command) {
                 case 'help':
-                    return `📖 指令
-
-🟢 常用:
-/start — 首次认证
-/help — 帮助
-/status — 连接状态
-/reset — 清空会话
-/copy — 复制回复
-/revert — 撤销消息
-
-🔄 任务:
-/loop — 循环执行
-/refresh — 刷新上下文
-/restart — 重启 bot
-/stop — 停止 bot
-
-📂 会话:
-/sessions — 浏览会话
-/delsessions — 删除会话
-
-🤖 AI 模型:
-/model — 切换模型
-/agents — 查看可用 Agent
-/oc — 使用 OpenCode
-/cc — 使用 Claude Code
-
-💬 直接发消息给 AI!`;
+                    return getHelpText();
 
                 case 'agents': {
                     const agents = registry.listAgents();
@@ -165,9 +287,6 @@ export async function routeMessage(parsed, ctx) {
                 case 'restart':
                     return '🔄 重启信号已发送，bot 即将重启...';
 
-                case 'stop':
-                    return '🛑 停止信号已发送';
-
                 case 'sessions': {
                     const sessions = await getSessionsList();
                     if (!sessions || sessions.length === 0) return '📭 暂无会话';
@@ -288,38 +407,11 @@ export async function routeMessage(parsed, ctx) {
                     return ctx.opencodeSessionId ? '✏️ 用法: /edit <消息编号>' : '❌ 没有活跃的会话';
 
                 case 'expert': {
-                    const { execSync } = await import('child_process');
-                    const { existsSync, readFileSync } = await import('fs');
-                    const { homedir } = await import('os');
-                    const { join } = await import('path');
-                    const projectRoot = process.cwd();
-                    let gitStatus = '', recentCommits = '', dirTree = '';
-                    try { gitStatus = execSync('git status --short', { cwd: projectRoot, timeout: 5000, encoding: 'utf-8' }); } catch { gitStatus = '(not a git repo)'; }
-                    try { recentCommits = execSync('git log --oneline -5', { cwd: projectRoot, timeout: 5000, encoding: 'utf-8' }); } catch { recentCommits = '(no commits)'; }
-                    try { dirTree = execSync('cmd /c "tree /F /A"', { cwd: projectRoot, timeout: 5000, encoding: 'utf-8' }); } catch { dirTree = '(failed to get tree)'; }
-                    const customPromptPath = join(homedir(), '.opencode-remote', 'expert-prompt.md');
-                    let promptTemplate = '';
-                    if (existsSync(customPromptPath)) {
-                        promptTemplate = readFileSync(customPromptPath, 'utf-8');
-                    } else {
-                        promptTemplate = `你是一个软件工程专家团队。请按以下流程执行：
-
-## 项目上下文
-{git_status}
-{recent_commits}
-{directory_tree}
-
-## 要求
-1. 分析项目当前状态
-2. 找出问题
-3. 给出改进建议`;
-                    }
-                    const prompt = promptTemplate.replace('{git_status}', gitStatus.trim()).replace('{recent_commits}', recentCommits.trim()).replace('{directory_tree}', dirTree.trim());
                     const agent = registry.findAgent('opencode');
                     if (!agent) return '❌ OpenCode agent not found';
                     const available = await agent.isAvailable().catch(() => false);
                     if (!available) return '❌ OpenCode 不可用';
-                    const response = await agent.sendPrompt(ctx.threadId || 'expert-review', prompt, []);
+                    const response = await agent.sendPrompt(ctx.threadId || 'expert-review', EXPERT_SYSTEM_PROMPT + '\n\n用户问题：' + (parsed.arg || '请评审当前项目'), []);
                     return response || '无响应';
                 }
 

package/dist/feishu/commands.js

@@ -3,7 +3,7 @@ import { splitMessage } from '../core/notifications.js';
 import { EMOJI } from '../core/types.js';
 import { initOpenCode, createSession, sendMessage, checkConnection, abortSession, resumeSession, revertSessionMessage, unrevertSession, listProviders, updateGlobalModel } from '../opencode/client.js';
 import { claimOwnership } from '../core/auth.js';
-import { COMMAND_ALIASES, detectCommand } from '../core/router.js';
+import { COMMAND_ALIASES, detectCommand, getHelpText } from '../core/router.js';
 import { registry } from '../core/registry.js';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, basename } from 'path';
@@ -76,40 +76,7 @@ async function handleCommand(adapter, ctx, command, arg, openCodeSessions) {
             return true;
         }
         case 'help':
-            await adapter.reply(ctx.threadId, `📖 指令
-
-/start — 首次认证
-/help h ? — 帮助
-/status — 连接状态
-/reset — 清空会话
-/restart — 重启 bot
-/stop — 停止 bot
-/retry — 重试连接
-/approve .a .y .1 — 同意变更
-/reject .r .n .0 — 拒绝变更
-/diff — 查看变更
-/files — 已修改文件
-/sessions — 浏览会话
-/delsessions — 删除会话
-/loop — 循环任务
-/summary — 会话摘要
-/compact — 压缩会话上下文
-/copy — 复制最新 AI 回复
-/revert — 撤销 AI 回复
-/switchdir — 切换项目目录
-/scope — 设置上下文范围
-/analyze — 分析后执行
-/commit — 生成提交信息
-/review — 代码审查
-/flush — 刷新记忆
-
-🤖 AI 模型:
-/model — 切换模型
-/agents — 查看可用 Agent
-/oc — 使用 OpenCode
-/cc — 使用 Claude Code
-
-💬 直接发消息给 AI!`);
+            await adapter.reply(ctx.threadId, getHelpText());
             return true;
         case 'agents': {
             const agents = registry.listAgents();

package/dist/feishu/handler.js

@@ -2,46 +2,36 @@ import { getOrCreateSession } from '../core/session.js';
 import { splitMessage } from '../core/notifications.js';
 import { initOpenCode, createSession, sendMessage, checkConnection, resumeSession, shareSession } from '../opencode/client.js';
 import { isAuthorized, hasOwner } from '../core/auth.js';
-import { detectCommand } from '../core/router.js';
+import { detectCommand, EXPERT_SYSTEM_PROMPT } from '../core/router.js';
 import { handleCommand, formatTimeAgo } from './commands.js';
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
-const EXPERT_SYSTEM_PROMPT = `你是一个专家角色扮演系统，严格按照 AGENTS.md 中的"专家点评系统"流程执行。
-
-当用户输入包含触发词（z / 叫全部专家 / 叫所有专家 / 呼叫专家点评 / 专家点评 / 专家意见 / call all experts / expert review）时，启动专家评审。
-
-## 规则
-- 严格遵循 AGENTS.md 中定义的 13 位角色和点评流程
-- 言辞必须苛刻犀利，不讨好不委婉
-- 不说客套话
-- 直接指出问题`;
-
 async function handleMessage(adapter, ctx, text, openCodeSessions) {
     const session = await getOrCreateSession(ctx.threadId, 'feishu');
 
+    const expertTriggers = ['z', 'Z', '叫全部专家', '叫所有专家', '呼叫专家点评', '专家点评', '专家意见', 'call all experts', 'expert review', '专家会诊', '团队评审', '代码审查', '全员review', 'review all', '请专家', '叫专家', '找专家'];
+    let expertPrompt = null;
+
     if (text.startsWith('/z')) {
         const arg = text.slice(2).trim();
         if (arg === 'off' || arg === 'reset' || arg === '关闭') {
-            session.expertMode = false;
-            session.systemPrompt = null;
-            await adapter.reply(ctx.threadId, '⏹️ 专家模式已关闭');
+            await adapter.reply(ctx.threadId, '⏹️ 自定义 prompt 已清除');
             return;
         }
         if (arg) {
-            session.expertMode = true;
-            session.systemPrompt = arg;
-            await adapter.reply(ctx.threadId, `✅ 自定义专家 prompt 已设置 (${arg.length}字)`);
-            return;
-        }
-        if (!session.expertMode) {
-            session.expertMode = true;
-            session.systemPrompt = EXPERT_SYSTEM_PROMPT;
+            expertPrompt = arg;
+        } else {
+            expertPrompt = EXPERT_SYSTEM_PROMPT;
         }
-        await adapter.reply(ctx.threadId, '✅ 专家模式已启动，直接发送你的问题\n/z off — 关闭\n/z <内容> — 自定义 prompt');
+        await forwardToOpenCode(adapter, ctx, text, openCodeSessions, session, expertPrompt);
         return;
     }
 
+    if (expertTriggers.some(t => text.trim().toLowerCase().includes(t))) {
+        expertPrompt = EXPERT_SYSTEM_PROMPT;
+    }
+
     const parsed = detectCommand(text);
     if (parsed) {
         await handleCommand(adapter, ctx, parsed.name, parsed.arg, openCodeSessions);
@@ -222,7 +212,7 @@ async function handleMessage(adapter, ctx, text, openCodeSessions) {
     await forwardToOpenCode(adapter, ctx, text, openCodeSessions, session);
 }
 
-async function forwardToOpenCode(adapter, ctx, text, openCodeSessions, session) {
+async function forwardToOpenCode(adapter, ctx, text, openCodeSessions, session, expertPrompt) {
     await adapter.sendTypingIndicator(ctx.threadId);
     let openCodeSession = openCodeSessions.get(ctx.threadId);
     if (!openCodeSession) {
@@ -258,8 +248,8 @@ async function forwardToOpenCode(adapter, ctx, text, openCodeSessions, session)
         }
     }
 
-    if (session.expertMode && session.systemPrompt) {
-        scopedText = `${session.systemPrompt}\n\n${scopedText}`;
+    if (expertPrompt) {
+        scopedText = `${expertPrompt}\n\n${scopedText}`;
     }
 
     console.log(`📤 Forwarding to OpenCode: ${text.substring(0, 80)}...`);
@@ -268,6 +258,7 @@ async function forwardToOpenCode(adapter, ctx, text, openCodeSessions, session)
         let hasToolActivity = false;
         let toolCallCount = 0;
         let response = await sendMessage(openCodeSession, scopedText, {
+            idleThreshold: expertPrompt ? 30 : 10,
             onEvent: (event) => {
                 if (event.type === 'tool.call') {
                     const props = event.properties || {};