openmatrix 0.1.65 → 0.1.67

package/dist/agents/agent-runner.d.ts

@@ -68,9 +68,7 @@ export declare class AgentRunner {
      */
     buildExecutionPrompt(task: Task): Promise<string>;
     /**
-     * 构建累积上下文 - 从已完成任务中提取共享信息
-     *
-     * 读取所有已完成任务的 context.md，为当前 Agent 提供前序 Agent 的决策和知识
+     * 构建累积上下文 - 从全局 context.md 读取前序 Agent 的决策和知识
      */
     private buildAccumulatedContext;
     /**

package/dist/agents/agent-runner.js

@@ -168,43 +168,22 @@ ${agentPrompt.instructions}
 
 1. 完成任务后，更新任务状态文件: \`.openmatrix/tasks/${task.id}/task.json\`
 2. 将执行结果写入: \`.openmatrix/tasks/${task.id}/artifacts/result.md\`
-3. 将上下文摘要写入: \`.openmatrix/tasks/${task.id}/context.md\` (供后续 Agent 读取)
-4. 如需审批，创建审批请求: \`.openmatrix/approvals/\` 目录
+3. 如需审批，创建审批请求: \`.openmatrix/approvals/\` 目录
+
+注意: 任务完成后，由 Skill 调用 \`openmatrix complete\` 并传入 --summary 参数，
+该摘要会自动追加到全局 \`.openmatrix/context.md\` 供后续 Agent 参考。
 `;
     }
     /**
-     * 构建累积上下文 - 从已完成任务中提取共享信息
-     *
-     * 读取所有已完成任务的 context.md，为当前 Agent 提供前序 Agent 的决策和知识
+     * 构建累积上下文 - 从全局 context.md 读取前序 Agent 的决策和知识
      */
     async buildAccumulatedContext(currentTask) {
         const omPath = path.join(process.cwd(), '.openmatrix');
-        const tasksDir = path.join(omPath, 'tasks');
+        const contextFile = path.join(omPath, 'context.md');
         try {
-            // 异步检查目录是否存在
-            try {
-                await fs.access(tasksDir);
-            }
-            catch {
-                return '';
-            }
-            const contextParts = [];
-            // 异步读取目录
-            const taskDirs = (await fs.readdir(tasksDir)).filter(name => name.startsWith('TASK-'));
-            for (const taskId of taskDirs) {
-                const contextFile = path.join(tasksDir, taskId, 'context.md');
-                try {
-                    const content = await fs.readFile(contextFile, 'utf-8');
-                    const trimmed = content.trim();
-                    if (trimmed) {
-                        contextParts.push(`### ${taskId}\n${trimmed}`);
-                    }
-                }
-                catch {
-                    // 文件不存在或读取失败，跳过
-                }
-            }
-            if (contextParts.length === 0)
+            const content = await fs.readFile(contextFile, 'utf-8');
+            const trimmed = content.trim();
+            if (!trimmed)
                 return '';
             return `
 ## 前序 Agent 共享上下文 (Agent Memory)
@@ -212,7 +191,7 @@ ${agentPrompt.instructions}
 以下是之前执行的 Agent 留下的上下文信息，包含它们的决策、发现和注意事项。
 你应该基于这些信息来工作，避免重复犯错或与已有决策冲突。
 
-${contextParts.join('\n\n')}
+${trimmed}
 `;
         }
         catch {

package/dist/cli/commands/complete.js

@@ -46,6 +46,7 @@ exports.completeCommand = new commander_1.Command('complete')
     .option('--success', '标记为成功完成 (默认)', true)
     .option('--failed', '标记为失败')
     .option('--output <text>', '执行结果摘要')
+    .option('--summary <text>', 'Agent 执行摘要 (写入 context.md)')
     .option('--error <text>', '错误信息 (失败时)')
     .action(async (taskId, options) => {
     const basePath = process.cwd();
@@ -101,27 +102,27 @@ exports.completeCommand = new commander_1.Command('complete')
         currentPhase: allDone ? 'completed' : 'execution',
         ...(allDone ? { completedAt: now } : {})
     });
-    // 5. 写入 context.md (Agent Memory)
+    // 5. 追加写入全局 context.md (Agent Memory)
     if (isSuccess) {
-        const taskDir = path.join(omPath, 'tasks', taskId);
-        const contextFile = path.join(taskDir, 'context.md');
-        try {
-            await fs.mkdir(taskDir, { recursive: true });
-            const contextContent = `## 任务：${task.id} ${task.title}
-
-### 关键决策
-- [待补充]
-
-### 创建/修改的文件
-- [待补充]
-
-### 重要发现
-- [待补充]
+        const contextFile = path.join(omPath, 'context.md');
+        const timestamp = new Date().toISOString();
+        // 构建上下文内容
+        const summary = options.summary || '任务已完成';
+        const contextEntry = `## ${taskId} ${task.title}
+- 时间: ${timestamp}
+- 摘要: ${summary}
 
-### 对后续任务的建议
-- [待补充]
 `;
-            await fs.writeFile(contextFile, contextContent, 'utf-8');
+        try {
+            // 追加写入全局 context.md
+            let existingContent = '';
+            try {
+                existingContent = await fs.readFile(contextFile, 'utf-8');
+            }
+            catch {
+                // 文件不存在，创建新文件
+            }
+            await fs.writeFile(contextFile, existingContent + contextEntry, 'utf-8');
         }
         catch {
             // 忽略写入错误

package/dist/cli/commands/start.js

@@ -40,7 +40,6 @@ const state_manager_js_1 = require("../../storage/state-manager.js");
 const task_parser_js_1 = require("../../orchestrator/task-parser.js");
 const task_planner_js_1 = require("../../orchestrator/task-planner.js");
 const approval_manager_js_1 = require("../../orchestrator/approval-manager.js");
-const executor_js_1 = require("../../orchestrator/executor.js");
 const gitignore_js_1 = require("../../utils/gitignore.js");
 const index_js_1 = require("../../types/index.js");
 const fs = __importStar(require("fs/promises"));
@@ -253,33 +252,26 @@ async function handleTasksJson(options, stateManager, state, omPath, basePath) {
         }
         return;
     }
-    // 无审批点，直接开始执行
-    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
-        maxConcurrent: state.config.maxConcurrentAgents,
-        taskTimeout: state.config.timeout * 1000
-    });
-    const phaseExecutor = executor.getPhaseExecutor();
-    if (phaseExecutor) {
-        phaseExecutor.setRunId(state.runId);
-        if (executionMode === 'auto') {
-            phaseExecutor.setAutoMode(true);
-        }
-    }
-    const result = await executor.step();
+    // 无审批点，返回任务列表供 Skill 执行
+    const allTasks = await stateManager.listTasks();
+    const subagentTasks = allTasks.map(t => ({
+        taskId: t.id,
+        agentType: t.assignedAgent,
+        title: t.title,
+        description: t.description,
+        priority: t.priority,
+        dependencies: t.dependencies,
+        timeout: t.timeout
+    }));
     if (options.json) {
         console.log(JSON.stringify({
-            status: result.status,
-            message: result.message,
-            statistics: result.statistics,
-            subagentTasks: result.subagentTasks.map(t => ({
-                subagent_type: t.subagent_type,
-                description: t.description,
-                prompt: t.prompt,
-                isolation: t.isolation,
-                taskId: t.taskId,
-                agentType: t.agentType,
-                timeout: t.timeout
-            })),
+            status: 'tasks_ready',
+            message: '任务已准备就绪，等待 Skill 执行',
+            statistics: {
+                totalTasks: allTasks.length,
+                pending: allTasks.filter(t => t.status === 'pending').length
+            },
+            subagentTasks,
             taskInfo: {
                 title: tasksInput.title,
                 description: tasksInput.description,
@@ -289,9 +281,9 @@ async function handleTasksJson(options, stateManager, state, omPath, basePath) {
     }
     else {
         console.log(`\n📋 ${tasksInput.title} - ${subTasks.length} 个子任务已创建`);
-        console.log(`🎯 执行模式: ${executionMode}`);
-        console.log(`   质量级别: ${qualityLevel}`);
-        console.log('\n🚀 开始执行...');
+        console.log(`🎯 执行模式：${executionMode}`);
+        console.log(`   质量级别：${qualityLevel}`);
+        console.log('\n🚀 等待 Skill 执行任务...');
         console.log('   使用 /om:status 查看进度');
     }
 }
@@ -426,32 +418,26 @@ async function handleAutoParse(input, options, stateManager, state) {
         }
         return;
     }
-    const executor = new executor_js_1.OrchestratorExecutor(stateManager, approvalManager, {
-        maxConcurrent: state.config.maxConcurrentAgents,
-        taskTimeout: state.config.timeout * 1000
-    });
-    const phaseExecutor = executor.getPhaseExecutor();
-    if (phaseExecutor) {
-        phaseExecutor.setRunId(state.runId);
-        if (executionMode === 'auto') {
-            phaseExecutor.setAutoMode(true);
-        }
-    }
-    const result = await executor.step();
+    // 无审批点，返回任务列表供 Skill 执行
+    const allTasks = await stateManager.listTasks();
+    const subagentTasks = allTasks.map(t => ({
+        taskId: t.id,
+        agentType: t.assignedAgent,
+        title: t.title,
+        description: t.description,
+        priority: t.priority,
+        dependencies: t.dependencies,
+        timeout: t.timeout
+    }));
     if (options.json) {
         console.log(JSON.stringify({
-            status: result.status,
-            message: result.message,
-            statistics: result.statistics,
-            subagentTasks: result.subagentTasks.map(t => ({
-                subagent_type: t.subagent_type,
-                description: t.description,
-                prompt: t.prompt,
-                isolation: t.isolation,
-                taskId: t.taskId,
-                agentType: t.agentType,
-                timeout: t.timeout
-            })),
+            status: 'tasks_ready',
+            message: '任务已准备就绪，等待 Skill 执行',
+            statistics: {
+                totalTasks: allTasks.length,
+                pending: allTasks.filter(t => t.status === 'pending').length
+            },
+            subagentTasks,
             taskInfo: {
                 title: options.title || parsedTask.title,
                 description: options.description,
@@ -463,8 +449,8 @@ async function handleAutoParse(input, options, stateManager, state) {
     }
     else {
         console.log(`\n📋 生成 ${subTasks.length} 个子任务`);
-        console.log(`🎯 执行模式: ${executionMode}`);
-        console.log('\n🚀 开始执行...');
+        console.log(`🎯 执行模式：${executionMode}`);
+        console.log('\n🚀 等待 Skill 执行任务...');
         console.log('   使用 /om:status 查看进度');
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmatrix",
-  "version": "0.1.65",
+  "version": "0.1.67",
   "description": "AI Agent task orchestration system with Claude Code Skills integration",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/start.md

@@ -13,9 +13,9 @@ description: 启动新的任务执行周期
 ```
 Step 1:  初始化 .openmatrix 目录
 Step 2:  解析任务输入（文件或描述）
-Step 3:  智能分析，动态决定是否需要交互问答
-Step 4:  如需问答 → AskUserQuestion（可跳过简单任务）
-Step 5:  展示执行计划 + 确认执行模式
+Step 3:  智能分析任务类型
+Step 4:  必选问题（质量等级、E2E、执行模式）← 不可跳过
+Step 5:  可选问题（仅复杂任务）+ 展示执行计划
 Step 6:  AI 提取 goals，生成 plan
 Step 7:  写入 .openmatrix/tasks-input.json          ← 必须完成
 Step 8:  调用 openmatrix start --tasks-json          ← 必须完成，不可跳过
@@ -26,13 +26,19 @@ Step 10: 逐个执行 subagentTasks（调用 Agent 工具）    ← 只有这步
 **违反以下任一规则将导致任务执行失败：**
 
 ❌ **禁止在 Step 8 之前写任何业务代码** — 所有代码必须在 Step 10 通过 Agent 执行
+❌ **禁止跳过 Step 4 必选问题** — 质量等级、执行模式必须由用户选择
 ❌ **禁止跳过 Step 8** — 必须调用 CLI，不能用其他方式代替
 ❌ **禁止自行规划 Phase** — 任务由 CLI 的 TaskPlanner 拆分，AI 只提取 goals
 ❌ **禁止用 Bash/npm/write 直接写业务代码** — 业务代码只能通过 Step 10 的 Agent 执行
 </MANDATORY-EXECUTION-ORDER>
 
 <objective>
-解析任务文档，智能推断配置，仅对不确定的问题交互问答，确认后通过 CLI 拆分任务并执行。
+解析任务文档，通过必选问答确定质量等级、E2E测试、执行模式，确认后通过 CLI 拆分任务并执行。
+
+⚠️ **Step 4 必选问题不可跳过** — 必须让用户选择：
+1. 质量等级 (strict/balanced/fast)
+2. E2E 测试 (当选择 strict/balanced 时必问)
+3. 执行模式 (全自动/关键节点确认/每阶段确认)
 </objective>
 
 <process>
@@ -71,38 +77,72 @@ openmatrix start --init-only
 
 ### Step 3: 智能分析
 
-根据任务内容判断是否需要交互问答:
+根据任务内容判断是否需要额外问题（质量等级、执行模式、E2E 始终必选）:
 
-| 任务类型 | 跳过问题 | 默认配置 |
+| 任务类型 | 额外问题 | 默认配置 |
 |---------|---------|---------|
-| Bug 修复 / 小改动 | 跳过所有 | fast + 最小文档 |
-| 新功能开发 | 正常询问 | balanced |
-| 重构 | 跳过 E2E | balanced |
-| 测试编写 | 跳过文档 | 无需文档 |
+| Bug 修复 / 小改动 | 跳过复杂度问题 | fast |
+| 新功能开发 | 询问技术栈等 | balanced |
+| 重构 | 跳过 E2E 相关 | balanced |
+| 测试编写 | 跳过文档相关 | 无需文档 |
+
+### Step 4: 必选问题（所有任务都必须回答）
+
+**⚠️ 以下问题为必选，不可跳过：**
+
+#### 4.1 质量等级（必选）
+
+```typescript
+AskUserQuestion({
+  questions: [
+    {
+      question: "选择质量等级（决定测试覆盖、Lint、安全扫描等要求）:",
+      header: "质量等级",
+      options: [
+        { label: "strict", description: "TDD + >80%覆盖率 + 严格Lint + 安全扫描 — 生产级代码" },
+        { label: "balanced (推荐)", description: ">60%覆盖率 + Lint + 安全扫描 — 日常开发" },
+        { label: "fast", description: "无质量门禁 — 快速原型/验证" }
+      ],
+      multiSelect: false
+    }
+  ]
+})
+```
 
-### Step 4: 交互问答（仅对复杂任务）
+#### 4.2 E2E 测试（当质量等级为 strict 或 balanced 时必选）
 
-如果需要确认配置，使用 AskUserQuestion 一次询问多个问题:
+如果用户选择了 `strict` 或 `balanced`，继续询问:
 
 ```typescript
 AskUserQuestion({
   questions: [
     {
-      question: "选择质量级别:",
-      header: "质量",
+      question: "是否启用端到端 (E2E) 测试？（适用于 Web/Mobile/GUI 项目，耗时较长）",
+      header: "E2E 测试",
       options: [
-        { label: "strict", description: "TDD + >80%覆盖率 + Lint + 安全扫描" },
-        { label: "balanced", description: ">60%覆盖率 + Lint + 安全扫描" },
-        { label: "fast", description: "无质量门禁" }
+        { label: "启用 E2E 测试", description: "使用 Playwright/Cypress 等框架进行端到端测试" },
+        { label: "不启用 (推荐)", description: "仅进行单元测试和集成测试，节省时间" }
       ],
       multiSelect: false
-    },
+    }
+  ]
+})
+```
+
+**注意:** 如果用户选择 `fast` 质量等级，跳过 E2E 问题（fast 模式不启用 E2E）。
+
+#### 4.3 执行模式（必选）
+
+```typescript
+AskUserQuestion({
+  questions: [
     {
-      question: "是否启用 E2E 测试? (Web/Mobile/GUI 项目推荐)",
-      header: "E2E",
+      question: "选择执行模式（控制 AI 执行过程中的审批节点）:",
+      header: "执行模式",
       options: [
-        { label: "跳过 (推荐)", description: "E2E 测试耗时较长，大多数项目不需要" },
-        { label: "启用", description: "适合 Web 应用 (Playwright/Cypress)、Mobile (Appium/Detox)" }
+        { label: "全自动执行 (推荐)", description: "全自动执行，无需人工审批，遇到阻塞自动 Meeting" },
+        { label: "关键节点确认", description: "plan/merge/deploy 时暂停确认" },
+        { label: "每阶段确认", description: "每个阶段（develop/verify/accept）完成后暂停" }
       ],
       multiSelect: false
     }
@@ -110,7 +150,14 @@ AskUserQuestion({
 })
 ```
 
-### Step 5: 展示计划 + 确认模式
+### Step 5: 可选问题（仅复杂任务）
+
+根据任务类型，可能需要额外询问:
+
+- 技术栈偏好
+- 文档级别
+- 风险评估
+- 验收标准
 
 展示 AI 生成的执行计划:
 
@@ -121,27 +168,9 @@ AskUserQuestion({
 📊 统计
   Goals: N 个（将生成 N个开发 + N个测试 + 审查）
   质量级别: xxx
+  E2E 测试: 启用/不启用
 ```
 
-使用 AskUserQuestion 确认执行模式:
-
-```typescript
-AskUserQuestion({
-  questions: [{
-    question: "请选择执行模式:",
-    header: "执行模式",
-    options: [
-      { label: "全自动执行 (推荐)", description: "无需确认，自动完成，阻塞任务 (Meeting) 留到最后统一处理" },
-      { label: "关键节点确认", description: "plan/merge 时暂停确认" },
-      { label: "每阶段确认", description: "每个阶段完成后暂停" }
-    ],
-    multiSelect: false
-  ]
-})
-```
-
-**默认进入 BYPASS 模式（全自动执行），用户可选其他模式。**
-
 ### Step 6: AI 提取 goals + 生成 plan
 
 从任务描述中提取:
@@ -203,7 +232,8 @@ CLI 返回 JSON 中 `subagentTasks` 数组包含待执行任务。
 **文件持久化循环（防止上下文压缩丢失状态）:**
 ```bash
 # 每个 Agent 完成后执行:
-openmatrix complete TASK-XXX --success       # 标记完成 + 更新统计（含自动 git commit）
+# --summary 传入执行摘要，自动追加到全局 context.md
+openmatrix complete TASK-XXX --success --summary "决策: xxx; 文件: xxx"
 
 # 提交验证（防止 commit 静默失败）:
 git status --porcelain                        # 检查是否有未提交的文件
@@ -229,26 +259,15 @@ Agent({
 每个 Agent 完成后:
 1. **标记完成并更新统计（必须执行）:**
 ```bash
-openmatrix complete TASK-XXX --success
+# --summary 参数传入 Agent 执行摘要，自动追加到全局 context.md
+openmatrix complete TASK-XXX --success --summary "关键决策: xxx; 创建文件: xxx"
 ```
-2. **保存 Agent 上下文** — 将执行结果摘要写入 `.openmatrix/tasks/TASK-XXX/context.md`，格式如下:
 
-```markdown
-## 任务: TASK-XXX 任务标题
+2. **全局上下文文件** — 所有任务的上下文累积在 `.openmatrix/context.md`:
+   - 每次任务完成后，通过 `--summary` 参数追加写入
+   - 后续 Agent 可读取此文件了解前序任务的决策和发现
 
-### 关键决策
-- [做出的重要决策]
-
-### 创建/修改的文件
-- `path/to/file1.ts` - 简述用途
-- `path/to/file2.ts` - 简述用途
-
-### 重要发现
-- [发现的问题、模式、注意事项]
-
-### 对后续任务的建议
-- [下一个 Agent 应该注意什么]
-```
+3. Git 自动提交（必须使用下方统一提交格式）
 
 3. Git 自动提交（必须使用下方统一提交格式）
 4. **获取下一个任务（防止上下文压缩丢失）:**
@@ -260,6 +279,50 @@ openmatrix step --json
 如果返回 `status: "blocked"` → 有阻塞任务，处理 Meeting
 5. 检查审批点（auto 模式自动批准，其他模式按配置暂停）
 
+6. **审批点处理（根据执行模式）:**
+
+根据用户选择的执行模式处理审批:
+
+| 执行模式 | 审批点 | 处理方式 |
+|---------|--------|---------|
+| 全自动执行 | 无 | 自动批准所有操作 |
+| 关键节点确认 | plan, merge, deploy | 到达审批点时暂停，交互式确认 |
+| 每阶段确认 | develop, verify, accept | 每个阶段完成后暂停，交互式确认 |
+
+**交互式审批流程（非全自动模式）:**
+
+当到达审批点时，使用 `openmatrix approve --list` 查看待审批项，然后通过 AskUserQuestion 请求用户确认:
+
+```typescript
+// 检查是否有待审批项
+// 通过 CLI: openmatrix approve --list --json
+
+AskUserQuestion({
+  questions: [
+    {
+      question: "审批请求: [审批类型]
+
+[审批内容摘要]
+
+是否批准?",
+      header: "审批",
+      options: [
+        { label: "批准", description: "同意继续执行" },
+        { label: "拒绝", description: "拒绝并停止执行" },
+        { label: "查看详情", description: "查看完整审批内容后再决定" }
+      ],
+      multiSelect: false
+    }
+  ]
+})
+```
+
+用户选择后，执行对应命令:
+- 批准: `openmatrix approve <approval-id> --approve`
+- 拒绝: `openmatrix approve <approval-id> --reject`
+- 查看详情: 读取 `.openmatrix/approvals/<approval-id>.json` 并展示完整内容
+
+
 **Agent 上下文共享机制 (Agent Memory):**
 
 每个 Agent 执行时会自动接收前序 Agent 的上下文信息（通过 `context.md` 文件）。