openmatrix 0.1.37 → 0.1.39

package/dist/cli/commands/brainstorm.js

@@ -220,35 +220,170 @@ exports.brainstormCommand = new commander_1.Command('brainstorm')
 function generateBrainstormQuestions(taskContent, taskTitle) {
     const questions = [];
     const content = taskContent.toLowerCase();
-    // 问题 1: 核心目标
-    questions.push({
-        id: 'core_objective',
-        question: '这个任务的核心目标是什么？想要解决什么问题？',
-        header: '核心目标',
-        options: [
-            { label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
-            { label: '修复问题', description: '修复 Bug 或解决已知问题' },
-            { label: '重构优化', description: '改进代码结构、性能或可维护性' },
-            { label: '技术探索', description: '探索新技术方案，验证可行性' }
-        ],
-        multiSelect: false,
-        why: '明确核心目标有助于选择正确的实现策略和质量标准'
-    });
-    // 问题 2: 用户价值
-    questions.push({
-        id: 'user_value',
-        question: '这个任务为用户带来什么价值？最终用户是谁？',
-        header: '用户价值',
-        options: [
-            { label: '开发者', description: '主要用户是开发者，需要清晰的 API 和文档' },
-            { label: '终端用户', description: '主要用户是终端用户，需要良好的用户体验' },
-            { label: '运维人员', description: '主要用户是运维，需要稳定性和可观测性' },
-            { label: '内部团队', description: '主要用户是内部团队，需要高效协作支持' }
-        ],
-        multiSelect: false,
-        why: '了解目标用户有助于设计合适的接口和交互方式'
-    });
-    // 问题 3: 实现复杂度 - 如果任务内容包含复杂关键词
+    const title = taskTitle.toLowerCase();
+    // 检测任务类型
+    const isGame = /游戏|game|玩家|player|塔防|td|rpg|射击|shooter|角色|character|关卡|level|boss|技能|skill|武器|weapon|敌人|enemy/.test(content + title);
+    const isAPI = /api|接口|后端|backend|rest|graphql|微服务|microservice/.test(content + title);
+    const isCLI = /cli|命令行|command|工具|tool|脚本|script/.test(content + title);
+    const isLibrary = /库|library|sdk|包|package|npm|组件|component/.test(content + title);
+    // 根据任务类型生成不同的问题
+    if (isGame) {
+        // ========== 游戏专用问题 ==========
+        questions.push({
+            id: 'game_type',
+            question: '这是什么类型的游戏？核心玩法是什么？',
+            header: '游戏类型',
+            options: [
+                { label: '塔防 (TD)', description: '放置防御塔，阻止敌人到达终点' },
+                { label: 'RPG', description: '角色扮演，升级成长' },
+                { label: '射击/动作', description: '实时战斗，操作为主' },
+                { label: '策略/模拟', description: '资源管理，策略决策' }
+            ],
+            multiSelect: false,
+            why: '游戏类型决定核心机制和技术架构'
+        });
+        questions.push({
+            id: 'target_player',
+            question: '目标玩家是谁？',
+            header: '目标玩家',
+            options: [
+                { label: '休闲玩家', description: '简单易上手，碎片时间游玩' },
+                { label: '硬核玩家', description: '深度策略，挑战性高' },
+                { label: '全年龄', description: '老少皆宜，难度适中' },
+                { label: '核心玩家', description: '游戏爱好者，追求高品质' }
+            ],
+            multiSelect: false,
+            why: '目标玩家决定游戏难度和设计风格'
+        });
+        questions.push({
+            id: 'game_platform',
+            question: '游戏运行在什么平台？',
+            header: '平台',
+            options: [
+                { label: 'Web 浏览器', description: 'HTML5/Canvas/WebGL' },
+                { label: '移动端', description: 'iOS/Android 原生或混合' },
+                { label: 'PC 桌面', description: 'Electron/原生应用' },
+                { label: '跨平台', description: '同时支持多个平台' }
+            ],
+            multiSelect: true,
+            why: '平台决定技术选型和性能优化方向'
+        });
+        questions.push({
+            id: 'game_features',
+            question: '游戏包含哪些核心功能？',
+            header: '核心功能',
+            options: [
+                { label: '多人对战', description: '实时/PVP/联机' },
+                { label: '单机闯关', description: '关卡/剧情模式' },
+                { label: '存档系统', description: '保存/加载进度' },
+                { label: '成就/排行榜', description: '激励机制' }
+            ],
+            multiSelect: true,
+            why: '核心功能决定开发优先级和工作量'
+        });
+        questions.push({
+            id: 'art_style',
+            question: '美术风格是什么？素材如何获取？',
+            header: '美术',
+            options: [
+                { label: '程序化生成', description: '用代码绘制图形' },
+                { label: '像素风', description: '复古像素艺术' },
+                { label: '使用免费素材', description: 'OpenGameArt 等资源' },
+                { label: '需要美术设计', description: '需要定制美术资源' }
+            ],
+            multiSelect: false,
+            why: '美术方案影响开发成本和视觉效果'
+        });
+    }
+    else if (isAPI) {
+        // ========== API 专用问题 ==========
+        questions.push({
+            id: 'api_consumer',
+            question: 'API 的调用方是谁？',
+            header: '调用方',
+            options: [
+                { label: '前端应用', description: 'Web/Mobile 前端调用' },
+                { label: '第三方开发者', description: '公开 API 供外部使用' },
+                { label: '内部服务', description: '微服务间调用' },
+                { label: '混合场景', description: '多种调用方' }
+            ],
+            multiSelect: false,
+            why: '调用方决定 API 设计和文档要求'
+        });
+        questions.push({
+            id: 'api_auth',
+            question: '需要什么样的认证授权？',
+            header: '认证',
+            options: [
+                { label: '无认证', description: '公开 API，无需认证' },
+                { label: 'API Key', description: '简单的密钥认证' },
+                { label: 'JWT/OAuth', description: '用户身份认证' },
+                { label: '需要调研', description: '认证方案待定' }
+            ],
+            multiSelect: false,
+            why: '认证方式影响安全架构'
+        });
+    }
+    else if (isCLI) {
+        // ========== CLI 专用问题 ==========
+        questions.push({
+            id: 'cli_user',
+            question: 'CLI 工具的主要使用者是谁？',
+            header: '使用者',
+            options: [
+                { label: '开发者', description: '开发流程辅助工具' },
+                { label: '运维人员', description: '部署/运维自动化' },
+                { label: '普通用户', description: '非技术用户也能使用' },
+                { label: 'CI/CD', description: '自动化流程中使用' }
+            ],
+            multiSelect: true,
+            why: '使用者决定交互设计和文档要求'
+        });
+        questions.push({
+            id: 'cli_output',
+            question: 'CLI 的输出格式要求？',
+            header: '输出',
+            options: [
+                { label: '人类可读', description: '彩色、表格、友好提示' },
+                { label: 'JSON 机器读', description: '结构化输出，便于解析' },
+                { label: '两种都支持', description: '通过参数切换' },
+                { label: '静默模式', description: '最少输出，仅错误' }
+            ],
+            multiSelect: false,
+            why: '输出格式影响用户体验和自动化集成'
+        });
+    }
+    else {
+        // ========== 通用问题 ==========
+        questions.push({
+            id: 'core_objective',
+            question: '这个任务的核心目标是什么？想要解决什么问题？',
+            header: '核心目标',
+            options: [
+                { label: '实现新功能', description: '添加新的功能特性，扩展系统能力' },
+                { label: '修复问题', description: '修复 Bug 或解决已知问题' },
+                { label: '重构优化', description: '改进代码结构、性能或可维护性' },
+                { label: '技术探索', description: '探索新技术方案，验证可行性' }
+            ],
+            multiSelect: false,
+            why: '明确核心目标有助于选择正确的实现策略和质量标准'
+        });
+        questions.push({
+            id: 'user_value',
+            question: '这个任务为用户带来什么价值？最终用户是谁？',
+            header: '用户价值',
+            options: [
+                { label: '开发者', description: '主要用户是开发者，需要清晰的 API 和文档' },
+                { label: '终端用户', description: '主要用户是终端用户，需要良好的用户体验' },
+                { label: '运维人员', description: '主要用户是运维，需要稳定性和可观测性' },
+                { label: '内部团队', description: '主要用户是内部团队，需要高效协作支持' }
+            ],
+            multiSelect: false,
+            why: '了解目标用户有助于设计合适的接口和交互方式'
+        });
+    }
+    // ========== 通用问题（所有类型都有） ==========
+    // 实现复杂度 - 如果任务内容包含复杂关键词
     if (content.includes('架构') || content.includes('系统') || content.includes('集成') || content.includes('多个')) {
         questions.push({
             id: 'complexity',
@@ -264,8 +399,8 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
             why: '复杂度评估有助于决定是否需要分阶段实施和额外的设计审查'
         });
     }
-    // 问题 4: 技术约束 - 如果涉及技术选型
-    if (content.includes('技术') || content.includes('框架') || content.includes('库')) {
+    // 技术约束 - 如果涉及技术选型
+    if (content.includes('技术') || content.includes('框架') || content.includes('库') || content.includes('技术栈')) {
         questions.push({
             id: 'tech_constraints',
             question: '有哪些技术约束或偏好？需要使用/避免什么技术？',
@@ -280,7 +415,7 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
             why: '技术约束影响实现方案和后续维护成本'
         });
     }
-    // 问题 5: 风险评估
+    // 风险评估
     questions.push({
         id: 'risks',
         question: '这个任务可能面临哪些风险或挑战？',
@@ -294,7 +429,7 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '识别风险有助于提前规划应对策略'
     });
-    // 问题 6: 验收标准
+    // 验收标准
     questions.push({
         id: 'acceptance',
         question: '如何判断任务完成？有哪些验收标准？',
@@ -308,7 +443,7 @@ function generateBrainstormQuestions(taskContent, taskTitle) {
         multiSelect: true,
         why: '明确的验收标准有助于判断任务完成度'
     });
-    // 问题 7: 实现优先级
+    // 实现优先级
     questions.push({
         id: 'priority',
         question: '这个任务的优先级如何？是否需要 MVP 版本？',

package/dist/cli/commands/start.js

@@ -58,6 +58,7 @@ exports.startCommand = new commander_1.Command('start')
     .option('-q, --quality <level>', '质量级别 (strict|balanced|fast)')
     .option('-t, --tech-stack <stack>', '技术栈 (逗号分隔，如 "TypeScript,Vue.js,PostgreSQL")')
     .option('--docs <level>', '文档级别 (full|basic|minimal|none)')
+    .option('--brainstorm-answers <json>', '从 brainstorm 传递的答案 JSON')
     .action(async (input, options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
@@ -101,6 +102,53 @@ exports.startCommand = new commander_1.Command('start')
         }
         return;
     }
+    // 检查 brainstorm 状态 (状态校验)
+    const brainstormPath = path.join(omPath, 'brainstorm', 'session.json');
+    try {
+        const brainstormContent = await fs.readFile(brainstormPath, 'utf-8');
+        const brainstormSession = JSON.parse(brainstormContent);
+        if (brainstormSession.status === 'brainstorming') {
+            // 检查是否有未回答的问题
+            const answeredCount = Object.keys(brainstormSession.answers || {}).length;
+            const totalQuestions = brainstormSession.questions?.length || 0;
+            if (answeredCount < totalQuestions && !options.brainstormAnswers) {
+                // brainstorm 未完成，且没有传递答案
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        status: 'error',
+                        code: 'BRAINSTORM_INCOMPLETE',
+                        message: '头脑风暴未完成',
+                        details: {
+                            taskTitle: brainstormSession.taskTitle,
+                            answeredCount,
+                            totalQuestions,
+                            missingQuestions: brainstormSession.questions
+                                ?.filter((q) => !brainstormSession.answers?.[q.id])
+                                ?.map((q) => ({ question: q.question, header: q.header })) || []
+                        },
+                        hint: '请先完成头脑风暴: /om:brainstorm，或传递 --brainstorm-answers 参数'
+                    }));
+                }
+                else {
+                    console.log('⚠️  头脑风暴未完成!');
+                    console.log(`   任务: ${brainstormSession.taskTitle}`);
+                    console.log(`   进度: ${answeredCount}/${totalQuestions} 问题已回答`);
+                    console.log('\n   未回答的问题:');
+                    brainstormSession.questions
+                        ?.filter((q) => !brainstormSession.answers?.[q.id])
+                        ?.forEach((q, i) => {
+                        console.log(`   ${i + 1}. [${q.header}] ${q.question}`);
+                    });
+                    console.log('\n   💡 请先完成头脑风暴: /om:brainstorm');
+                    console.log('   或传递 --brainstorm-answers 参数跳过此检查');
+                }
+                return;
+            }
+        }
+    }
+    catch {
+        // brainstorm 文件不存在，继续执行
+    }
     // 构建任务内容
     let taskContent = input;
     // 如果提供了 --title 和 --description，构建任务内容
@@ -163,6 +211,24 @@ exports.startCommand = new commander_1.Command('start')
     }
     const parser = new task_parser_js_1.TaskParser();
     const parsedTask = parser.parse(taskContent);
+    // 解析 brainstorm 答案 (如果有)
+    let brainstormContext = {};
+    if (options.brainstormAnswers) {
+        try {
+            brainstormContext = JSON.parse(options.brainstormAnswers);
+            if (!options.json) {
+                console.log('\n🧠 使用 brainstorm 收集的信息:');
+                if (brainstormContext.answers) {
+                    Object.entries(brainstormContext.answers).forEach(([key, value]) => {
+                        console.log(`   - ${key}: ${Array.isArray(value) ? value.join(', ') : value}`);
+                    });
+                }
+            }
+        }
+        catch {
+            // 忽略解析错误
+        }
+    }
     if (!options.json) {
         console.log(`\n📋 任务: ${parsedTask.title}`);
         console.log(`   目标: ${parsedTask.goals.join(', ')}`);
@@ -172,7 +238,27 @@ exports.startCommand = new commander_1.Command('start')
         console.log('\n🔧 拆解任务...');
     }
     const planner = new task_planner_js_1.TaskPlanner();
-    const subTasks = planner.breakdown(parsedTask, {});
+    // 构建 planner 上下文，包含 brainstorm 信息
+    // 注意: TaskPlanner.breakdown 需要 Record<string, string> 类型
+    const plannerContext = {};
+    if (brainstormContext.answers) {
+        plannerContext.brainstormAnswers = JSON.stringify(brainstormContext.answers);
+    }
+    if (brainstormContext.insights && brainstormContext.insights.length > 0) {
+        plannerContext.insights = brainstormContext.insights.join('; ');
+    }
+    if (brainstormContext.designNotes && brainstormContext.designNotes.length > 0) {
+        plannerContext.designNotes = brainstormContext.designNotes.join('; ');
+    }
+    // 添加技术栈信息
+    if (options.techStack) {
+        plannerContext.techStack = options.techStack;
+    }
+    // 添加质量级别
+    if (options.quality) {
+        plannerContext.qualityLevel = options.quality;
+    }
+    const subTasks = planner.breakdown(parsedTask, plannerContext);
     // 创建任务到状态管理器
     for (const subTask of subTasks) {
         await stateManager.createTask({

package/package.json

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

package/skills/brainstorm.md

@@ -14,9 +14,37 @@ OpenMatrix 独立运行，使用自己的头脑风暴流程。
 </objective>
 
 <process>
-1. **初始化头脑风暴会话**
+1. **检查现有会话 (断点续传)**
 
-   如果 `$ARGUMENTS` 为空，   先询问用户任务内容:
+   **首先检查** `.openmatrix/brainstorm/session.json` 是否存在且未完成:
+   ```bash
+   # 检查现有会话状态
+   cat .openmatrix/brainstorm/session.json 2>/dev/null
+   ```
+
+   **如果存在未完成的会话**:
+   - 读取 `session.status`、`session.questions`、`session.answers`
+   - 计算未回答的问题: `questions.filter(q => !answers[q.id])`
+   - 询问用户是否继续:
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: `发现未完成的头脑风暴会话: "${session.taskTitle}"，已回答 ${Object.keys(session.answers).length}/${session.questions.length} 个问题。是否继续？`,
+       header: "恢复会话",
+       options: [
+         { label: "✅ 继续回答", description: "从上次中断的地方继续" },
+         { label: "🔄 重新开始", description: "丢弃之前的回答，重新开始" }
+       ],
+       multiSelect: false
+     }]
+   })
+   ```
+   - 如果选择"继续回答"，只问未回答的问题
+   - 如果选择"重新开始"，继续下面的初始化流程
+
+2. **初始化头脑风暴会话**
+
+   如果 `$ARGUMENTS` 为空，先询问用户任务内容:
    ```typescript
    AskUserQuestion({
      questions: [{
@@ -32,6 +60,12 @@ OpenMatrix 独立运行，使用自己的头脑风暴流程。
    openmatrix brainstorm "$ARGUMENTS" --json
    ```
 
+   **CLI 会根据任务关键词自动选择问题类型**:
+   - 游戏 (game/游戏/玩家) → 游戏专用问题
+   - API (api/接口/后端) → API 专用问题
+   - CLI (cli/命令行/工具) → CLI 专用问题
+   - 其他 → 通用问题
+
    这会返回:
    ```json
    {
@@ -51,25 +85,44 @@ OpenMatrix 独立运行，使用自己的头脑风暴流程。
    }
    ```
 
-2. **交互式问答**
+2. **交互式问答 (必须收集答案)**
+
+   **重要**: 必须收集所有答案，用于后续传递给 CLI。
 
    对每个问题使用 `AskUserQuestion` 进行提问:
 
    ```typescript
-   AskUserQuestion({
-     questions: [{
-       question: questions[0].question,
-       header: questions[0].header,
-       options: questions[0].options,
-       multiSelect: questions[0].multiSelect
-     }]
-   })
+   // 收集答案的对象
+   const collectedAnswers: Record<string, string | string[]> = {};
+   const collectedInsights: string[] = [];
+
+   // 对每个问题提问
+   for (const q of questions) {
+     const response = await AskUserQuestion({
+       questions: [{
+         question: q.question,
+         header: q.header,
+         options: q.options,
+         multiSelect: q.multiSelect
+       }]
+     });
+
+     // 记录答案
+     collectedAnswers[q.id] = response.answers[q.question] || response.answers['0'];
+
+     // 记录洞察 (根据答案推导)
+     if (q.id === 'core_objective') {
+       collectedInsights.push(`核心目标: ${collectedAnswers[q.id]}`);
+     }
+     // ... 其他洞察
+   }
    ```
 
    **收集回答并记录洞察**:
    - 每个回答后，思考其含义
    - 记录可能的设计决策
    - 识别潜在风险
+   - **必须保存到 session.answers 对象中**
 
 3. **深入追问** (可选)
 
@@ -134,28 +187,76 @@ OpenMatrix 独立运行，使用自己的头脑风暴流程。
    })
    ```
 
-6. **自动执行 start**
+6. **保存答案并执行 start**
+
+   **关键步骤**: 必须将收集的答案保存到 CLI，然后再启动执行。
 
    如果用户选择"开始执行":
-   - 调用 CLI 标记头脑风暴完成:
-     ```bash
-     openmatrix brainstorm --complete --json
-     ```
-   - **必须使用 Skill 工具调用 om:start**:
-     ```typescript
-     Skill({
-       skill: "om:start",
-       args: JSON.stringify({
-         taskInput: session.taskInput,
-         taskTitle: session.taskTitle,
-         answers: session.answers,
-         insights: session.insights,
-         designNotes: session.designNotes
-       })
-     })
-     ```
-   - 将头脑风暴收集的洞察传递给 start
-   - **不要直接执行任务**，必须通过 `/om:start` 启动
+
+   **步骤 1**: 构建结果 JSON (必须包含所有收集的答案):
+   ```typescript
+   const resultsJson = JSON.stringify({
+     answers: collectedAnswers,      // 用户对每个问题的回答
+     insights: collectedInsights,    // 推导出的洞察
+     designNotes: collectedNotes    // 设计笔记
+   });
+   ```
+
+   **步骤 2**: 调用 CLI 保存结果并标记完成:
+   ```bash
+   # 必须传递 --results 参数，否则答案不会被保存!
+   openmatrix brainstorm --complete --results '$RESULTS_JSON' --json
+   ```
+
+   实际执行示例:
+   ```bash
+   # 使用单引号包裹 JSON，避免 shell 解析问题
+   openmatrix brainstorm --complete --results '{"answers":{"core_objective":"实现新功能","user_value":"终端用户"},"insights":["核心目标是实现新功能"],"designNotes":[]}' --json
+   ```
+
+   **步骤 3**: 调用 CLI 启动任务执行:
+   ```bash
+   # 使用 --brainstorm-answers 参数传递收集的信息
+   openmatrix start "$TASK_INPUT" \
+     --title "$TASK_TITLE" \
+     --quality "$QUALITY_LEVEL" \
+     --mode "$MODE" \
+     --brainstorm-answers '$RESULTS_JSON' \
+     --json
+   ```
+
+   实际执行示例:
+   ```bash
+   openmatrix start "实现用户登录功能" \
+     --title "用户登录功能" \
+     --quality balanced \
+     --mode auto \
+     --brainstorm-answers '{"answers":{"core_objective":"实现新功能","user_value":"终端用户"},"insights":["核心目标是实现新功能"],"designNotes":[]}' \
+     --json
+   ```
+
+   **步骤 4**: 读取 CLI 返回的 SubagentTask 列表并执行:
+   ```typescript
+   // CLI 返回 JSON 格式的任务列表
+   const result = JSON.parse(cliOutput);
+   if (result.status === 'continue' && result.subagentTasks.length > 0) {
+     // 使用 Agent 工具执行每个 SubagentTask
+     for (const task of result.subagentTasks) {
+       await Agent({
+         subagent_type: task.subagent_type,
+         description: task.description,
+         prompt: task.prompt,
+         isolation: task.isolation
+       });
+     }
+   }
+   ```
+
+   **注意事项**:
+   - 必须先调用 `--complete --results` 保存答案
+   - 然后调用 `openmatrix start` 并传递 `--brainstorm-answers`
+   - 最后读取返回的 SubagentTask 列表并执行
+   - 不要直接执行任务，必须通过 `/om:start` 启动
 
 </process>
 

package/skills/start.md

@@ -3,6 +3,25 @@ name: om:start
 description: 启动新的任务执行周期
 ---
 
+## 📊 进度状态指示器
+
+在执行过程中，始终显示当前进度状态:
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  OpenMatrix 执行流程                                          ║
+╠═══════════════════════════════════════════════════════════════╣
+║  [1/6] 🧠 Brainstorm    → 深入理解需求                        ║
+║  [2/6] 📋 Plan          → 拆解任务，制定计划                   ║
+║  [3/6] 🔧 Develop       → 编写代码实现                         ║
+║  [4/6] ✅ Verify        → 测试、Lint、安全扫描                 ║
+║  [5/6] 🎯 Accept        → 验收确认                             ║
+║  [6/6] 📦 Complete      → 提交、部署                           ║
+╚═══════════════════════════════════════════════════════════════╝
+
+📍 当前位置: Step X/6 - [阶段名称]
+```
+
 <EXTREMELY-IMPORTANT>
 ## 必须使用此 Skill 的情况
 
@@ -74,6 +93,22 @@ description: 启动新的任务执行周期
    - 如果 `$ARGUMENTS` 是任务描述 → 直接使用
    - 如果无参数 → 使用 AskUserQuestion 询问用户要执行的任务
 
+6. **检查 brainstorm 会话 (重要)**
+
+   检查 `.openmatrix/brainstorm/session.json` 是否存在:
+   - 如果存在且 `status === 'ready_to_start'`，读取收集的信息:
+     ```json
+     {
+       "taskInput": "任务描述",
+       "taskTitle": "任务标题",
+       "answers": { "core_objective": "...", ... },
+       "insights": ["洞察1", "洞察2"],
+       "designNotes": ["设计要点1"]
+     }
+     ```
+   - 将这些信息用于后续的任务分析和质量级别推荐
+   - **从 brainstorm 继承的答案可以跳过重复提问**
+
 ---
 
 ## Step 1: 展示理解 + 选择质量级别
@@ -139,9 +174,43 @@ AskUserQuestion({
 
 ## Step 2: 展示执行计划 + 执行模式
 
-**调用 CLI 拆解任务（传入任务描述）:**
+**调用 CLI 拆解任务（传入任务描述和质量配置）:**
+
 ```bash
-openmatrix plan "$ARGUMENTS" --json
+# 基本调用
+openmatrix start "$TASK_INPUT" --quality "$QUALITY_LEVEL" --mode "$MODE" --json
+
+# 如果有 brainstorm 信息，传递额外参数
+openmatrix start "$TASK_INPUT" \
+  --quality "$QUALITY_LEVEL" \
+  --mode "$MODE" \
+  --title "$TASK_TITLE" \
+  --tech-stack "$TECH_STACK" \
+  --json
+```
+
+**参数说明:**
+- `$TASK_INPUT`: 任务描述或文件路径
+- `$QUALITY_LEVEL`: fast | balanced | strict
+- `$MODE`: auto | confirm-key | confirm-all
+- `$TASK_TITLE`: 从 brainstorm 继承的任务标题
+- `$TECH_STACK`: 技术栈 (逗号分隔)
+
+**重要**: CLI 会自动:
+1. 解析任务
+2. 拆解为子任务
+3. 创建任务文件到 `.openmatrix/tasks/`
+4. 返回待执行的 SubagentTask 列表
+
+---
+
+**📍 Step 2 完成 → 下一步: Step 3 执行**
+
+输出进度提示:
+```
+✅ Step 2/6 完成 - 任务计划已生成
+   📊 统计: X 个任务, 预计 Y 分钟
+   ➡️ 下一步: Step 3 - 开始执行任务
 ```
 
 **展示执行计划:**
@@ -204,8 +273,22 @@ AskUserQuestion({
 
 ## Step 3: 执行
 
+**📍 当前进度: Step 3/6 - 执行任务**
+
 **重要**: 从此步骤开始，除非遇到风险操作、meeting 或失败，否则**不得暂停询问用户**。
 
+### 执行开始提示
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  🚀 开始执行任务                                              ║
+╠═══════════════════════════════════════════════════════════════╣
+║  质量级别: balanced                                           ║
+║  执行模式: auto                                                ║
+║  总任务数: X                                                   ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
 ### 执行循环
 
 ```
@@ -284,13 +367,102 @@ while (有待执行任务) {
 
 ### 执行完成
 
+**📍 Step 3/6 完成 → 显示执行总结**
+
 ```
-✅ 任务完成!
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ Step 3/6 完成 - 执行阶段结束                               ║
+╠═══════════════════════════════════════════════════════════════╣
+║  📊 执行统计:                                                  ║
+║     • 总任务: X                                                ║
+║     • 成功: X                                                  ║
+║     • 失败: X                                                  ║
+║     • 跳过: X                                                  ║
+║                                                                ║
+║  📝 文件改动: 3 个文件                                          ║
+║  🔗 Git Commits: 2 个                                          ║
+║                                                                ║
+║  ➡️ 下一步: Step 4 - 验证阶段 (自动运行)                        ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Step 4: 验证 (Verify)
+
+**📍 当前进度: Step 4/6 - 验证质量门禁**
+
+自动执行验证 (根据质量级别):
+
+```
+🔍 验证阶段开始...
+
+[1/5] 🏗️  编译检查     → npm run build
+[2/5] 🧪  测试运行     → npm test
+[3/5] 📊  覆盖率检查   → npm test -- --coverage
+[4/5] 🔍  Lint 检查    → npm run lint
+[5/5] 🔒  安全扫描     → npm audit
+
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ Step 4/6 完成 - 验证通过                                   ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Tests:    ✅ 15/15 passed, 85% coverage                       ║
+║  Build:    ✅ Success                                          ║
+║  Lint:     ✅ No errors                                        ║
+║  Security: ✅ No vulnerabilities                                ║
+║                                                                ║
+║  ➡️ 下一步: Step 5 - 验收阶段                                  ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+---
 
-📝 改动: 3 个文件
-🔗 Commits: 2 个
+## Step 5: 验收 (Accept)
 
-[查看 Diff] [回滚上一步] [回滚全部]
+**📍 当前进度: Step 5/6 - 最终验收**
+
+检查验收标准:
+
+```
+📋 验收标准检查:
+
+[✅] 1. 所有功能按预期工作
+[✅] 2. 测试覆盖率达到要求
+[✅] 3. 无 Lint 错误
+[✅] 4. 无安全漏洞
+
+╔═══════════════════════════════════════════════════════════════╗
+║  ✅ Step 5/6 完成 - 验收通过                                   ║
+╠═══════════════════════════════════════════════════════════════╣
+║  验收结果: ✅ 全部通过                                         ║
+║                                                                ║
+║  ➡️ 下一步: Step 6 - 完成阶段                                  ║
+╚═══════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Step 6: 完成 (Complete)
+
+**📍 当前进度: Step 6/6 - 最终提交**
+
+```
+╔═══════════════════════════════════════════════════════════════╗
+║  🎉 Step 6/6 完成 - 任务全部完成!                              ║
+╠═══════════════════════════════════════════════════════════════╣
+║  📊 总结:                                                      ║
+║     • 总任务: X                                                ║
+║     • 成功: X                                                  ║
+║     • 失败: X                                                  ║
+║     • 耗时: X 分钟                                             ║
+║                                                                ║
+║  📝 文件改动: X 个文件                                          ║
+║  🔗 Git Commits: X 个                                          ║
+║                                                                ║
+║  🎯 下一步建议:                                                 ║
+║     • git push (如需推送)                                       ║
+║     • /om:report (查看详细报告)                                ║
+╚═══════════════════════════════════════════════════════════════╝
 ```
 
 ---