openmatrix 0.1.0

package/dist/orchestrator/phase-executor.js

@@ -0,0 +1,796 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhaseExecutor = void 0;
+const agent_runner_js_1 = require("../agents/agent-runner.js");
+const git_commit_manager_js_1 = require("./git-commit-manager.js");
+/**
+ * PhaseExecutor - 四阶段验证执行器 (增强版)
+ *
+ * 每个任务经历四个阶段 (TDD 模式):
+ * 0. TDD - 先写测试 (可选)
+ * 1. Develop - 开发实现
+ * 2. Verify - 严格质量门禁 (测试/构建/Lint/安全/验收)
+ * 3. Accept - 最终验收
+ *
+ * 质量级别:
+ * - fast: 无质量门禁，最快
+ * - balanced: 基础门禁 (60%覆盖率, Lint, 安全扫描)
+ * - strict: 严格门禁 (TDD, 80%覆盖率, 严格Lint, 安全扫描)
+ *
+ * 在 auto 模式下 (isAutoMode=true):
+ * - 阶段间自动流转，无需确认
+ * - 质量门禁失败时暂停
+ * - 仅在失败/异常时暂停
+ */
+class PhaseExecutor {
+    stateManager;
+    approvalManager;
+    agentRunner;
+    gitCommitManager;
+    isAutoMode = false;
+    runId = '';
+    userContext = {};
+    minTestCoverage = 60;
+    /** 质量配置 */
+    qualityConfig;
+    /** 默认质量配置 (balanced) */
+    static DEFAULT_QUALITY = {
+        tdd: false,
+        minCoverage: 60,
+        strictLint: true,
+        securityScan: true,
+        level: 'balanced'
+    };
+    constructor(stateManager, approvalManager) {
+        this.stateManager = stateManager;
+        this.approvalManager = approvalManager;
+        this.agentRunner = new agent_runner_js_1.AgentRunner(stateManager, approvalManager);
+        this.gitCommitManager = new git_commit_manager_js_1.GitCommitManager();
+        this.qualityConfig = PhaseExecutor.DEFAULT_QUALITY;
+    }
+    /**
+     * 设置自动模式
+     */
+    setAutoMode(auto) {
+        this.isAutoMode = auto;
+    }
+    /**
+     * 获取自动模式状态
+     */
+    getAutoMode() {
+        return this.isAutoMode;
+    }
+    /**
+     * 设置 Run ID (用于提交信息)
+     */
+    setRunId(runId) {
+        this.runId = runId;
+    }
+    /**
+     * 设置质量配置
+     */
+    setQualityConfig(config) {
+        this.qualityConfig = { ...this.qualityConfig, ...config };
+        if (config.minCoverage !== undefined) {
+            this.minTestCoverage = config.minCoverage;
+        }
+    }
+    /**
+     * 获取质量配置
+     */
+    getQualityConfig() {
+        return this.qualityConfig;
+    }
+    /**
+     * 设置质量级别预设
+     */
+    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' }
+        };
+        this.qualityConfig = presets[level];
+        this.minTestCoverage = this.qualityConfig.minCoverage;
+    }
+    /**
+     * 设置用户上下文
+     */
+    setUserContext(context) {
+        this.userContext = context;
+        this.agentRunner.setUserContext(context);
+        // 从用户上下文解析覆盖率要求
+        if (context.testCoverage) {
+            const match = context.testCoverage.match(/(\d+)/);
+            if (match) {
+                this.minTestCoverage = parseInt(match[1], 10);
+            }
+        }
+    }
+    /**
+     * 设置最低测试覆盖率
+     */
+    setMinTestCoverage(coverage) {
+        this.minTestCoverage = coverage;
+    }
+    /**
+     * 获取最低测试覆盖率
+     */
+    getMinTestCoverage() {
+        return this.minTestCoverage;
+    }
+    /**
+     * 设置是否启用自动提交
+     */
+    setAutoCommit(enabled) {
+        this.gitCommitManager.setEnabled(enabled);
+    }
+    /**
+     * 获取 GitCommitManager 实例
+     */
+    getGitCommitManager() {
+        return this.gitCommitManager;
+    }
+    /**
+     * 获取任务当前阶段
+     */
+    getCurrentPhase(task) {
+        // TDD 模式: 先写测试
+        if (this.qualityConfig.tdd && task.phases.develop.status === 'pending') {
+            // 检查是否已有测试文件
+            return 'tdd';
+        }
+        if (task.phases.develop.status !== 'completed')
+            return 'develop';
+        if (task.phases.verify.status !== 'completed')
+            return 'verify';
+        return 'accept';
+    }
+    /**
+     * 准备阶段执行的 Subagent 任务
+     */
+    async preparePhaseExecution(task) {
+        const currentPhase = this.getCurrentPhase(task);
+        switch (currentPhase) {
+            case 'tdd':
+                return this.prepareTDDPhase(task);
+            case 'develop':
+                return this.prepareDevelopPhase(task);
+            case 'verify':
+                return this.prepareVerifyPhase(task);
+            case 'accept':
+                return this.prepareAcceptPhase(task);
+            default:
+                return null;
+        }
+    }
+    /**
+     * 准备 TDD 阶段 - 先写测试
+     */
+    async prepareTDDPhase(task) {
+        const prompt = this.buildTDDPrompt(task);
+        return {
+            subagent_type: 'general-purpose',
+            description: `tdd: write tests for ${task.title.slice(0, 30)}`,
+            prompt,
+            isolation: undefined,
+            taskId: task.id,
+            agentType: 'tester',
+            timeout: task.timeout / 2,
+            needsApproval: false
+        };
+    }
+    /**
+     * 准备开发阶段
+     */
+    async prepareDevelopPhase(task) {
+        const prompt = this.buildDevelopPrompt(task);
+        return {
+            subagent_type: this.agentRunner.mapAgentType(task.assignedAgent),
+            description: `develop: ${task.title.slice(0, 40)}`,
+            prompt,
+            isolation: 'worktree',
+            taskId: task.id,
+            agentType: task.assignedAgent,
+            timeout: task.timeout,
+            needsApproval: false
+        };
+    }
+    /**
+     * 构建 TDD 阶段提示词 - 先写测试
+     */
+    buildTDDPrompt(task) {
+        return `# TDD 阶段 - 先写测试 (Test-First)
+
+## 任务信息
+- ID: ${task.id}
+- 标题: ${task.title}
+- 描述: ${task.description}
+
+## TDD 目标
+在编写实现代码之前，先编写测试用例。这确保:
+1. 你理解需求
+2. 代码可测试
+3. 有明确的成功标准
+
+## 验收标准 → 测试用例
+${task.acceptanceCriteria?.map((c, i) => `${i + 1}. ${c}`).join('\n') || '根据任务描述生成测试用例'}
+
+## 测试要求
+1. **覆盖正常流程** - 主要功能路径
+2. **覆盖边界情况** - 空值、极值、特殊字符
+3. **覆盖异常处理** - 错误输入、网络失败
+4. **AAA 模式** - Arrange, Act, Assert
+
+## 测试框架
+根据项目选择:
+- TypeScript/JavaScript: Vitest, Jest
+- Python: pytest
+- Go: testing package
+
+## 输出
+1. 创建测试文件 (\`.test.ts\` 或 \`.spec.ts\`)
+2. 测试应该**失败** (因为还没实现)
+3. 输出测试文件路径
+
+## 验证
+运行 \`npm test\` 确认测试失败 (这是正确的!)
+
+## 输出格式
+\`\`\`
+TDD_TESTS_CREATED
+测试文件: [路径]
+测试用例数: [数量]
+预期: 全部失败 (RED 阶段)
+\`\`\`
+`;
+    }
+    /**
+     * 准备验证阶段
+     */
+    async prepareVerifyPhase(task) {
+        const prompt = this.buildVerifyPrompt(task);
+        return {
+            subagent_type: 'general-purpose',
+            description: `verify: ${task.title.slice(0, 40)}`,
+            prompt,
+            isolation: undefined, // 验证不需要隔离
+            taskId: task.id,
+            agentType: 'reviewer',
+            timeout: task.timeout / 2, // 验证阶段时间较短
+            needsApproval: false
+        };
+    }
+    /**
+     * 准备验收阶段
+     */
+    async prepareAcceptPhase(task) {
+        const prompt = this.buildAcceptPrompt(task);
+        return {
+            subagent_type: 'general-purpose',
+            description: `accept: ${task.title.slice(0, 40)}`,
+            prompt,
+            isolation: undefined,
+            taskId: task.id,
+            agentType: 'reviewer',
+            timeout: 60000, // 验收阶段固定 1 分钟
+            needsApproval: true // 验收需要确认
+        };
+    }
+    /**
+     * 构建开发阶段提示词 (增强版: 注入验收标准和用户上下文)
+     */
+    buildDevelopPrompt(task) {
+        const parts = [];
+        const isTDDMode = this.qualityConfig.tdd;
+        parts.push(`# 开发阶段 (Develop Phase)${isTDDMode ? ' - TDD GREEN 阶段' : ''}
+
+## 任务信息
+- ID: ${task.id}
+- 标题: ${task.title}
+- 描述: ${task.description}
+- 优先级: ${task.priority}
+- 质量级别: ${this.qualityConfig.level}`);
+        // TDD 模式提示
+        if (isTDDMode) {
+            parts.push(`
+## ⚠️ TDD 模式
+你已经在上一步编写了测试。现在需要:
+1. 编写最小代码使测试通过
+2. 不要过度设计
+3. 测试通过即可 (GREEN 阶段)`);
+        }
+        // 注入用户上下文
+        if (this.userContext.objective) {
+            parts.push(`
+## 整体目标
+${this.userContext.objective}`);
+        }
+        if (this.userContext.techStack && this.userContext.techStack.length > 0) {
+            parts.push(`
+## 技术栈要求
+${this.userContext.techStack.map(t => `- ${t}`).join('\n')}`);
+        }
+        // 注入验收标准
+        if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+            parts.push(`
+## 验收标准 (必须全部满足)
+${task.acceptanceCriteria.map((c, i) => `${i + 1}. [ ] ${c}`).join('\n')}`);
+        }
+        parts.push(`
+## 开发要求
+1. 根据任务描述编写代码
+2. 遵循项目代码规范
+3. 编写必要的注释
+4. 处理边界情况和错误
+5. 确保代码可编译
+
+## 编码规范 (SOLID + Clean Code)
+- **S**ingle Responsibility: 每个函数只做一件事
+- **O**pen/Closed: 对扩展开放，对修改关闭
+- **L**iskov Substitution: 子类可替换父类
+- **I**nterface Segregation: 接口要小而专注
+- **D**ependency Inversion: 依赖抽象而非具体
+
+## 代码质量标准
+- 函数长度: < 30 行
+- 参数数量: < 4 个
+- 嵌套深度: < 3 层
+- 圈复杂度: < 10
+
+## 输出要求
+完成后，在 \`.openmatrix/tasks/${task.id}/artifacts/\` 目录下创建:
+- \`result.md\` - 实现说明
+- \`changes.txt\` - 变更文件列表
+
+## 完成检查清单
+- [ ] 代码可编译
+- [ ] 边界情况已处理
+- [ ] 错误处理完善
+- [ ] 无安全隐患
+- [ ] 代码风格一致
+- [ ] 验收标准全部满足
+${isTDDMode ? '- [ ] 所有测试通过 (GREEN)' : ''}
+`);
+        return parts.join('\n');
+    }
+    /**
+     * 构建验证阶段提示词 (增强版: 严格质量门禁)
+     */
+    buildVerifyPrompt(task) {
+        const parts = [];
+        const qc = this.qualityConfig;
+        parts.push(`# 验证阶段 (Verify Phase) - 严格质量门禁
+
+## 任务信息
+- ID: ${task.id}
+- 标题: ${task.title}
+- 质量级别: ${qc.level}
+
+## 🚨 质量门禁 (Quality Gates)
+
+| 检查项 | 要求 | 失败后果 |
+|--------|------|----------|
+| 编译 | 无错误 | ❌ 阻止通过 |
+| 测试 | 全部通过 | ❌ 阻止通过 |
+| 覆盖率 | >= ${qc.minCoverage}% | ${qc.minCoverage > 0 ? '❌ 阻止通过' : '⚠️ 仅警告'} |
+| Lint | ${qc.strictLint ? '无 error' : '无严重 error'} | ${qc.strictLint ? '❌ 阻止通过' : '⚠️ 仅警告'} |
+| 安全 | 无高危漏洞 | ${qc.securityScan ? '❌ 阻止通过' : '⏭️ 跳过'} |
+| 验收标准 | 全部满足 | ❌ 阻止通过 |
+
+## 自动化验证命令
+
+### 1. 编译检查 (必须通过)
+\`\`\`bash
+npm run build
+\`\`\`
+**预期**: 无编译错误
+**失败后果**: ❌ VERIFY_FAILED
+
+### 2. 测试运行 (必须通过)
+\`\`\`bash
+npm test
+\`\`\`
+**预期**: 所有测试通过
+**失败后果**: ❌ VERIFY_FAILED
+
+### 3. 覆盖率检查
+\`\`\`bash
+npm test -- --coverage 2>/dev/null || npm run test:coverage 2>/dev/null || echo "Coverage check skipped"
+\`\`\`
+**最低覆盖率**: ${qc.minCoverage}%
+**失败后果**: ${qc.minCoverage > 0 ? '❌ VERIFY_FAILED' : '⚠️ 警告'}
+
+### 4. Lint 检查
+\`\`\`bash
+npm run lint || echo "No lint script configured"
+\`\`\`
+**要求**: ${qc.strictLint ? '无 error' : '无严重 error'}
+**失败后果**: ${qc.strictLint ? '❌ VERIFY_FAILED' : '⚠️ 警告'}
+
+### 5. 安全扫描
+${qc.securityScan ? `\`\`\`bash
+npm audit --audit-level=high || echo "Security scan skipped"
+\`\`\`
+**要求**: 无 high/critical 漏洞
+**失败后果**: ❌ VERIFY_FAILED` : '⏭️ 已禁用'}
+
+### 6. 验收标准验证`);
+        // 注入验收标准
+        if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+            parts.push(`
+逐项检查以下标准:
+${task.acceptanceCriteria.map((c, i) => `${i + 1}. [ ] ${c}`).join('\n')}
+**失败后果**: ❌ VERIFY_FAILED`);
+        }
+        else {
+            parts.push(`
+⏭️ 无验收标准定义`);
+        }
+        parts.push(`
+
+## 📊 质量报告格式
+
+在 \`.openmatrix/tasks/${task.id}/artifacts/\` 目录下创建 \`quality-report.json\`:
+
+\`\`\`json
+{
+  "taskId": "${task.id}",
+  "timestamp": "[ISO时间]",
+  "tests": {
+    "passed": 0,
+    "failed": 0,
+    "skipped": 0,
+    "coverage": 0,
+    "status": "pass|fail"
+  },
+  "build": {
+    "success": true,
+    "errors": [],
+    "status": "pass|fail"
+  },
+  "lint": {
+    "errors": 0,
+    "warnings": 0,
+    "status": "pass|fail|warning"
+  },
+  "security": {
+    "vulnerabilities": [],
+    "status": "pass|fail"
+  },
+  "acceptance": {
+    "total": ${task.acceptanceCriteria?.length || 0},
+    "met": 0,
+    "details": [],
+    "status": "pass|fail"
+  },
+  "overall": "pass|fail|warning"
+}
+\`\`\`
+
+## 最终输出
+
+✅ **所有门禁通过**:
+\`\`\`
+VERIFY_PASSED
+Quality Score: [A/B/C/D/F]
+- Tests: ✅ X/X passed, Y% coverage
+- Build: ✅ Success
+- Lint: ✅ No errors
+- Security: ✅ No vulnerabilities
+- Acceptance: ✅ N/M criteria met
+\`\`\`
+
+❌ **门禁失败**:
+\`\`\`
+VERIFY_FAILED
+Failed Gates:
+1. [检查项]: [失败原因]
+2. [检查项]: [失败原因]
+
+Fix Required:
+1. [修复建议]
+2. [修复建议]
+\`\`\`
+
+## ⚠️ 重要提示
+- **不要跳过任何检查**
+- **不要伪造通过结果**
+- 如果项目没有某个脚本，标记为 "⏭️ Skipped" 而非 "❌ Failed"
+- 所有检查结果必须基于实际命令输出
+`);
+        return parts.join('\n');
+    }
+    /**
+     * 构建验收阶段提示词 (增强版: 验收标准检查)
+     */
+    buildAcceptPrompt(task) {
+        const parts = [];
+        parts.push(`# 验收阶段 (Accept Phase)
+
+## 任务信息
+- ID: ${task.id}
+- 标题: ${task.title}
+- 描述: ${task.description}`);
+        // 注入验收标准
+        if (task.acceptanceCriteria && task.acceptanceCriteria.length > 0) {
+            parts.push(`
+## 验收标准 (必须全部满足)
+${task.acceptanceCriteria.map((c, i) => `${i + 1}. [ ] ${c}`).join('\n')}`);
+        }
+        parts.push(`
+## 验收检查清单
+- [ ] 功能演示/验证
+- [ ] 测试报告 (verify-report.md 已生成)
+- [ ] 代码审查通过
+- [ ] 文档已更新 (如需要)
+- [ ] 所有验收标准已满足
+
+## 验收流程
+
+### 1. 检查验证阶段结果
+读取 \`.openmatrix/tasks/${task.id}/artifacts/verify-report.md\`
+确认所有检查项已通过
+
+### 2. 验证验收标准
+逐项检查验收标准是否满足
+
+### 3. 最终确认
+- 确认代码可以合并
+- 确认无遗留问题
+
+## 输出要求
+在 \`.openmatrix/tasks/${task.id}/artifacts/\` 目录下创建:
+- \`accept-report.md\` - 验收报告
+
+## 结果格式
+如果验收通过，输出:
+\`\`\`
+ACCEPT_PASSED
+\`\`\`
+
+如果需要修改，输出:
+\`\`\`
+ACCEPT_NEEDS_MODIFICATION
+修改建议:
+1. [建议]
+2. [建议]
+\`\`\`
+
+如果验收失败，输出:
+\`\`\`
+ACCEPT_FAILED
+失败原因:
+1. [原因]
+\`\`\`
+`);
+        return parts.join('\n');
+    }
+    /**
+     * 处理阶段结果
+     *
+     * 在 auto 模式下:
+     * - 自动进入下一阶段，needsApproval = false
+     * - 仅在失败时暂停
+     * - 自动提交代码 (如果启用)
+     */
+    async processPhaseResult(task, phase, result) {
+        const now = new Date().toISOString();
+        if (result.success) {
+            // 更新阶段状态
+            const updates = {
+                phases: {
+                    ...task.phases,
+                    [phase]: {
+                        status: 'completed',
+                        duration: 0,
+                        completedAt: now
+                    }
+                }
+            };
+            // 设置下一阶段
+            let nextPhase;
+            // auto 模式下不需要审批，仅在 accept 阶段且非 auto 模式时需要
+            let needsApproval = false;
+            if (phase === 'develop') {
+                nextPhase = 'verify';
+                updates.phases.verify = {
+                    status: 'pending',
+                    duration: null,
+                    startedAt: now
+                };
+                updates.status = 'verify';
+            }
+            else if (phase === 'verify') {
+                nextPhase = 'accept';
+                updates.phases.accept = {
+                    status: 'pending',
+                    duration: null,
+                    startedAt: now
+                };
+                updates.status = 'accept';
+                // 仅在非 auto 模式下需要审批
+                needsApproval = !this.isAutoMode;
+            }
+            else if (phase === 'accept') {
+                updates.status = 'completed';
+            }
+            await this.stateManager.updateTask(task.id, updates);
+            // 自动提交代码
+            if (this.runId) {
+                try {
+                    const commitResult = await this.gitCommitManager.commit({
+                        taskId: task.id,
+                        taskTitle: task.title,
+                        runId: this.runId,
+                        phase,
+                        changes: [],
+                        impactScope: []
+                    });
+                    if (commitResult.success) {
+                        console.log(`✅ Git 提交成功: ${commitResult.commitHash}`);
+                    }
+                    else if (commitResult.message !== 'No changes to commit') {
+                        console.log(`⚠️ Git 提交跳过: ${commitResult.message || commitResult.error}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`❌ Git 提交失败: ${error}`);
+                }
+            }
+            return {
+                phase,
+                success: true,
+                output: result.output,
+                duration: 0,
+                artifacts: [],
+                nextPhase,
+                needsApproval
+            };
+        }
+        else {
+            // 阶段失败
+            await this.stateManager.updateTask(task.id, {
+                status: 'failed',
+                error: result.error || `${phase} phase failed`
+            });
+            return {
+                phase,
+                success: false,
+                error: result.error,
+                duration: 0,
+                artifacts: [],
+                // 失败时总是需要审批/确认
+                needsApproval: true
+            };
+        }
+    }
+    /**
+     * 检查 Build 测试结果
+     */
+    parseBuildTestResult(output) {
+        const result = {
+            compile: false,
+            staticAnalysis: false,
+            dependencies: false,
+            package: false,
+            errors: []
+        };
+        // 解析编译结果
+        if (output.includes('npm run build') && !output.includes('error')) {
+            result.compile = true;
+        }
+        // 解析 lint 结果
+        if (output.includes('npm run lint')) {
+            result.staticAnalysis = !output.includes('error') && !output.includes('warning');
+        }
+        else {
+            result.staticAnalysis = true; // 没有 lint 脚本视为通过
+        }
+        // 解析依赖检查
+        if (output.includes('npm ci') || output.includes('npm install')) {
+            result.dependencies = !output.includes('ERR!');
+        }
+        // 解析测试结果
+        if (output.includes('npm test')) {
+            result.package = output.includes('passed') || output.includes('PASS');
+        }
+        // 收集错误
+        const errorLines = output.split('\n').filter(line => line.toLowerCase().includes('error') ||
+            line.toLowerCase().includes('failed') ||
+            line.toLowerCase().includes('fail'));
+        result.errors = errorLines;
+        return result;
+    }
+    /**
+     * 解析质量报告
+     */
+    parseQualityReport(output) {
+        const result = {
+            passed: false,
+            tests: { passed: 0, failed: 0, coverage: 0 },
+            build: { success: false, errors: [] },
+            lint: { errors: 0, warnings: 0 },
+            security: { vulnerabilities: 0 },
+            acceptance: { met: 0, total: 0 }
+        };
+        // 解析测试结果
+        const testMatch = output.match(/(\d+)\s*(?:passed|passing)/i);
+        if (testMatch)
+            result.tests.passed = parseInt(testMatch[1], 10);
+        const failMatch = output.match(/(\d+)\s*(?:failed|failing)/i);
+        if (failMatch)
+            result.tests.failed = parseInt(failMatch[1], 10);
+        const coverageMatch = output.match(/(?:coverage|covered).*?(\d+)%/i);
+        if (coverageMatch)
+            result.tests.coverage = parseInt(coverageMatch[1], 10);
+        // 解析构建结果
+        result.build.success = output.includes('VERIFY_PASSED') ||
+            (output.includes('npm run build') && !output.includes('error'));
+        // 解析 Lint 结果
+        const lintErrorMatch = output.match(/(\d+)\s*error/i);
+        if (lintErrorMatch)
+            result.lint.errors = parseInt(lintErrorMatch[1], 10);
+        const lintWarnMatch = output.match(/(\d+)\s*warning/i);
+        if (lintWarnMatch)
+            result.lint.warnings = parseInt(lintWarnMatch[1], 10);
+        // 解析安全漏洞
+        const vulnMatch = output.match(/(\d+)\s*(?:vulnerabilities|vulnerable)/i);
+        if (vulnMatch)
+            result.security.vulnerabilities = parseInt(vulnMatch[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;
+        return result;
+    }
+    /**
+     * 生成质量报告 JSON
+     */
+    generateQualityReport(task, gateResult) {
+        const qc = this.qualityConfig;
+        return {
+            taskId: task.id,
+            timestamp: new Date().toISOString(),
+            tests: {
+                passed: gateResult.tests.passed,
+                failed: gateResult.tests.failed,
+                skipped: 0,
+                coverage: gateResult.tests.coverage,
+                status: gateResult.tests.failed === 0 ? 'pass' : 'fail'
+            },
+            build: {
+                success: gateResult.build.success,
+                errors: gateResult.build.errors,
+                status: gateResult.build.success ? 'pass' : 'fail'
+            },
+            lint: {
+                errors: gateResult.lint.errors,
+                warnings: gateResult.lint.warnings,
+                status: qc.strictLint && gateResult.lint.errors > 0 ? 'fail' :
+                    gateResult.lint.warnings > 0 ? 'warning' : 'pass'
+            },
+            security: {
+                vulnerabilities: [],
+                status: gateResult.security.vulnerabilities === 0 ? 'pass' : 'fail'
+            },
+            acceptance: {
+                total: task.acceptanceCriteria?.length || 0,
+                met: gateResult.acceptance.met,
+                details: [],
+                status: gateResult.acceptance.met >= (task.acceptanceCriteria?.length || 0) ? 'pass' : 'fail'
+            },
+            overall: gateResult.passed ? 'pass' : 'fail'
+        };
+    }
+    /**
+     * 获取 AgentRunner 实例
+     */
+    getAgentRunner() {
+        return this.agentRunner;
+    }
+}
+exports.PhaseExecutor = PhaseExecutor;