speccore 8.3.22 → 8.3.26

package/dist/commands/execute.js

@@ -63,6 +63,8 @@ const execution_state_1 = require("../core/execution-state");
 const git_integration_1 = require("../core/git-integration");
 const prompt_builder_1 = require("../core/prompt-builder");
 const verify_engine_1 = require("../core/verify-engine");
+const arbitration_engine_1 = require("../core/arbitration/arbitration-engine");
+const verdict_generator_1 = require("../core/arbitration/verdict-generator");
 const unified_config_1 = require("../core/unified-config");
 const pipeline_engine_1 = require("../core/pipeline-engine");
 const index_guard_1 = require("../core/index-guard");
@@ -1527,7 +1529,8 @@ async function executionVerifyLoop(tasks, iteration, options) {
     const maxRounds = 3;
     const iterDir = await (0, context_1.getIterationDir)(iteration);
     const config = await (0, unified_config_1.loadConfig)();
-    const codePath = config.code_scope?.[0] || process.cwd();
+    const projectConfig = await (0, unified_config_1.loadProjectConfig)();
+    const codePath = projectConfig.code_scope?.[0] || process.cwd();
     const absCodePath = codePath.startsWith('/') ? codePath : (0, path_1.join)(process.cwd(), codePath);
     for (const task of tasks) {
         logger_1.logger.info(`\n🔍 验证 ${task.id}...`);
@@ -1538,27 +1541,100 @@ async function executionVerifyLoop(tasks, iteration, options) {
             if (round > 1)
                 logger_1.logger.info(`   🔄 第 ${round} 轮修复...`);
             allPassed = true;
-            // ── Step 1: 质量门禁（编译→Lint→测试→依赖→安全→Spec一致性）──
-            const gate = await (0, verify_engine_1.runQualityGate)(task.id, taskCodePath, taskDir);
-            if (!gate.passed) {
-                allPassed = false;
-                logger_1.logger.warn(`   ❌ 质量门禁未通过`);
-                for (const f of gate.blockingFailed) {
-                    logger_1.logger.warn(`      ❌ ${f.name}: ${f.details}`);
-                    await (0, issue_tracker_1.logIssue)(taskDir, {
-                        type: f.name.includes('编译') || f.name.includes('测试') ? 'error' : 'technical',
-                        severity: 'critical',
-                        summary: `${f.name}: ${f.details}`,
-                        detail: `任务: ${task.id}，轮次: ${round}/3`,
-                    });
+            // ── Step 1: 契约冲突裁决 / 传统质量门禁 ──
+            const arbConfig = await (0, arbitration_engine_1.getArbitrationConfig)();
+            let testPassed = true;
+            if (!arbConfig.enabled) {
+                // 仲裁已禁用：回退到传统质量门禁
+                const gate = await (0, verify_engine_1.runQualityGate)(task.id, taskCodePath, taskDir);
+                await (0, verify_engine_1.writeVerifyReport)(gate.report, taskDir);
+                if (options.auto) {
+                    logger_1.logger.info(`   🚧 质量门禁: ${gate.passed ? '✅ 通过' : '❌ 失败'} (arbitration=off)`);
                 }
+                else {
+                    logger_1.logger.info('');
+                    logger_1.logger.info(`🚧 传统质量门禁 — ${task.id}`);
+                    logger_1.logger.info(`   ${gate.passed ? '✅ 全部通过' : `❌ ${gate.blockingFailed.length} 项阻塞性检查失败`}`);
+                }
+                if (!gate.passed) {
+                    allPassed = false;
+                }
+                const testCheck = gate.report.checks.find(c => c.name === '单元测试');
+                testPassed = !testCheck || testCheck.status !== 'fail';
             }
             else {
-                logger_1.logger.info(`   ✅ 质量门禁通过`);
+                // 仲裁已启用：执行三级裁决
+                const arbResult = await (0, arbitration_engine_1.runArbitration)(task.id, taskCodePath, taskDir, { mode: arbConfig.mode });
+                await (0, verdict_generator_1.writeArbitrationReport)(arbResult.report, taskDir);
+                if (options.auto) {
+                    // auto 模式：极简输出
+                    const totalFailed = arbResult.report.L1.failed + arbResult.report.L2.failed + arbResult.report.L3.failed;
+                    const modeLabel = arbConfig.mode === 'full' ? '' : ` [${arbConfig.mode}]`;
+                    if (totalFailed === 0) {
+                        logger_1.logger.info(`   ⚖️ 契约裁决${modeLabel}: ✅ 全部通过`);
+                    }
+                    else {
+                        logger_1.logger.info(`   ⚖️ 契约裁决${modeLabel}: ❌ L1=${arbResult.report.L1.failed} L2=${arbResult.report.L2.pending} L3=${arbResult.report.L3.pending}`);
+                    }
+                }
+                else {
+                    // 正常模式：完整输出
+                    logger_1.logger.info('');
+                    logger_1.logger.info(`⚖️  契约冲突裁决 — ${task.id}${arbConfig.mode !== 'full' ? ` [mode=${arbConfig.mode}]` : ''}`);
+                    // L1 机器契约
+                    if (arbResult.report.L1.total > 0) {
+                        logger_1.logger.info(`   ⚙️ L1 机器契约: ${arbResult.report.L1.passed}/${arbResult.report.L1.total} 通过`);
+                        if (arbResult.report.L1.failed > 0) {
+                            logger_1.logger.warn(`      ❌ ${arbResult.report.L1.failed} 项致命错误，已自动裁决驳回`);
+                            allPassed = false;
+                        }
+                    }
+                    else {
+                        logger_1.logger.info(`   ⚙️ L1 机器契约: ✅ 全部通过`);
+                    }
+                    // L2 规范契约
+                    if (arbResult.report.L2.total > 0) {
+                        logger_1.logger.info(`   🤖 L2 规范契约: ${arbResult.report.L2.passed}/${arbResult.report.L2.total} 通过, ${arbResult.report.L2.pending} 待确认`);
+                        if (arbResult.report.L2.pending > 0) {
+                            logger_1.logger.info(`      💡 ${arbResult.report.L2.pending} 项需确认修复方案（见 ARBITRATION_REPORT.md）`);
+                        }
+                        if (arbResult.report.L2.failed > 0) {
+                            allPassed = false;
+                        }
+                    }
+                    else {
+                        logger_1.logger.info(`   🤖 L2 规范契约: ✅ 全部通过`);
+                    }
+                    // L3 架构契约
+                    if (arbResult.report.L3.total > 0) {
+                        logger_1.logger.info(`   👤 L3 架构契约: ${arbResult.report.L3.passed}/${arbResult.report.L3.total} 通过, ${arbResult.report.L3.pending} 待裁决`);
+                        if (arbResult.report.L3.pending > 0) {
+                            logger_1.logger.warn(`      ⚠️ ${arbResult.report.L3.pending} 项需人工裁决`);
+                            logger_1.logger.info(`         执行: speccore verdict --list --task ${task.id}`);
+                            allPassed = false;
+                        }
+                    }
+                    else {
+                        logger_1.logger.info(`   👤 L3 架构契约: ✅ 全部通过`);
+                    }
+                }
+                if (!arbResult.canProceed) {
+                    allPassed = false;
+                    if (!options.auto) {
+                        for (const c of arbResult.report.conflicts.filter(c => c.level === 'L1' && c.status === 'resolved')) {
+                            await (0, issue_tracker_1.logIssue)(taskDir, {
+                                type: 'error',
+                                severity: 'critical',
+                                summary: `L1 契约违反: ${c.contractName}`,
+                                detail: `任务: ${task.id}，轮次: ${round}/3，${c.message}`,
+                            });
+                        }
+                    }
+                }
+                const testConflict = arbResult.report.conflicts.find(c => c.contractName === '单元测试通过');
+                testPassed = !testConflict || testConflict.status !== 'resolved';
             }
             // ── Step 2: 文档同步 — 根据单元测试结果更新 TEST.md ──
-            const testCheck = gate.report.checks.find(c => c.name === '单元测试');
-            const testPassed = testCheck?.status === 'pass';
             await (0, verify_engine_1.syncTestDocFromResults)(taskDir, testPassed);
             // ── Step 3: 检查 REVIEW.md（人工审查清单）──
             const platDirsRound = await getPlatformSubtaskDirs(taskDir);
@@ -1619,7 +1695,8 @@ async function executionVerifyLoop(tasks, iteration, options) {
             if (round < maxRounds) {
                 logger_1.logger.info(`   💡 AI 将修复未通过项。使用 speccore execute --task=${task.id} --force 重新执行代码生成`);
                 await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.needs-retry'), String(round));
-                // 输出 [SPECCORE_EXEC] 让 AI 修复
+                // 输出 [SPECCORE_EXEC] 让 AI 修复（回退到质量门禁报告）
+                const gate = await (0, verify_engine_1.runQualityGate)(task.id, taskCodePath, taskDir);
                 if (!gate.passed) {
                     await (0, verify_engine_1.outputFixTag)(gate.report, taskDir, round);
                 }
@@ -1629,29 +1706,60 @@ async function executionVerifyLoop(tasks, iteration, options) {
         if (allPassed) {
             await (0, fs_extra_1.writeFile)((0, path_1.join)(taskDir, '.verification'), 'passed');
             logger_1.logger.info(`   ✅ ${task.id} 全部检查通过，可以 speccore done`);
-            // v8.2.0+: 执行通过后检测可复用模式候选
+            // v8.3.23+: 执行通过后检测可复用模式候选（适配端平铺结构 + 自动写入）
             try {
-                const codeDirs = [
-                    (0, path_1.join)(taskDir, '10-backend'),
-                    (0, path_1.join)(taskDir, '20-frontend'),
-                    (0, path_1.join)(taskDir, 'src'),
-                ];
+                const codeDirs = await (0, pattern_detector_1.resolveCodeDirsFromTask)(taskDir);
+                if (codeDirs.length === 0) {
+                    // 无代码目录时静默跳过（代码可能在外部工程）
+                    return;
+                }
                 const candidates = await (0, pattern_detector_1.detectPatternCandidates)(codeDirs, `task:${task.id}`);
-                if (candidates.length > 0) {
+                if (candidates.length === 0)
+                    return;
+                const mode = await (0, pattern_detector_1.getPatternAutoSaveMode)();
+                const autoSaved = [];
+                const manual = [];
+                for (const c of candidates) {
+                    const result = await (0, pattern_detector_1.autoSavePattern)(c, `task:${task.id}`, mode);
+                    if (result.saved && result.path) {
+                        autoSaved.push(`${c.name} [${result.confidence}]`);
+                    }
+                    else if (!(0, pattern_detector_1.isHighConfidenceCandidate)(c) && mode === 'smart') {
+                        manual.push(`${c.name} [${c.category}]`);
+                    }
+                }
+                logger_1.logger.info('');
+                logger_1.logger.info('🧩 执行完成，检测到以下可复用模式候选:');
+                const byPlatform = (0, pattern_detector_1.groupCandidatesByPlatform)(candidates);
+                for (const [plat, list] of Object.entries(byPlatform)) {
+                    const platLabel = plat === 'shared' ? '🌐 跨端共享' : plat === 'backend' ? '⚙️ 后端' : plat === 'frontend' ? '🎨 前端' : '📦 其他';
+                    logger_1.logger.info(`   ${platLabel}:`);
+                    for (const c of list.slice(0, 2)) {
+                        logger_1.logger.info(`     • ${c.name} [${c.category}] — ${c.reason}`);
+                    }
+                    if (list.length > 2) {
+                        logger_1.logger.info(`       ... 还有 ${list.length - 2} 个`);
+                    }
+                }
+                if (autoSaved.length > 0) {
                     logger_1.logger.info('');
-                    logger_1.logger.info('🧩 执行完成，检测到以下可复用模式候选:');
-                    const byPlatform = (0, pattern_detector_1.groupCandidatesByPlatform)(candidates);
-                    for (const [plat, list] of Object.entries(byPlatform)) {
-                        const platLabel = plat === 'shared' ? '🌐 跨端共享' : plat === 'backend' ? '⚙️ 后端' : plat === 'frontend' ? '🎨 前端' : '📦 其他';
-                        logger_1.logger.info(`   ${platLabel}:`);
-                        for (const c of list.slice(0, 2)) {
-                            logger_1.logger.info(`     • ${c.name} [${c.category}] — ${c.reason}`);
-                        }
-                        if (list.length > 2) {
-                            logger_1.logger.info(`       ... 还有 ${list.length - 2} 个`);
-                        }
+                    logger_1.logger.info(`   ✅ 已自动保存 ${autoSaved.length} 个高置信度模式到 .speccore/PATTERNS/`);
+                    for (const s of autoSaved.slice(0, 3)) {
+                        logger_1.logger.info(`      • ${s}`);
                     }
-                    logger_1.logger.info(`   💡 有价值？执行 speccore pattern save --name=<模式名> --file=<文件路径>`);
+                }
+                if (manual.length > 0 && mode === 'smart') {
+                    logger_1.logger.info('');
+                    logger_1.logger.info(`   💡 以下 ${manual.length} 个候选置信度较低，建议手动确认后保存:`);
+                    for (const m of manual.slice(0, 3)) {
+                        logger_1.logger.info(`      • ${m}`);
+                    }
+                    logger_1.logger.info('      命令: speccore pattern save --name=<模式名> --file=<文件路径>');
+                }
+                if (mode === 'off') {
+                    logger_1.logger.info('');
+                    logger_1.logger.info('   💡 检测到可复用模式，自动保存已关闭。如需保存请执行:');
+                    logger_1.logger.info('      speccore pattern save --name=<模式名> --file=<文件路径>');
                 }
             }
             catch { /* 静默失败 */ }