team-anya 0.2.2 → 0.2.4

package/apps/server/dist/gateway/health-monitor.js

@@ -1,10 +1,4 @@
-import { getRecentMessages } from '@team-anya/db';
 // ── 话术池 ──
-const SILENT_RESULT_REPLIES = [
-    '刚才处理完了但好像漏说了结果，你再问我一下？',
-    '不好意思，刚才干完活忘了汇报，你可以再@我一下',
-    '处理完了但我好像没回你，抱歉，你再说一声我接上',
-];
 const STUCK_REPLIES = [
     '我这边好像卡住了，正在尝试恢复，如果一直没反应你踢我一下',
     '抱歉，我可能卡在某个环节了，你可以发条消息唤醒我试试',
@@ -17,37 +11,28 @@ function pickRandom(pool) {
 /**
  * 静默健康监控器
  *
- * 正常流程零感知，仅在异常时主动通知用户：
- * 1. CC result 到了但没回复用户 → 兜底通知
- * 2. CC 实例卡死（executing 但长时间无 progress） → 告警
+ * 正常流程零感知，仅在 CC 实例卡死（executing 但长时间无 progress）时主动通知用户。
  */
 export class HealthMonitor {
     deps;
     config;
     logger;
     scanTimer = null;
-    pendingChecks = new Map(); // instanceId → timer
     /** 已通知过卡死的实例，防止重复告警 */
     stuckNotified = new Set();
     constructor(deps, config = {}) {
         this.deps = deps;
         this.logger = deps.logger ?? { info: console.log, error: console.error };
         this.config = {
-            resultCheckDelayMs: config.resultCheckDelayMs ?? 10_000,
             stuckThresholdMs: config.stuckThresholdMs ?? 3 * 60_000,
             scanIntervalMs: config.scanIntervalMs ?? 30_000,
-            recentOutboundWindowMs: config.recentOutboundWindowMs ?? 30_000,
         };
     }
     /**
      * 启动监控：监听 broker 事件 + 启动定时扫描
      */
     start() {
-        // 场景 2：监听 result 事件，延迟检查是否有回复
-        this.deps.broker.on('instance.result', (instanceId, role, _result) => {
-            this.scheduleResultCheck(instanceId, role);
-        });
-        // 场景 3：定时扫描卡死实例
+        // 定时扫描卡死实例
         this.scanTimer = setInterval(() => this.checkStuckInstances(), this.config.scanIntervalMs);
         // 实例退出时清理追踪状态
         this.deps.broker.on('instance.exited', (instanceId) => {
@@ -66,36 +51,10 @@ export class HealthMonitor {
             clearInterval(this.scanTimer);
             this.scanTimer = null;
         }
-        for (const timer of this.pendingChecks.values()) {
-            clearTimeout(timer);
-        }
-        this.pendingChecks.clear();
         this.stuckNotified.clear();
         this.logger.info('[HealthMonitor] 已停止');
     }
-    // ── 场景 2：result 到了但没回复 ──
-    scheduleResultCheck(instanceId, role) {
-        // 如果已有待检查的 timer，先清掉（同一实例连续 result）
-        const existing = this.pendingChecks.get(instanceId);
-        if (existing)
-            clearTimeout(existing);
-        const timer = setTimeout(() => {
-            this.pendingChecks.delete(instanceId);
-            this.checkResultReply(instanceId, role);
-        }, this.config.resultCheckDelayMs);
-        this.pendingChecks.set(instanceId, timer);
-    }
-    checkResultReply(instanceId, role) {
-        const chatId = this.deps.resolveChatId(instanceId, role);
-        if (!chatId)
-            return; // 无法定位用户，跳过
-        if (this.hasRecentOutbound(chatId))
-            return; // 已回复，正常
-        // 没回复 → 发兜底通知
-        this.notify(chatId, 'silent_result');
-        this.logger.info(`[HealthMonitor] result 无回复兜底通知 (instance: ${instanceId}, chat: ${chatId})`);
-    }
-    // ── 场景 3：卡死检测 ──
+    // ── 卡死检测 ──
     checkStuckInstances() {
         const now = Date.now();
         const instances = this.deps.broker.status();
@@ -115,25 +74,13 @@ export class HealthMonitor {
             if (!chatId)
                 continue;
             this.stuckNotified.add(inst.id);
-            this.notify(chatId, 'stuck');
+            this.notify(chatId);
             this.logger.info(`[HealthMonitor] 卡死告警 (instance: ${inst.id}, idle: ${Math.round(elapsed / 1000)}s)`);
         }
     }
     // ── 工具方法 ──
-    hasRecentOutbound(chatId) {
-        const since = new Date(Date.now() - this.config.recentOutboundWindowMs).toISOString();
-        const messages = getRecentMessages(this.deps.db, {
-            direction: 'outbound',
-            chat_id: chatId,
-            since,
-            limit: 1,
-        });
-        return messages.length > 0;
-    }
-    notify(chatId, type) {
-        const text = type === 'silent_result'
-            ? pickRandom(SILENT_RESULT_REPLIES)
-            : pickRandom(STUCK_REPLIES);
+    notify(chatId) {
+        const text = pickRandom(STUCK_REPLIES);
         this.deps.feishuSender.sendText({
             receiveIdType: 'chat_id',
             receiveId: chatId,
@@ -143,11 +90,6 @@ export class HealthMonitor {
         });
     }
     cleanup(instanceId) {
-        const timer = this.pendingChecks.get(instanceId);
-        if (timer) {
-            clearTimeout(timer);
-            this.pendingChecks.delete(instanceId);
-        }
         this.stuckNotified.delete(instanceId);
     }
 }

package/blueprint/TOOLS.md

@@ -253,7 +253,11 @@
 | project.mode | string | `project` / `adhoc` |
 | project.repos | array | 仓库列表（project 模式，单仓库也是数组） |
 
-**约束**: Brief 只写做什么和标准，不写怎么做。派工三步走：`task.dispatch`(MCP) → bash 准备工作区 → `yor.spawn`(MCP)，三步缺一不可。
+**约束**: Brief 只写做什么和标准，不写怎么做。
+
+**派工一步到位**：dispatch 成功后自动启动 Yor，无需再手动调用 `yor.spawn`。
+返回值中 `instance_id` 为 Yor 实例 ID，`spawn_error`（如有）表示自动启动失败。
+dispatch 返回 status="blocked" 时不会启动 Yor，通知人类即可。
 
 ### task.lookup
 

package/blueprint/loid/PLAYBOOK.md

@@ -2,6 +2,12 @@
 
 ## 铁律
 
+### 禁止删除工作区
+
+**绝对不要执行 `rm -rf` 或任何方式删除工作区目录。** 任务完成后工作区由系统管理，不由你清理。原因：
+- 已完成的任务可能被 `task.escalate_to_topic` 升级为话题，需要 fork 源工作区
+- 工作区保留用于审计追溯
+
 ### 定向消息必须回应
 
 @Anya 或私聊的消息就是定向消息。收到后必须有明确的下一步动作，**且所有回复必须通过 `channel.send` 发出**（纯文本输出对方看不到）：
@@ -97,44 +103,42 @@ memory.search 没有结果？30 秒内组装调研 Brief → 派工 Yor → 回
 
 ## 派工流程
 
+**一步派工**：调用 `task.dispatch(...)` 即可，Yor 会自动启动。
+
 ```
-1. task.dispatch(MCP) → 创建任务 + 写 brief + 自动准备隔离工作区 → 返回 working_dir
-2. yor.spawn(MCP)     → 启动 Yor，传入 working_dir 和 brief_path
+result = task.dispatch({ title, brief, project_id, ... })
+// Yor 已自动启动，result.instance_id 为 Yor 实例 ID
+channel.send({ message: "已派工，稍等" })
 ```
 
-### Step 1: 创建任务 + 准备工作区
+### 返回值
 
-调用 `task.dispatch(...)`，返回：
 - `task_id`：任务 ID
 - `brief_path`：brief 文件绝对路径
 - `working_dir`：隔离工作区绝对路径
 - `status`：`dispatched`（成功）或 `blocked`（工作区准备失败）
-- `error`：失败原因（仅 status=blocked）
+- `instance_id`：Yor 实例 ID（成功时）
+- `spawn_error`：Yor 启动失败原因（任务已创建但 Yor 未启动，可手动调 `yor.spawn` 重试）
+- `error`：工作区准备失败原因（仅 status=blocked）
 
 工作区自动准备：
 - **project 模式**：自动 clone --local 到 `{workspaceDir}/{repo_name}`
 - **adhoc 模式**：自动 mkdir 到 `{taskDir}/adhoc`
 
-### Step 2: 启动 Yor
-
-调用 `yor.spawn(...)`，**必须原样传入 dispatch 返回的 `working_dir` 和 `brief_path`**。
-
-> **⚠️ 严禁修改 working_dir！** 不要传 repo 子目录（如 `WS-xxx/test-repo`），必须传工作区根目录（`WS-xxx/`）。工作区根目录包含 Yor 的角色文件（CLAUDE.md、PROFILE.md 等），Yor 启动后会自动在子目录中操作代码。
+### 异常处理
 
-dispatch 返回 status=blocked 时，不执行 yor.spawn——通知人类工作区准备失败的原因。
+- `status=blocked` → 通知人类工作区准备失败的原因
+- `spawn_error` → 任务已创建（READY），可手动调用 `yor.spawn({ task_id, working_dir, brief_path })` 重试
 
 ## 审核闭环
 
 Yor 完成任务后调用 `task.deliver`，CC 实例保持存活等待审核：
 
-- **通过** → `yor.approve()` + `delivery.submit()` + `task.update({ status: "DONE" })` + `channel.send()` + 清理工作区
+- **通过** → `yor.approve()` + `delivery.submit()` + `task.update({ status: "DONE" })` + `channel.send()`
 - **返工** → `yor.rework({ task_id, feedback })` — Yor 在原工作区继续，修改完后再次 deliver
 - **升级** → `task.update({ status: "BLOCKED" })` + `yor.kill()` + `channel.send()` 告知人类
 
-清理规则：
-- 通过：`yor.approve` 自动关闭 Yor；`rm -rf` 清理工作区，分支保留等 PR 合并
-- 返工：不清理工作区
-- 升级：`yor.kill` 关闭 Yor；不清理工作区
+⚠️ **任何审核结果都不清理工作区。** `yor.approve` 自动关闭 Yor CC 实例即可，工作区目录保留。
 
 ## 场景打法
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "team-anya",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "Team Anya - AI 数字员工系统",
   "bin": {

package/packages/mcp-tools/dist/registry.js

@@ -460,8 +460,10 @@ Brief 只写做什么和标准，不写怎么做。
 同时从当前对话上下文中提取 created_by（sender_name 或 sender_id）和 source_chat_id（chat_id），确保任务可追溯。
 
 返回值包含 task_id、brief_path 和 working_dir（已准备好的隔离工作区绝对路径）。
-派工两步走：task.dispatch(MCP) → yor.spawn(MCP，传入返回的 working_dir 和 brief_path)。
-如果返回 status="blocked"，说明工作区准备失败，error 字段包含原因，此时不要调用 yor.spawn，应通知人类。`,
+
+派工成功（status="dispatched"）后会自动启动 Yor，无需再调用 yor.spawn。返回值中 instance_id 为 Yor 实例 ID。
+如果返回 status="blocked"，说明工作区准备失败，error 字段包含原因，应通知人类。
+如果返回 spawn_error，说明 Yor 启动失败但任务已创建（READY），可手动调用 yor.spawn 重试。`,
         inputSchema: TaskDispatchInputSchema,
         layer: 2,
         roles: ['loid'],
@@ -795,13 +797,33 @@ export function createToolRouter(role, deps) {
                 if (!deps.workspaceManager)
                     throw new Error('workspaceManager 未注入');
                 const { taskDispatch } = await import('./layer2/loid/task-dispatch.js');
-                return taskDispatch({
+                const dispatchResult = await taskDispatch({
                     db: deps.db,
                     workspacePath: deps.workspacePath,
                     logger: deps.logger,
                     getProjectConfig: deps.getProjectConfig,
                     workspaceManager: deps.workspaceManager,
                 }, args);
+                // 派工成功 → 自动 spawn Yor（固定流程，不需要 LLM 判断）
+                if (dispatchResult.status === 'dispatched' && dispatchResult.working_dir) {
+                    if (!deps.yorOrchestrator) {
+                        deps.logger?.error('[anya:pipeline] [dispatch] auto-spawn 跳过: yorOrchestrator 未注入');
+                    }
+                    else {
+                        try {
+                            const { yorSpawn } = await import('./layer2/loid/yor-spawn.js');
+                            const spawnResult = await yorSpawn({ yorOrchestrator: deps.yorOrchestrator, logger: deps.logger }, { task_id: dispatchResult.task_id, working_dir: dispatchResult.working_dir, brief_path: dispatchResult.brief_path });
+                            dispatchResult.instance_id = spawnResult.instance_id;
+                            deps.logger?.info(`[anya:pipeline] [dispatch] auto-spawn 完成: ${spawnResult.instance_id}`);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            deps.logger?.error(`[anya:pipeline] [dispatch] auto-spawn 失败: ${msg}`);
+                            dispatchResult.spawn_error = msg;
+                        }
+                    }
+                }
+                return dispatchResult;
             }
             case 'task.lookup': {
                 const { taskLookup } = await import('./layer2/loid/task-lookup.js');