openmatrix 0.1.14 → 0.1.16

package/README.md

@@ -161,15 +161,15 @@ ls ~/.claude/commands/om/
 
 ### 1️⃣ 三级质量配置 (第一个问题就让你选)
 
-| 级别 | TDD | 覆盖率 | Lint | 安全 | AI验收 | 适用场景 |
-|:----:|:---:|:------:|:----:|:----:|:------:|---------|
-| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ✅ | 🏭 **生产代码** |
-| **balanced** | ❌ | >60% | ✅ | ✅ | ✅ | 📦 日常开发 |
-| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | 🏃 快速原型 |
+| 级别 | TDD | 覆盖率 | Lint | 安全 | E2E测试 | AI验收 | 适用场景 |
+|:----:|:---:|:------:|:----:|:----:|:-------:|:------:|---------|
+| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ❓ 可选 | ✅ | 🏭 **生产代码** |
+| **balanced** | ❌ | >60% | ✅ | ✅ | ❓ 可选 | ✅ | 📦 日常开发 |
+| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | ❌ | 🏃 快速原型 |
 
-> strict 可配置为 100%。默认 >80% 覆盖核心业务逻辑。
+> E2E 测试耗时较长，建议根据项目需要选择。strict 可配置为 100%。默认 >80% 覆盖核心业务逻辑。
 
-### 2️⃣ 六道质量门禁 (Verify 阶段)
+### 2️⃣ 七道质量门禁 (Verify 阶段)
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
@@ -180,7 +180,8 @@ ls ~/.claude/commands/om/
 │  🚪 Gate 3: 覆盖率检查   >20%/60%/80%    → 可配置         │
 │  🚪 Gate 4: Lint 检查    无 error         → 可配置         │
 │  🚪 Gate 5: 安全扫描     npm audit        → 无高危漏洞     │
-│  🚪 Gate 6: 验收标准     用户定义         → 必须全部满足   │
+│  🚪 Gate 6: E2E 测试     Playwright等     → 可选           │
+│  🚪 Gate 7: 验收标准     用户定义         → 必须全部满足   │
 └─────────────────────────────────────────────────────────────┘
 ```
 
@@ -378,6 +379,7 @@ Accept 阶段由 Reviewer Agent 执行:
   "build": { "success": true },
   "lint": { "errors": 0, "warnings": 3 },
   "security": { "vulnerabilities": [] },
+  "e2e": { "passed": 5, "failed": 0, "skipped": 0 },
   "acceptance": { "met": 5, "total": 5 }
 }
 ```
@@ -431,7 +433,8 @@ OpenMatrix 通过 Claude Code Agent 工具**原生支持所有主流编程语言
     "tdd": false,
     "minCoverage": 60,
     "strictLint": true,
-    "securityScan": true
+    "securityScan": true,
+    "e2eTests": false
   },
   "approvalPoints": ["plan", "merge"],
   "agents": { "maxConcurrent": 3 }
@@ -452,12 +455,13 @@ cd openmatrix && npm install && npm run build && npm test
 ## Roadmap
 
 - [x] TDD 模式
-- [x] 6 道质量门禁
+- [x] 7 道质量门禁
 - [x] Meeting 机制
 - [x] 质量报告
 - [x] AI 验收
 - [x] `/om:auto` 全自动模式
 - [x] 多语言支持 (Python/Go/Java/TypeScript 等)
+- [x] E2E 测试支持 (Web/Mobile/GUI)
 - [ ] VSCode 扩展
 - [ ] CI/CD 集成
 

package/dist/cli/commands/start.js

@@ -42,15 +42,22 @@ 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"));
 const path = __importStar(require("path"));
 exports.startCommand = new commander_1.Command('start')
     .description('启动新的任务执行周期')
     .argument('[input]', '任务文件路径或描述')
     .option('-c, --config <path>', '配置文件路径')
+    .option('--init-only', '仅初始化 .openmatrix 目录，不执行任务')
     .option('--skip-questions', '跳过澄清问题')
     .option('--mode <mode>', '执行模式 (confirm-all|confirm-key|auto)')
     .option('--json', '输出 JSON 格式 (供 Skill 解析)')
+    .option('--title <title>', '任务标题')
+    .option('--description <desc>', '任务描述')
+    .option('-q, --quality <level>', '质量级别 (strict|balanced|fast)')
+    .option('-t, --tech-stack <stack>', '技术栈 (逗号分隔，如 "TypeScript,Vue.js,PostgreSQL")')
+    .option('--docs <level>', '文档级别 (full|basic|minimal|none)')
     .action(async (input, options) => {
     const basePath = process.cwd();
     const omPath = path.join(basePath, '.openmatrix');
@@ -60,6 +67,21 @@ exports.startCommand = new commander_1.Command('start')
     await fs.mkdir(path.join(omPath, 'approvals'), { recursive: true });
     // 确保 .openmatrix 被 git 忽略
     await (0, gitignore_js_1.ensureOpenmatrixGitignore)(basePath);
+    // --init-only 模式：仅初始化目录后返回
+    if (options.initOnly) {
+        if (options.json) {
+            console.log(JSON.stringify({
+                status: 'initialized',
+                message: '.openmatrix 目录已初始化',
+                path: omPath
+            }));
+        }
+        else {
+            console.log('✅ .openmatrix 目录已初始化');
+            console.log(`   路径: ${omPath}`);
+        }
+        return;
+    }
     const stateManager = new state_manager_js_1.StateManager(omPath);
     await stateManager.initialize();
     const state = await stateManager.getState();
@@ -79,10 +101,18 @@ exports.startCommand = new commander_1.Command('start')
         }
         return;
     }
-    // 获取任务内容
+    // 构建任务内容
     let taskContent = input;
+    // 如果提供了 --title 和 --description，构建任务内容
+    if (options.title || options.description) {
+        const title = options.title || '未命名任务';
+        const description = options.description || '';
+        const techStack = options.techStack ? `\n\n技术栈: ${options.techStack}` : '';
+        const docs = options.docs ? `\n文档要求: ${options.docs}` : '';
+        taskContent = `# ${title}\n\n${description}${techStack}${docs}`;
+    }
+    // 如果没有任务内容，尝试读取默认文件
     if (!taskContent) {
-        // 尝试读取默认任务文件
         const defaultPath = path.join(basePath, 'TASK.md');
         try {
             taskContent = await fs.readFile(defaultPath, 'utf-8');
@@ -101,6 +131,7 @@ exports.startCommand = new commander_1.Command('start')
                 console.log('❌ 请提供任务文件路径或描述');
                 console.log('   用法: openmatrix start <task.md>');
                 console.log('   或创建 TASK.md 文件');
+                console.log('   或使用 --title 和 --description 选项');
             }
             return;
         }
@@ -158,9 +189,6 @@ exports.startCommand = new commander_1.Command('start')
     const executionMode = options.mode || 'confirm-key';
     let approvalPoints = [];
     // 根据模式设置审批点
-    // auto 模式: 空数组，不暂停任何审批点
-    // confirm-key 模式: 仅在关键节点暂停
-    // confirm-all 模式: 每个阶段都暂停
     switch (executionMode) {
         case 'confirm-all':
             approvalPoints = ['plan', 'phase', 'merge', 'deploy'];
@@ -169,18 +197,27 @@ exports.startCommand = new commander_1.Command('start')
             approvalPoints = ['plan', 'merge', 'deploy'];
             break;
         case 'auto':
-            approvalPoints = []; // 全自动模式：无任何审批点
+            approvalPoints = [];
             break;
         default:
             approvalPoints = ['plan', 'merge'];
     }
+    // 处理质量配置
+    let qualityConfig;
+    if (options.quality) {
+        const qualityLevel = options.quality.toLowerCase();
+        if (['strict', 'balanced', 'fast'].includes(qualityLevel)) {
+            qualityConfig = index_js_1.QUALITY_PRESETS[qualityLevel];
+        }
+    }
     // 更新状态
     await stateManager.updateState({
         status: 'running',
         currentPhase: 'execution',
         config: {
             ...state.config,
-            approvalPoints: approvalPoints
+            approvalPoints: approvalPoints,
+            quality: qualityConfig || state.config.quality
         }
     });
     // 创建审批请求（如果有审批点）
@@ -198,7 +235,15 @@ exports.startCommand = new commander_1.Command('start')
                     index: i + 1,
                     title: t.title,
                     priority: t.priority
-                }))
+                })),
+                // 额外信息供 Skill 使用
+                taskInfo: {
+                    title: options.title || parsedTask.title,
+                    description: options.description,
+                    quality: options.quality,
+                    techStack: options.techStack,
+                    docs: options.docs
+                }
             }));
         }
         else {
@@ -208,6 +253,12 @@ exports.startCommand = new commander_1.Command('start')
             });
             console.log(`\n🎯 执行模式: ${executionMode}`);
             console.log(`   审批点: ${approvalPoints.join(', ')}`);
+            if (options.quality) {
+                console.log(`   质量级别: ${options.quality}`);
+            }
+            if (options.techStack) {
+                console.log(`   技术栈: ${options.techStack}`);
+            }
             console.log(`\n⏸️  等待计划审批`);
             console.log(`   审批ID: ${approval.id}`);
             console.log(`   使用 /om:approve ${approval.id} 审批`);
@@ -242,7 +293,15 @@ exports.startCommand = new commander_1.Command('start')
                 taskId: t.taskId,
                 agentType: t.agentType,
                 timeout: t.timeout
-            }))
+            })),
+            // 额外信息供 Skill 使用
+            taskInfo: {
+                title: options.title || parsedTask.title,
+                description: options.description,
+                quality: options.quality,
+                techStack: options.techStack,
+                docs: options.docs
+            }
         }));
     }
     else {
@@ -252,6 +311,12 @@ exports.startCommand = new commander_1.Command('start')
         });
         console.log(`\n🎯 执行模式: ${executionMode}`);
         console.log(`   审批点: ${approvalPoints.length > 0 ? approvalPoints.join(', ') : '无 (全自动)'}`);
+        if (options.quality) {
+            console.log(`   质量级别: ${options.quality}`);
+        }
+        if (options.techStack) {
+            console.log(`   技术栈: ${options.techStack}`);
+        }
         console.log('\n🚀 开始执行...');
         console.log('   使用 /om:status 查看进度');
     }

package/dist/orchestrator/phase-executor.d.ts

@@ -44,6 +44,12 @@ export interface QualityGateResult {
     security: {
         vulnerabilities: number;
     };
+    e2e: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        duration: number;
+    };
     acceptance: {
         met: number;
         total: number;

package/dist/orchestrator/phase-executor.js

@@ -39,6 +39,7 @@ class PhaseExecutor {
         minCoverage: 60,
         strictLint: true,
         securityScan: true,
+        e2eTests: false,
         level: 'balanced'
     };
     constructor(stateManager, approvalManager) {
@@ -86,9 +87,9 @@ class PhaseExecutor {
      */
     setQualityLevel(level) {
         const presets = {
-            fast: { tdd: false, minCoverage: 0, strictLint: false, securityScan: false, level: 'fast' },
-            balanced: { tdd: false, minCoverage: 60, strictLint: true, securityScan: true, level: 'balanced' },
-            strict: { tdd: true, minCoverage: 80, strictLint: true, securityScan: true, level: 'strict' }
+            fast: { tdd: false, minCoverage: 0, strictLint: false, securityScan: false, e2eTests: false, level: 'fast' },
+            balanced: { tdd: false, minCoverage: 60, strictLint: true, securityScan: true, e2eTests: false, level: 'balanced' },
+            strict: { tdd: true, minCoverage: 80, strictLint: true, securityScan: true, e2eTests: false, level: 'strict' }
         };
         this.qualityConfig = presets[level];
         this.minTestCoverage = this.qualityConfig.minCoverage;
@@ -376,6 +377,7 @@ ${isTDDMode ? '- [ ] 所有测试通过 (GREEN)' : ''}
 | 覆盖率 | >= ${qc.minCoverage}% | ${qc.minCoverage > 0 ? '❌ 阻止通过' : '⚠️ 仅警告'} |
 | Lint | ${qc.strictLint ? '无 error' : '无严重 error'} | ${qc.strictLint ? '❌ 阻止通过' : '⚠️ 仅警告'} |
 | 安全 | 无高危漏洞 | ${qc.securityScan ? '❌ 阻止通过' : '⏭️ 跳过'} |
+| E2E | 全部通过 | ${qc.e2eTests ? '❌ 阻止通过' : '⏭️ 跳过'} |
 | 验收标准 | 全部满足 | ❌ 阻止通过 |
 
 ## 自动化验证命令
@@ -415,7 +417,21 @@ npm audit --audit-level=high || echo "Security scan skipped"
 **要求**: 无 high/critical 漏洞
 **失败后果**: ❌ VERIFY_FAILED` : '⏭️ 已禁用'}
 
-### 6. 验收标准验证`);
+### 6. E2E 测试 (端到端测试)
+${qc.e2eTests ? `\`\`\`bash
+# Web 应用: Playwright / Cypress
+npx playwright test || npx cypress run
+
+# 移动端: Appium / Detox
+npx appium ... || npx detox test
+
+# GUI 桌面应用: 根据项目配置
+npm run test:e2e
+\`\`\`
+**要求**: 所有 E2E 测试通过
+**失败后果**: ❌ VERIFY_FAILED` : '⏭️ 已禁用'}
+
+### 7. 验收标准验证`);
         // 注入验收标准
         if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
             parts.push(`
@@ -458,6 +474,13 @@ ${task.acceptanceCriteria.map((c, i) => `${i + 1}. [ ] ${c}`).join('\n')}
     "vulnerabilities": [],
     "status": "pass|fail"
   },
+  "e2e": {
+    "passed": 0,
+    "failed": 0,
+    "skipped": 0,
+    "duration": 0,
+    "status": "pass|fail|skipped"
+  },
   "acceptance": {
     "total": ${task.acceptanceCriteria?.length || 0},
     "met": 0,
@@ -478,6 +501,7 @@ Quality Score: [A/B/C/D/F]
 - Build: ✅ Success
 - Lint: ✅ No errors
 - Security: ✅ No vulnerabilities
+${qc.e2eTests ? '- E2E: ✅ X/X passed' : ''}
 - Acceptance: ✅ N/M criteria met
 \`\`\`
 
@@ -712,6 +736,7 @@ ACCEPT_FAILED
             build: { success: false, errors: [] },
             lint: { errors: 0, warnings: 0 },
             security: { vulnerabilities: 0 },
+            e2e: { passed: 0, failed: 0, skipped: 0, duration: 0 },
             acceptance: { met: 0, total: 0 }
         };
         // 解析测试结果
@@ -738,13 +763,27 @@ ACCEPT_FAILED
         const vulnMatch = output.match(/(\d+)\s*(?:vulnerabilities|vulnerable)/i);
         if (vulnMatch)
             result.security.vulnerabilities = parseInt(vulnMatch[1], 10);
+        // 解析 E2E 测试结果
+        const e2ePassedMatch = output.match(/(?:e2e|playwright|cypress|appium|detox).*?(\d+)\s*(?:passed|passing)/i);
+        if (e2ePassedMatch)
+            result.e2e.passed = parseInt(e2ePassedMatch[1], 10);
+        const e2eFailedMatch = output.match(/(?:e2e|playwright|cypress|appium|detox).*?(\d+)\s*(?:failed|failing)/i);
+        if (e2eFailedMatch)
+            result.e2e.failed = parseInt(e2eFailedMatch[1], 10);
+        const e2eSkippedMatch = output.match(/(?:e2e|playwright|cypress|appium|detox).*?(\d+)\s*skipped/i);
+        if (e2eSkippedMatch)
+            result.e2e.skipped = parseInt(e2eSkippedMatch[1], 10);
+        const e2eDurationMatch = output.match(/(?:e2e|playwright|cypress|appium|detox).*?(\d+)\s*(?:ms|s|min)/i);
+        if (e2eDurationMatch)
+            result.e2e.duration = parseInt(e2eDurationMatch[1], 10);
         // 判断是否通过
         const qc = this.qualityConfig;
         const testsPassed = result.tests.failed === 0;
         const coverageOk = result.tests.coverage >= qc.minCoverage;
         const lintOk = qc.strictLint ? result.lint.errors === 0 : true;
         const buildOk = result.build.success;
-        result.passed = testsPassed && coverageOk && lintOk && buildOk;
+        const e2eOk = qc.e2eTests ? result.e2e.failed === 0 : true;
+        result.passed = testsPassed && coverageOk && lintOk && buildOk && e2eOk;
         return result;
     }
     /**
@@ -777,6 +816,13 @@ ACCEPT_FAILED
                 vulnerabilities: [],
                 status: gateResult.security.vulnerabilities === 0 ? 'pass' : 'fail'
             },
+            e2e: {
+                passed: gateResult.e2e.passed,
+                failed: gateResult.e2e.failed,
+                skipped: gateResult.e2e.skipped,
+                duration: gateResult.e2e.duration,
+                status: qc.e2eTests ? (gateResult.e2e.failed === 0 ? 'pass' : 'fail') : 'skipped'
+            },
             acceptance: {
                 total: task.acceptanceCriteria?.length || 0,
                 met: gateResult.acceptance.met,

package/dist/orchestrator/task-planner.d.ts

@@ -17,6 +17,10 @@ export interface UserAnswers {
     testCoverage?: string;
     documentationLevel?: string;
     additionalContext?: Record<string, string>;
+    /** 是否启用 E2E 测试 */
+    e2eTests?: boolean;
+    /** E2E 测试类型 (web/mobile/gui) */
+    e2eType?: 'web' | 'mobile' | 'gui';
 }
 /**
  * TaskPlanner - 任务拆解器
@@ -57,6 +61,18 @@ export declare class TaskPlanner {
      * 构建测试任务描述
      */
     private buildTestDescription;
+    /**
+     * 构建 E2E 测试任务描述
+     */
+    private buildE2ETestDescription;
+    /**
+     * 获取 E2E 测试类型配置
+     */
+    private getE2ETypeConfig;
+    /**
+     * 生成用户流程测试用例
+     */
+    private generateUserFlows;
     /**
      * 解析覆盖率数值
      */

package/dist/orchestrator/task-planner.js

@@ -164,7 +164,36 @@ ${parsedTask.deliverables.map(d => `- ${d}`).join('\n')}
                 ]
             });
         }
-        // 4. 文档任务 (如果需要)
+        // 4. E2E 测试任务 (如果启用，作为 verify 阶段的一部分)
+        if (userContext.e2eTests) {
+            const e2eTaskId = this.generateTaskId();
+            const e2eType = userContext.e2eType || 'web';
+            // E2E 测试依赖所有开发任务和单元测试任务
+            const allTestDependencies = [...devTaskIds];
+            breakdowns.forEach(b => {
+                if (b.phase === 'verify' && b.title.startsWith('测试:')) {
+                    allTestDependencies.push(b.taskId);
+                }
+            });
+            breakdowns.push({
+                taskId: e2eTaskId,
+                title: '端到端(E2E)测试',
+                description: this.buildE2ETestDescription(e2eType, parsedTask, userContext),
+                priority: 'P0', // E2E 测试是关键任务
+                dependencies: allTestDependencies, // 依赖所有开发任务和单元测试
+                estimatedComplexity: 'high',
+                assignedAgent: 'tester',
+                phase: 'verify',
+                acceptanceCriteria: [
+                    '所有 E2E 测试用例通过',
+                    '关键用户流程验证完成',
+                    '跨浏览器/设备兼容性验证',
+                    'E2E 测试报告已生成',
+                    '无阻塞级别的缺陷'
+                ]
+            });
+        }
+        // 5. 文档任务 (如果需要)
         if (userContext.documentationLevel && userContext.documentationLevel !== '无需文档') {
             breakdowns.push({
                 taskId: this.generateTaskId(),
@@ -196,11 +225,15 @@ ${userContext.documentationLevel}
      * 提取用户上下文
      */
     extractUserContext(answers) {
+        const e2eAnswer = answers['E2E测试'] || answers['e2eTests'] || answers['e2e'];
+        const e2eTypeAnswer = answers['E2E类型'] || answers['e2eType'];
         return {
             objective: answers['目标'] || answers['objective'],
             techStack: this.parseArrayAnswer(answers['技术栈'] || answers['techStack']),
             testCoverage: answers['测试'] || answers['testCoverage'],
             documentationLevel: answers['文档'] || answers['documentationLevel'],
+            e2eTests: e2eAnswer === 'true' || e2eAnswer === '✅ 启用 E2E 测试' || e2eAnswer === '是',
+            e2eType: e2eTypeAnswer || 'web',
             additionalContext: answers
         };
     }
@@ -263,6 +296,101 @@ ${devTaskId}
 - 测试报告
 - 覆盖率报告`;
     }
+    /**
+     * 构建 E2E 测试任务描述
+     */
+    buildE2ETestDescription(e2eType, parsedTask, userContext) {
+        const typeConfig = this.getE2ETypeConfig(e2eType);
+        return `## E2E 测试目标
+执行完整的端到端测试，验证关键用户流程
+
+## 应用类型
+${typeConfig.description}
+
+## 测试框架
+${typeConfig.frameworks.map(f => `- ${f}`).join('\n')}
+
+## 测试范围
+${parsedTask.goals.map((g, i) => `${i + 1}. ${g}`).join('\n')}
+
+## 关键用户流程
+根据应用功能，测试以下流程:
+${this.generateUserFlows(parsedTask, e2eType)}
+
+## 测试环境
+${typeConfig.environments.map(e => `- ${e}`).join('\n')}
+
+## 测试要求
+1. **关键路径覆盖**: 所有核心用户流程必须有 E2E 测试
+2. **断言完整**: 每个测试步骤必须有明确的断言
+3. **等待策略**: 使用合理的等待机制，避免硬编码延迟
+4. **数据隔离**: 测试数据独立，不影响其他测试
+5. **清理机制**: 测试后清理创建的数据
+
+## 输出要求
+- E2E 测试文件 (tests/e2e/*.spec.ts)
+- 测试执行报告
+- 截图/录像 (失败时)
+- 测试覆盖率报告 (如有)
+
+## 运行命令
+\`\`\`bash
+${typeConfig.runCommand}
+\`\`\`
+
+## 验收标准
+- [ ] 所有 E2E 测试用例通过
+- [ ] 关键用户流程验证完成
+- [ ] 跨浏览器/设备兼容性验证
+- [ ] E2E 测试报告已生成
+- [ ] 无阻塞级别的缺陷`;
+    }
+    /**
+     * 获取 E2E 测试类型配置
+     */
+    getE2ETypeConfig(type) {
+        const configs = {
+            web: {
+                description: 'Web 应用 (浏览器)',
+                frameworks: ['Playwright (推荐)', 'Cypress', 'Selenium WebDriver', 'Puppeteer'],
+                environments: ['Chrome', 'Firefox', 'Safari', 'Edge', 'Mobile Viewports'],
+                runCommand: 'npx playwright test --reporter=html'
+            },
+            mobile: {
+                description: '移动应用 (iOS/Android)',
+                frameworks: ['Appium', 'Detox (React Native)', 'XCUITest (iOS)', 'Espresso (Android)'],
+                environments: ['iOS Simulator', 'Android Emulator', 'Real Devices'],
+                runCommand: 'npx appium --base-path /wd/hub && npm run test:e2e'
+            },
+            gui: {
+                description: 'GUI 桌面应用 (Electron/Native)',
+                frameworks: ['Playwright for Electron', 'Spectron (Electron)', 'Robot Framework', 'PyAutoGUI'],
+                environments: ['Windows', 'macOS', 'Linux'],
+                runCommand: 'npm run test:e2e'
+            }
+        };
+        return configs[type];
+    }
+    /**
+     * 生成用户流程测试用例
+     */
+    generateUserFlows(parsedTask, type) {
+        const flows = [];
+        const goals = parsedTask.goals;
+        // 根据目标生成用户流程
+        goals.forEach((goal, i) => {
+            flows.push(`\n### 流程 ${i + 1}: ${goal}`);
+            flows.push('```gherkin');
+            flows.push(`Feature: ${goal}`);
+            flows.push('');
+            flows.push('  Scenario: 正常流程');
+            flows.push(`    Given 用户已启动应用`);
+            flows.push(`    When 用户执行 "${goal}" 操作`);
+            flows.push(`    Then 操作成功完成`);
+            flows.push('```');
+        });
+        return flows.join('\n');
+    }
     /**
      * 解析覆盖率数值
      */

package/dist/types/index.d.ts

@@ -107,6 +107,8 @@ export interface QualityConfig {
     strictLint: boolean;
     /** 安全扫描 */
     securityScan: boolean;
+    /** 端到端测试 (适用于 Web 项目等需要 E2E 测试的场景) */
+    e2eTests: boolean;
     /** 质量级别 */
     level: 'fast' | 'balanced' | 'strict';
 }
@@ -141,6 +143,14 @@ export interface QualityReport {
         vulnerabilities: SecurityVulnerability[];
         status: 'pass' | 'fail';
     };
+    /** E2E 测试结果 */
+    e2e: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        duration: number;
+        status: 'pass' | 'fail' | 'skipped';
+    };
     /** 验收标准检查 */
     acceptance: {
         total: number;

package/dist/types/index.js

@@ -11,6 +11,7 @@ exports.QUALITY_PRESETS = {
         minCoverage: 0,
         strictLint: false,
         securityScan: false,
+        e2eTests: false,
         level: 'fast'
     },
     balanced: {
@@ -18,6 +19,7 @@ exports.QUALITY_PRESETS = {
         minCoverage: 60,
         strictLint: true,
         securityScan: true,
+        e2eTests: false,
         level: 'balanced'
     },
     strict: {
@@ -25,6 +27,7 @@ exports.QUALITY_PRESETS = {
         minCoverage: 80,
         strictLint: true,
         securityScan: true,
+        e2eTests: false, // 让用户选择，因为 E2E 测试耗时
         level: 'strict'
     }
 };

package/package.json

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

package/skills/openmatrix.md

@@ -1,6 +1,8 @@
 ---
 name: openmatrix
 description: "Invoke /om:start for any implementation task - adding features, fixing bugs, refactoring, creating commands, writing code, building systems. Use this when user describes work to be done, not for questions or information requests."
+priority: high
+always_load: true
 ---
 
 <objective>

package/skills/start.md

@@ -19,6 +19,7 @@ description: 启动新的任务执行周期
      openmatrix start --init-only
      ```
    - 这会创建 `.openmatrix/`、`.openmatrix/tasks/`、`.openmatrix/approvals/` 目录
+   - 同时自动将 `.openmatrix/` 添加到 `.gitignore`
 
 2. **检查当前状态**
    - 读取 `.openmatrix/state.json`
@@ -40,7 +41,7 @@ description: 启动新的任务执行周期
 
 5. **⚠️ 交互式问答 (必须执行)**
 
-   **重要**: 除非用户明确指定 `--skip-questions`，否则必须执行交互式问答。
+   **重要**: 除非用户明确指定 `--skip-questions` 或提供了 `--quality` 等选项，否则必须执行交互式问答。
 
    使用 `AskUserQuestion` 工具，逐个提出以下问题：
 
@@ -53,11 +54,11 @@ description: 启动新的任务执行周期
        options: [
          {
            label: "🚀 strict (推荐生产代码)",
-           description: "TDD + 80%覆盖率 + 严格Lint + 安全扫描 + AI验收"
+           description: "TDD + 80%覆盖率 + 严格Lint + 安全扫描 + AI验收 (E2E可选)"
          },
          {
            label: "⚖️ balanced (日常开发)",
-           description: "60%覆盖率 + Lint + 安全扫描 + AI验收"
+           description: "60%覆盖率 + Lint + 安全扫描 + AI验收 (E2E可选)"
          },
          {
            label: "⚡ fast (快速原型)",
@@ -69,6 +70,52 @@ description: 启动新的任务执行周期
    })
    ```
 
+   **⚠️ 如果用户选择 "strict" 或 "balanced"，追问 E2E 测试:**
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: "是否需要端到端(E2E)测试？(适用于 Web、移动端、GUI 桌面应用等需要完整用户流程测试的场景，较耗时)",
+       header: "E2E测试",
+       options: [
+         {
+           label: "✅ 启用 E2E 测试",
+           description: "添加端到端测试，验证完整用户流程（Playwright/Cypress/Appium等）"
+         },
+         {
+           label: "❌ 不需要",
+           description: "仅运行单元测试和集成测试"
+         }
+       ],
+       multiSelect: false
+     }]
+   })
+   ```
+
+   **⚠️ 如果用户启用 E2E 测试，追问应用类型:**
+   ```typescript
+   AskUserQuestion({
+     questions: [{
+       question: "选择应用类型以确定 E2E 测试方案:",
+       header: "应用类型",
+       options: [
+         {
+           label: "🌐 Web 应用",
+           description: "浏览器应用 - Playwright/Cypress/Selenium"
+         },
+         {
+           label: "📱 移动应用",
+           description: "iOS/Android - Appium/Detox/XCUITest/Espresso"
+         },
+         {
+           label: "🖥️ GUI 桌面应用",
+           description: "Electron/原生桌面 - Playwright/Spectron/Robot Framework"
+         }
+       ],
+       multiSelect: false
+     }]
+   })
+   ```
+
    **问题 1: 任务目标**
    ```typescript
    AskUserQuestion({
@@ -389,36 +436,38 @@ $ARGUMENTS
 <notes>
 ## 质量级别详解
 
-| 级别 | TDD | 覆盖率 | Lint | 安全扫描 | AI验收 | 适用场景 |
-|------|:---:|:------:|:----:|:--------:|:------:|---------|
-| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ✅ | 生产代码、核心功能 |
-| **balanced** | ❌ | >60% | ✅ | ✅ | ✅ | 日常开发 (默认) |
-| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | 快速原型、POC |
+| 级别 | TDD | 覆盖率 | Lint | 安全扫描 | E2E测试 | AI验收 | 适用场景 |
+|------|:---:|:------:|:----:|:--------:|:-------:|:------:|---------|
+| **strict** | ✅ | >80% | ✅ 严格 | ✅ | ❓ 可选 | ✅ | 生产代码、核心功能 |
+| **balanced** | ❌ | >60% | ✅ | ✅ | ❓ 可选 | ✅ | 日常开发 (默认) |
+| **fast** | ❌ | >20% | ❌ | ❌ | ❌ | ❌ | 快速原型、POC |
 
-> strict 可配置为 100%。80% 覆盖核心业务逻辑，100% 成本高收益低。
+> E2E 测试耗时较长，即使在严格模式下也建议根据项目需要选择。strict 可配置为 100%。80% 覆盖核心业务逻辑，100% 成本高收益低。
 
 ### strict 模式 (推荐生产代码)
 ```
 🧪 TDD 阶段:   先写测试 (RED) → 测试必须失败
 ✨ 开发阶段:   再写代码 (GREEN) → 测试必须通过
-✅ 验证阶段:   6道质量门禁
+✅ 验证阶段:   7道质量门禁
    ├── Gate 1: 编译检查 (必须通过)
    ├── Gate 2: 测试运行 (必须通过)
    ├── Gate 3: 覆盖率 >= 80% (必须达标)
    ├── Gate 4: Lint 无 error (必须通过)
    ├── Gate 5: 安全扫描无高危 (必须通过)
-   └── Gate 6: 验收标准全部满足
+   ├── Gate 6: E2E 测试通过 (必须通过，Web项目)
+   └── Gate 7: 验收标准全部满足
 🎉 验收阶段:   AI Reviewer 最终确认
 ```
 
 ### balanced 模式 (日常开发)
 ```
 ✨ 开发阶段:   编写代码
-✅ 验证阶段:   4道质量门禁
+✅ 验证阶段:   4-5道质量门禁
    ├── Gate 1: 编译检查
    ├── Gate 2: 测试运行
    ├── Gate 3: 覆盖率 >= 60%
-   └── Gate 4: 验收标准
+   ├── Gate 4: E2E 测试 (可选，Web项目)
+   └── Gate 5: 验收标准
 🎉 验收阶段:   AI Reviewer 确认
 ```