speccore 8.3.189 → 8.3.191

package/dist/commands/run.js

@@ -0,0 +1,619 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+/**
+ * run — 端到端流水线执行入口
+ * 唯一执行入口：13 阶段全自动流水线（--auto 默认，--from/--to 指定起止，--demo 放宽闸口 A/B）
+ */
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const context_1 = require("../core/context");
+const questions_1 = require("../core/questions");
+const handoff_generator_1 = require("../core/handoff-generator");
+const unified_config_1 = require("../core/unified-config");
+async function hasFeatureDirs(iterDir) {
+    try {
+        const featuresDir = (0, path_1.join)(iterDir, '010-requirements', 'features');
+        const entries = await (0, fs_extra_1.readdir)(featuresDir, { withFileTypes: true });
+        return entries.some(e => e.isDirectory() && !e.name.startsWith('.'));
+    }
+    catch {
+        return false;
+    }
+}
+async function runCommand(options) {
+    await autoPipeline(options);
+}
+async function autoPipeline(options) {
+    const PIPELINE_PHASES = [
+        // ── 需求入口（二选一：req-doc 一句话需求 / doc2spec 导入文档）──
+        { key: 'req-doc', cmd: 'speccore req-doc', layer: 'prepare' },
+        { key: 'doc2spec', cmd: 'speccore doc2spec', layer: 'prepare' },
+        // ── 结构化：切分功能单元（1→N，独立于澄清）──
+        { key: 'split-units', cmd: 'speccore doc2spec --split', layer: 'prepare' },
+        // ── 主流程（分析→校验→任务化→计划→执行→验证→部署→合并→归档→导出）──
+        { key: 'analyze', cmd: 'speccore analyze', layer: 'main' },
+        { key: 'validate', cmd: 'speccore validate', layer: 'main' },
+        { key: 'taskify', cmd: 'speccore iteration split', layer: 'main' },
+        { key: 'plan', cmd: 'speccore plan', layer: 'main' },
+        { key: 'execute', cmd: 'speccore execute', layer: 'main' },
+        { key: 'verify', cmd: 'speccore verify', layer: 'main' },
+        { key: 'pipeline', cmd: 'speccore pipeline', layer: 'main' },
+        { key: 'pr', cmd: 'speccore pr', layer: 'main' },
+        { key: 'done', cmd: 'speccore done', layer: 'main' },
+        { key: 'spec2doc', cmd: 'speccore spec2doc', layer: 'main' },
+    ];
+    // v8.3.190+: 内置预设流水线（起止点对，覆盖常见业务操作）
+    // 默认流水线为 develop（分析→验证，代码完成即止）；pr/done/spec2doc 为独立收尾操作，
+    // 需「提交代码/归档/导出」时用 deliver/import/docs preset 或单独跑命令。
+    const PRESETS = {
+        full: { from: 'req-doc', to: 'spec2doc', desc: '全流程：需求→导出（含收尾）' },
+        import: { from: 'doc2spec', to: 'pr', desc: '导入需求→合并请求' },
+        analyze: { from: 'analyze', to: 'validate', desc: '只分析校验' },
+        spec: { from: 'doc2spec', to: 'taskify', desc: '导入需求→任务化（生成 Spec，看效果）' },
+        develop: { from: 'analyze', to: 'verify', desc: '分析→验证（默认，代码+验证完成）' },
+        deliver: { from: 'execute', to: 'pr', desc: '执行→提交代码' },
+        deploy: { from: 'analyze', to: 'pipeline', desc: '分析→部署验证' },
+        docs: { from: 'analyze', to: 'spec2doc', desc: '分析→文档导出' },
+    };
+    // v8.3.184+: review 闸口（功能开发质量底线）——阶段执行前触发，软停等待宿主 AI 确认
+    // A: taskify 前（Spec 定稿）、B: verify 前（代码 review）、C: pipeline 前（部署前确认，永不跳过）
+    const GATES = {
+        taskify: { id: 'A', title: 'Spec 定稿', hint: '请 review 生成的 Spec（功能单元/端覆盖/验收标准），确认后继续', resumeFrom: 'taskify' },
+        verify: { id: 'B', title: '代码 review', hint: '请 review 生成的代码（重点扫 AI 标记的低置信点 / .issues.md / .deviations），确认后继续', resumeFrom: 'verify' },
+        pipeline: { id: 'C', title: '部署前确认', hint: '即将部署到环境（destructive 操作），确认后才执行', resumeFrom: 'pipeline' },
+    };
+    const iteration = await (0, context_1.getDefaultIteration)(options.iteration);
+    if (!iteration) {
+        logger_1.logger.info('🤖 Auto-pipeline: 未找到迭代，先初始化...');
+        (0, child_process_1.execSync)('speccore init', { stdio: 'inherit' });
+        return;
+    }
+    const iterDir = `Iteration-${iteration}`;
+    logger_1.logger.info(`\n🤖 Auto-pipeline: ${iteration}\n`);
+    // v8.3.190+: 读取 optional_steps（off 跳过）+ pipelines（命名流水线）配置
+    let optionalSteps = {};
+    let pipelinesConfig = {};
+    try {
+        const { config } = await (0, unified_config_1.loadConfigWithMeta)();
+        optionalSteps = (config.settings.optional_steps || {});
+        pipelinesConfig = (config.settings.pipelines || {});
+    }
+    catch { /* 配置读取失败用默认 */ }
+    const phaseResults = [];
+    const pipelineStart = Date.now();
+    // ── 解析流水线范围（优先级：--auto-steps > --from/--to > --preset/默认 > full）──
+    let startIdx = 0;
+    let endIdx = PIPELINE_PHASES.length - 1;
+    // 1. 解析预设/自定义流水线（--preset > 配置 default > 内置 full）
+    const presetName = options.preset || pipelinesConfig.default || 'full';
+    let presetFrom;
+    let presetTo;
+    if (PRESETS[presetName]) {
+        presetFrom = PRESETS[presetName].from;
+        presetTo = PRESETS[presetName].to;
+        if (options.preset)
+            logger_1.logger.info(`🎯 预设流水线 [${presetName}]: ${presetFrom} → ${presetTo}（${PRESETS[presetName].desc}）\n`);
+    }
+    else if (pipelinesConfig.custom?.[presetName]) {
+        const steps = pipelinesConfig.custom[presetName].split(',').map(s => s.trim()).filter(Boolean);
+        if (steps.length > 0) {
+            presetFrom = steps[0];
+            presetTo = steps[steps.length - 1];
+            logger_1.logger.info(`🎯 自定义流水线 [${presetName}]: ${presetFrom} → ${presetTo}\n`);
+        }
+    }
+    else if (presetName !== 'full') {
+        logger_1.logger.warn(`⚠️ 未知流水线 "${presetName}"，回退到 full`);
+        presetFrom = PRESETS.full.from;
+        presetTo = PRESETS.full.to;
+    }
+    // 2. 应用 preset 起止点（--from/--to 会覆盖）
+    if (presetFrom) {
+        const fi = PIPELINE_PHASES.findIndex(p => p.key === presetFrom);
+        if (fi >= 0)
+            startIdx = fi;
+    }
+    if (presetTo) {
+        const ti = PIPELINE_PHASES.findIndex(p => p.key === presetTo);
+        if (ti >= 0)
+            endIdx = ti;
+    }
+    // 3. --from/--to 显式覆盖
+    if (options.from) {
+        const fi = PIPELINE_PHASES.findIndex(p => p.key === options.from);
+        if (fi >= 0)
+            startIdx = fi;
+        else {
+            logger_1.logger.error(`未知阶段: ${options.from}`);
+            return;
+        }
+    }
+    if (options.to) {
+        const ti = PIPELINE_PHASES.findIndex(p => p.key === options.to);
+        if (ti >= 0)
+            endIdx = ti;
+        else {
+            logger_1.logger.error(`未知阶段: ${options.to}`);
+            return;
+        }
+    }
+    // 4. --auto-steps 最高优先级（指定连续步骤）
+    if (options.autoSteps) {
+        const stepKeys = options.autoSteps.split(',').map(s => s.trim());
+        const indices = stepKeys.map(k => PIPELINE_PHASES.findIndex(p => p.key === k));
+        if (indices.some(i => i < 0)) {
+            const unknown = stepKeys.filter(k => !PIPELINE_PHASES.find(p => p.key === k));
+            logger_1.logger.error(`未知阶段: ${unknown.join(', ')}`);
+            logger_1.logger.info(`可用: ${PIPELINE_PHASES.map(p => p.key).join(', ')}`);
+            return;
+        }
+        // 验证连续性
+        const sorted = [...indices].sort((a, b) => a - b);
+        for (let i = 1; i < sorted.length; i++) {
+            if (sorted[i] !== sorted[i - 1] + 1) {
+                logger_1.logger.error(`auto-steps 必须连续！${stepKeys.join(',')} 在流水线中不连续`);
+                logger_1.logger.info(`流水线顺序: ${PIPELINE_PHASES.map(p => p.key).join(' → ')}`);
+                return;
+            }
+        }
+        startIdx = sorted[0];
+        endIdx = sorted[sorted.length - 1];
+        logger_1.logger.info(`🎯 自动步骤: ${stepKeys.join(' → ')}\n`);
+    }
+    // ── 逐步执行 ──
+    let pausedGate = null;
+    let prevLayer = '';
+    for (let i = startIdx; i <= endIdx; i++) {
+        const phase = PIPELINE_PHASES[i];
+        // v8.3.189+: 分层展示（准备层 / 主流程）
+        if (phase.layer && phase.layer !== prevLayer) {
+            prevLayer = phase.layer;
+            logger_1.logger.info(phase.layer === 'prepare'
+                ? '\n────────── 🏗️ 准备层（初始化 + 需求入口）──────────'
+                : '\n────────── 🚀 主流程（分析→拆分→执行→验证→部署→归档→导出）──────────');
+        }
+        // v8.3.184+: review 闸口软停（功能开发质量底线）
+        const gate = GATES[phase.key];
+        if (gate) {
+            const skipGate = options.demo && gate.id !== 'C'; // demo 跳过 A/B，C 永不跳过
+            if (!skipGate) {
+                logger_1.logger.warn(`\n🛑 [SPECCORE_GATE_${gate.id}] ${gate.title}`);
+                logger_1.logger.warn(`   ${gate.hint}`);
+                logger_1.logger.warn(`   确认后继续: speccore run --auto --from ${gate.resumeFrom} -I ${iteration}\n`);
+                pausedGate = gate.id;
+                break; // 软停，等宿主 AI 确认后 --from 继续
+            }
+        }
+        logger_1.logger.info(`━━━ [${i - startIdx + 1}/${endIdx - startIdx + 1}] ${phase.key} ━━━`);
+        const phaseStart = Date.now();
+        let phaseStatus = 'success';
+        let phaseMessage = '完成';
+        let phaseQuestions = [];
+        try {
+            switch (phase.key) {
+                case 'req-doc': {
+                    // v8.3.184+: 一句话需求 → PRD（口语化需求入口，与 doc2spec 二选一）
+                    const reqDoc = (0, path_1.join)(iterDir, '010-requirements', 'REQUIREMENT.md');
+                    const hasFeatures = await hasFeatureDirs(iterDir);
+                    if ((await (0, fs_extra_1.pathExists)(reqDoc)) || hasFeatures) {
+                        logger_1.logger.info('  ✅ 需求已存在，跳过 req-doc');
+                    }
+                    else if (options.demand) {
+                        (0, child_process_1.execSync)(`speccore req-doc "${options.demand}" --to ${iteration}`, { stdio: 'inherit' });
+                    }
+                    else {
+                        logger_1.logger.info('  ℹ️ 未提供一句话需求，跳过 req-doc（走 doc2spec 导入文档）');
+                    }
+                    break;
+                }
+                case 'doc2spec': {
+                    const reqDoc = (0, path_1.join)(iterDir, '010-requirements', 'REQUIREMENT.md');
+                    const hasFeatures = await hasFeatureDirs(iterDir);
+                    if (!(await (0, fs_extra_1.pathExists)(reqDoc)) && !hasFeatures) {
+                        logger_1.logger.info('  ℹ️ 未找到需求文档，跳过（请手动 doc2spec）');
+                    }
+                    else {
+                        // 检查需求文档是否有实质内容（不是空文件）
+                        let hasContent = false;
+                        try {
+                            const { readFile: rf } = require('fs-extra');
+                            const content = await rf(reqDoc, 'utf-8');
+                            hasContent = content.replace(/^#+\s.*$/gm, '').replace(/\s/g, '').length > 50;
+                        }
+                        catch { }
+                        if (hasContent) {
+                            logger_1.logger.info('  ✅ 需求已导入且有实质内容，跳过');
+                        }
+                        else {
+                            logger_1.logger.info('  ⚠️ 需求文档存在但内容为空，请手动 doc2spec 导入');
+                        }
+                    }
+                    break;
+                }
+                case 'split-units': {
+                    // v8.3.191+: 切分功能单元（结构化，独立于澄清）
+                    // 已切分（features/ 非空）则跳过；否则对 converted/ 和 REQUIREMENT.md 文档切分
+                    const featuresDir = (0, path_1.join)(iterDir, '010-requirements', 'features');
+                    let hasFeatures = false;
+                    try {
+                        const entries = await (0, fs_extra_1.readdir)(featuresDir, { withFileTypes: true });
+                        hasFeatures = entries.some((e) => e.isDirectory() && !e.name.startsWith('.'));
+                    }
+                    catch { }
+                    if (hasFeatures) {
+                        logger_1.logger.info('  ✅ 功能单元已切分，跳过');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '功能单元已切分';
+                        break;
+                    }
+                    // 收集待切分的需求文档（converted/ + REQUIREMENT.md）
+                    const docsToSplit = [];
+                    const convDir = (0, path_1.join)(iterDir, '010-requirements', 'converted');
+                    if (await (0, fs_extra_1.pathExists)(convDir)) {
+                        const files = await (0, fs_extra_1.readdir)(convDir);
+                        for (const f of files.filter((f) => f.endsWith('.md')))
+                            docsToSplit.push((0, path_1.join)(convDir, f));
+                    }
+                    const reqRoot = (0, path_1.join)(iterDir, '010-requirements', 'REQUIREMENT.md');
+                    if (await (0, fs_extra_1.pathExists)(reqRoot))
+                        docsToSplit.push(reqRoot);
+                    if (docsToSplit.length === 0) {
+                        logger_1.logger.info('  ℹ️ 无需求文档可切分，跳过');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '无需求文档可切分';
+                        break;
+                    }
+                    const { splitDocumentToUnits } = await Promise.resolve().then(() => __importStar(require('./doc2spec')));
+                    let written = 0;
+                    for (const doc of docsToSplit) {
+                        try {
+                            await splitDocumentToUnits(iterDir, doc, '', (0, path_1.basename)(doc));
+                            written++;
+                        }
+                        catch (e) {
+                            logger_1.logger.warn(`  ⚠️ 切分失败: ${(0, path_1.basename)(doc)} — ${e?.message || e}`);
+                        }
+                    }
+                    logger_1.logger.info(`  🔪 切分功能单元完成: ${written}/${docsToSplit.length} 个文档`);
+                    break;
+                }
+                case 'analyze': {
+                    const analysis = (0, path_1.join)(iterDir, '020-specs', 'ANALYSIS.md');
+                    const techSpec = (0, path_1.join)(iterDir, '020-specs', 'ANALYSIS.md');
+                    let needsAnalysis = !(await (0, fs_extra_1.pathExists)(analysis));
+                    let needsSpecs = false;
+                    if (!needsAnalysis) {
+                        try {
+                            const { readFile: rf } = require('fs-extra');
+                            const techContent = await rf(techSpec, 'utf-8');
+                            const meaningful = techContent.replace(/_待填充_|_待补充_|\|\s*\|/g, '').replace(/\s/g, '');
+                            needsSpecs = meaningful.length < 50;
+                        }
+                        catch {
+                            needsSpecs = true;
+                        }
+                    }
+                    if (needsAnalysis || needsSpecs) {
+                        (0, child_process_1.execSync)(`speccore analyze --auto -I ${iteration}`, { stdio: 'inherit' });
+                    }
+                    else {
+                        logger_1.logger.info('  ✅ 分析已完成，跳过');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '分析已完成，跳过';
+                    }
+                    // v7.4.0+: CLARIFY_REPORT 质量检查
+                    const clarifyPath = (0, path_1.join)(iterDir, '010-requirements', 'CLARIFY_REPORT.md');
+                    if (await (0, fs_extra_1.pathExists)(clarifyPath)) {
+                        try {
+                            const clarifyContent = await (0, fs_extra_1.readFile)(clarifyPath, 'utf-8');
+                            const lowScoreMatch = clarifyContent.match(/总分[：:]\s*(\d+)/);
+                            if (lowScoreMatch) {
+                                const score = parseInt(lowScoreMatch[1]);
+                                if (score < 60) {
+                                    logger_1.logger.warn(`  ⚠️ CLARIFY_REPORT 质量评分偏低: ${score}/100`);
+                                    logger_1.logger.warn(`     建议重新澄清需求或手动补充后再继续`);
+                                    phaseStatus = 'warning';
+                                    phaseMessage = `CLARIFY_REPORT 质量评分 ${score}/100，建议重新澄清`;
+                                    phaseQuestions.push(`需求澄清质量评分 ${score}/100，低于 60 分基线`);
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                    break;
+                }
+                case 'validate': {
+                    // v8.3.184+: Spec 质量门禁（analyze 后校验完整性/一致性，不通过不进入 split）
+                    const analysis = (0, path_1.join)(iterDir, '020-specs', 'ANALYSIS.md');
+                    if (await (0, fs_extra_1.pathExists)(analysis)) {
+                        (0, child_process_1.execSync)(`speccore validate --iteration=${iteration}`, { stdio: 'inherit' });
+                    }
+                    else {
+                        logger_1.logger.info('  ⏭️ 无 Spec 可校验，跳过 validate');
+                    }
+                    break;
+                }
+                case 'taskify': {
+                    let hasTasks = false;
+                    try {
+                        const entries = await (0, fs_extra_1.readdir)((0, path_1.join)(iterDir, '030-tasks'), { withFileTypes: true });
+                        hasTasks = entries.some((e) => e.isDirectory() && e.name.startsWith('Task-'));
+                    }
+                    catch { }
+                    if (!hasTasks) {
+                        (0, child_process_1.execSync)(`speccore iteration split -i ${iteration} --force`, { stdio: 'inherit' });
+                    }
+                    else {
+                        logger_1.logger.info('  ✅ 任务已拆分，跳过');
+                    }
+                    break;
+                }
+                case 'plan': {
+                    // v8.3.190+: 单任务跳过 plan（无需调度计划，直接 execute）；多任务才列计划
+                    let taskCount = 0;
+                    try {
+                        const { readdir: rd3 } = require('fs-extra');
+                        const tasksDir = (0, path_1.join)(iterDir, '030-tasks');
+                        if (await (0, fs_extra_1.pathExists)(tasksDir)) {
+                            const entries = await rd3(tasksDir, { withFileTypes: true });
+                            taskCount = entries.filter((e) => e.isDirectory() && e.name.startsWith('Task-')).length;
+                        }
+                    }
+                    catch { }
+                    if (taskCount <= 1) {
+                        logger_1.logger.info(`  ⏭️ 仅 ${taskCount} 个任务，跳过 plan（单任务无需调度计划）`);
+                        phaseStatus = 'skipped';
+                        phaseMessage = '单任务跳过 plan';
+                        break;
+                    }
+                    // v6.91.1+: 检查是否已有计划，避免重复生成
+                    const plansDir = (0, path_1.join)(iterDir, '000-overview', 'plans');
+                    let hasPlan = false;
+                    try {
+                        const { readdir: rd2, pathExists: pe2 } = require('fs-extra');
+                        if (await pe2(plansDir)) {
+                            const entries = await rd2(plansDir);
+                            hasPlan = entries.some((e) => e.endsWith('.md'));
+                        }
+                    }
+                    catch { }
+                    if (hasPlan) {
+                        logger_1.logger.info('  ✅ 执行计划已存在，跳过');
+                    }
+                    else {
+                        (0, child_process_1.execSync)(`speccore plan -i ${iteration} --force`, { stdio: 'inherit' });
+                    }
+                    break;
+                }
+                case 'execute': {
+                    // v6.91.1+: 检查是否还有 pending 任务
+                    let hasPending = false;
+                    try {
+                        const { scanTasks } = await Promise.resolve().then(() => __importStar(require('../core/state')));
+                        const tasks = await scanTasks(iteration);
+                        hasPending = tasks.some(t => t.status === 'pending');
+                    }
+                    catch { }
+                    if (!hasPending) {
+                        logger_1.logger.info('  ✅ 所有任务已完成，跳过 execute');
+                    }
+                    else {
+                        (0, child_process_1.execSync)(`speccore execute --auto -i ${iteration}`, { stdio: 'inherit' });
+                    }
+                    break;
+                }
+                case 'verify': {
+                    if (optionalSteps['verify'] === 'off') {
+                        logger_1.logger.info('  ⏭️ 已配置跳过（optional_steps.verify = off）');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '已配置跳过';
+                        break;
+                    }
+                    // v8.3.184+: 验证（execute 后，编译+Lint+测试+ui 截图，只报告不阻断）
+                    let hasPendingV = false;
+                    try {
+                        const { scanTasks } = await Promise.resolve().then(() => __importStar(require('../core/state')));
+                        const tasks = await scanTasks(iteration);
+                        hasPendingV = tasks.some(t => t.status === 'pending');
+                    }
+                    catch { }
+                    if (hasPendingV) {
+                        logger_1.logger.info('  ⏭️ 还有 pending 任务，跳过 verify');
+                    }
+                    else {
+                        (0, child_process_1.execSync)(`speccore verify`, { stdio: 'inherit' });
+                    }
+                    break;
+                }
+                case 'pipeline': {
+                    if (optionalSteps['pipeline'] === 'off') {
+                        logger_1.logger.info('  ⏭️ 已配置跳过（optional_steps.pipeline = off）');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '已配置跳过';
+                        break;
+                    }
+                    // v8.3.184+: 部署（闸口 C 在阶段前已软停，确认后才到这）
+                    (0, child_process_1.execSync)(`speccore pipeline --all`, { stdio: 'inherit' });
+                    break;
+                }
+                case 'pr': {
+                    if (optionalSteps['pr'] === 'off') {
+                        logger_1.logger.info('  ⏭️ 已配置跳过（optional_steps.pr = off）');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '已配置跳过';
+                        break;
+                    }
+                    // v6.91.1+: 检查是否有未提交的代码变更
+                    let hasChanges = false;
+                    try {
+                        const { execSync: es2 } = await Promise.resolve().then(() => __importStar(require('child_process')));
+                        const gitStatus = es2('git status --short', { encoding: 'utf-8', cwd: process.cwd() });
+                        hasChanges = gitStatus.trim().length > 0;
+                    }
+                    catch { }
+                    if (!hasChanges) {
+                        logger_1.logger.info('  ✅ 没有未提交的变更，跳过 pr');
+                    }
+                    else {
+                        (0, child_process_1.execSync)(`speccore pr -i ${iteration} --force`, { stdio: 'inherit' });
+                    }
+                    break;
+                }
+                case 'done': {
+                    if (optionalSteps['done'] === 'off') {
+                        logger_1.logger.info('  ⏭️ 已配置跳过（optional_steps.done = off）');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '已配置跳过';
+                        break;
+                    }
+                    // v6.91.1+: 检查是否已归档
+                    const retroPath = (0, path_1.join)(iterDir, '000-overview', 'RETRO.md');
+                    if (await (0, fs_extra_1.pathExists)(retroPath)) {
+                        logger_1.logger.info('  ✅ 已生成复盘报告，跳过 done');
+                    }
+                    else {
+                        (0, child_process_1.execSync)(`speccore done --all -i ${iteration}`, { stdio: 'inherit' });
+                    }
+                    break;
+                }
+                case 'spec2doc': {
+                    if (optionalSteps['spec2doc'] === 'off') {
+                        logger_1.logger.info('  ⏭️ 已配置跳过（optional_steps.spec2doc = off）');
+                        phaseStatus = 'skipped';
+                        phaseMessage = '已配置跳过';
+                        break;
+                    }
+                    (0, child_process_1.execSync)(`speccore spec2doc -i ${iteration}`, { stdio: 'inherit' });
+                    break;
+                }
+            } // end switch
+        }
+        catch (err) {
+            phaseStatus = 'failed';
+            phaseMessage = err?.message?.slice(0, 100) || '执行失败';
+            logger_1.logger.error(`  ❌ ${phase.key} 失败: ${phaseMessage}`);
+        }
+        // v7.4.0+: 每个阶段执行后收集疑问
+        try {
+            const qFiles = await (0, questions_1.collectQuestionFiles)();
+            for (const qf of qFiles) {
+                if (qf.includes(`-${phase.key}-`)) {
+                    phaseQuestions.push(qf.split('/').pop() || qf);
+                }
+            }
+        }
+        catch { }
+        phaseResults.push({
+            key: phase.key,
+            status: phaseStatus,
+            message: phaseMessage,
+            questions: phaseQuestions,
+            duration: Math.round((Date.now() - phaseStart) / 1000),
+        });
+        // v8.3.187+: 阶段交接摘要（generateHandoff）——关键阶段成功后生成精简传递摘要，
+        // 完整产物存文件、传递摘要只给下一阶段 AI 看，控制跨阶段上下文大小。
+        // 13 阶段流水线 → 6 阶段 handoff 映射：verify 对应 review 闸口。
+        if (phaseStatus === 'success') {
+            const handoffMap = {
+                analyze: ['analyze', 'taskify'],
+                taskify: ['taskify', 'plan'],
+                plan: ['plan', 'execute'],
+                execute: ['execute', 'review'],
+                verify: ['review', 'done'],
+            };
+            const handoff = handoffMap[phase.key];
+            if (handoff) {
+                try {
+                    const handoffPath = await (0, handoff_generator_1.generateHandoff)(handoff[0], handoff[1], iteration);
+                    logger_1.logger.info(`  📋 阶段交接摘要: ${handoffPath}`);
+                }
+                catch (err) {
+                    logger_1.logger.debug(`  交接摘要生成跳过: ${err.message}`);
+                }
+            }
+        }
+        logger_1.logger.info('');
+    }
+    // v7.4.0+: 生成 Pipeline 总结报告
+    const totalDuration = Math.round((Date.now() - pipelineStart) / 1000);
+    const reportDir = (0, path_1.join)(iterDir, '000-overview');
+    await (0, fs_extra_1.ensureDir)(reportDir);
+    const reportPath = (0, path_1.join)(reportDir, 'PIPELINE_REPORT.md');
+    const now = new Date().toLocaleString('zh-CN');
+    let report = `# Pipeline 执行报告\n\n`;
+    report += `> 迭代: ${iteration} | 执行时间: ${now} | 总耗时: ${totalDuration}s\n`;
+    report += `> 执行范围: ${PIPELINE_PHASES.slice(startIdx, endIdx + 1).map(p => p.key).join(' → ')}\n\n`;
+    report += `## 阶段执行结果\n\n`;
+    report += `| 阶段 | 状态 | 耗时 | 说明 |\n`;
+    report += `| :--- | :--- | :--- | :--- |\n`;
+    for (const pr of phaseResults) {
+        const icon = pr.status === 'success' ? '✅' : pr.status === 'skipped' ? '⏭️' : pr.status === 'warning' ? '⚠️' : '❌';
+        report += `| ${pr.key} | ${icon} ${pr.status} | ${pr.duration}s | ${pr.message} |\n`;
+    }
+    // 汇总所有疑问
+    const allQuestions = phaseResults.filter(pr => pr.questions.length > 0);
+    if (allQuestions.length > 0) {
+        report += `\n## 疑问清单\n\n`;
+        for (const pr of allQuestions) {
+            report += `### ${pr.key} 阶段\n\n`;
+            for (const q of pr.questions) {
+                report += `- ${q}\n`;
+            }
+        }
+    }
+    // 失败项汇总
+    const failedPhases = phaseResults.filter(pr => pr.status === 'failed');
+    if (failedPhases.length > 0) {
+        report += `\n## 失败项需要处理\n\n`;
+        for (const fp of failedPhases) {
+            report += `- **${fp.key}**: ${fp.message}\n`;
+        }
+    }
+    report += `\n---\n> 报告自动生成 by speccore run auto-pipeline\n`;
+    await (0, fs_extra_1.writeFile)(reportPath, report, 'utf-8');
+    if (pausedGate) {
+        logger_1.logger.warn(`\n🛑 Pipeline 已暂停在闸口 ${pausedGate}（完成至 ${phaseResults.map(p => p.key).join(' → ')}）`);
+        logger_1.logger.warn(`   确认后继续: speccore run --auto --from ${GATES[Object.keys(GATES).find(k => GATES[k].id === pausedGate)].resumeFrom} -I ${iteration}\n`);
+    }
+    else {
+        logger_1.logger.success(`\n✅ Pipeline 完成: ${PIPELINE_PHASES.slice(startIdx, endIdx + 1).map(p => p.key).join(' → ')}`);
+    }
+    logger_1.logger.info(`📊 执行报告 → ${reportPath}\n`);
+}
+//# sourceMappingURL=run.js.map