soloforge 1.1.38 → 1.1.42

package/dist/engine/pipeline/orchestrate_single_artifact.js

@@ -0,0 +1,772 @@
+/**
+ * 四层编排共享内核 — 单产物操作的统一编排函数。
+ *
+ * 三种场景共用此内核：
+ * - 场景 A：sf_command（[sf] 审查/修改/生成/迭代 某某产物）
+ * - 场景 B：sf_single_artifact（结构化参数快捷入口）
+ * - 场景 C：CLI review/modify 命令
+ *
+ * 四层编排：
+ *   Layer 1 — 模板层：从模板 frontmatter 读取 companion_rules / companion_gates / consumes
+ *   Layer 2 — 引擎层：解析 consumes → 加载上游产物内容
+ *   Layer 3 — 上下文引擎：运行 requires_context 视图
+ *   Layer 4 — 规则层 + 门禁层：injectCompanions 按 operation 过滤加载
+ *   Layer 5 — 范围约束：allowed_paths + read_only_paths
+ *
+ * 按方案 SoloForge-模板体系四层职责分离方案.md Section 2.4 实现。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+import { ensureCanonicalPaths, findArtifactPathsByKind, findTemplatePath, hasArtifactAlias, } from "./artifact_resolver.js";
+import { findArtifactAlias } from "./artifact_aliases.js";
+import { injectCompanions } from "../context_engine/companion_injector.js";
+// ── 类型定义 ──
+/** OperationType → injectCompanions operation 映射 */
+const OPERATION_TO_COMPANION = {
+    extract: "execute", // 生成/创建 → 加载全部规则
+    review: "review", // 审查 → 加载 :review + :check
+    fix: "execute", // 修改/修复 → 加载全部规则
+    iterate: "execute", // 迭代/优化 → 加载全部规则
+};
+// ── 辅助函数 ──
+/**
+ * 加载输入路径内容。
+ * 文件 → 读取文本；目录 → 列出子文件（.md/.yaml）+ 非文本文件清单。
+ */
+function loadInputContents(relPaths, base) {
+    const result = {};
+    for (const rel of relPaths) {
+        const abs = path.join(base, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        try {
+            const stat = fs.statSync(abs);
+            if (stat.isDirectory()) {
+                const entries = fs.readdirSync(abs, {
+                    recursive: true,
+                    withFileTypes: false,
+                });
+                // 读取文本文件
+                for (const entry of entries) {
+                    if (typeof entry === "string" &&
+                        (entry.endsWith(".md") || entry.endsWith(".yaml") || entry.endsWith(".yml"))) {
+                        try {
+                            result[path.join(rel, entry)] = fs.readFileSync(path.join(abs, entry), "utf-8");
+                        }
+                        catch {
+                            /* 跳过 */
+                        }
+                    }
+                }
+                // 非文本文件清单
+                const nonText = entries.filter((e) => typeof e === "string" &&
+                    !e.endsWith(".md") &&
+                    !e.endsWith(".yaml") &&
+                    !e.endsWith(".yml"));
+                if (nonText.length > 0) {
+                    result[rel] = `[目录，包含文件: ${nonText.join(", ")}]`;
+                }
+            }
+            else {
+                result[rel] = fs.readFileSync(abs, "utf-8");
+            }
+        }
+        catch {
+            /* 读取失败跳过 */
+        }
+    }
+    return result;
+}
+/**
+ * 为 review/fix 操作构建上游对比指令。
+ *
+ * 审查必须用上游产物内容校验一致性和遗漏，
+ * 否则偏差会传导至后续架构、编码、验证阶段。
+ */
+function buildUpstreamComparisonDirective(operation, targetName, upstreamInputs) {
+    // extract 不需要上游对比；review/fix/iterate 都需要（iterate 循环中第一轮审查必须对比上游）
+    if (operation === "extract")
+        return "";
+    const loadedInputs = upstreamInputs.filter((i) => !i.missing && Object.keys(i.contents).length > 0);
+    if (loadedInputs.length === 0)
+        return "";
+    const inputList = loadedInputs.map((i) => {
+        const contentKeys = Object.keys(i.contents);
+        return `- 「${i.ref}」(${contentKeys.length} 个文件: ${contentKeys.slice(0, 3).join(", ")}${contentKeys.length > 3 ? " ..." : ""})`;
+    }).join("\n");
+    if (operation === "review") {
+        return [
+            "## 上游对比要求（强制）",
+            "",
+            `审查「${targetName}」时，必须逐项与以下上游产物对比，检查一致性和遗漏：`,
+            inputList,
+            "",
+            "对比维度：",
+            "1. **完整性**：上游提到的每个功能点/实体/流程，目标产物是否都有覆盖？",
+            "2. **一致性**：目标产物中的数据/描述/逻辑是否与上游一致？",
+            "3. **无遗漏**：是否存在上游有但目标产物完全未提及的内容？",
+            "",
+            "对每个偏差项标注：❌ 不一致 / ⚠️ 遗漏 / ✅ 一致",
+        ].join("\n");
+    }
+    // fix 操作
+    return [
+        "## 修复约束（强制）",
+        "",
+        `修复「${targetName}」时，必须参考以下上游产物确保修复后一致：`,
+        inputList,
+        "",
+        "修复原则：",
+        "1. 仅修正已标注的偏差项，不改动已正确的部分",
+        "2. 修复后必须与上游产物内容一致",
+        "3. 不得引入上游中不存在的新内容",
+    ].join("\n");
+}
+/**
+ * 为 iterate 操作构建自动迭代循环指令。
+ *
+ * 核心流程：review → 发现问题 → fix → 再 review → 直到全部通过。
+ * 这不是内核的自动化循环（内核不运行 AI），而是在 injection_text 中
+ * 告诉 AI 遵循的迭代协议。
+ */
+export function buildIterateDirective(operation, targetName, targetPaths, gateNames) {
+    // extract 是首次创建，不需要迭代循环；review/fix/iterate 都需要
+    if (operation === "extract")
+        return "";
+    const maxIterations = 5;
+    const gatesSection = gateNames.length > 0
+        ? gateNames.map((g) => `「${g}」`).join("、")
+        : "结构完整性检查";
+    return [
+        "## 对抗性审查-修复协议（强制）",
+        "",
+        `你正在处理「${targetName}」。你是严格的质量审查员，你的职责是发现问题，不是放行。`,
+        "",
+        "### 审查原则（违反任何一条等同审查失败）",
+        "",
+        "1. 默认立场：每一条门禁检查项都是 ❌，除非你能引用产物中的具体内容作为证据",
+        "2. 无证据的 ✅ 等同于 ❌ — 你必须引用章节名或行号 + 原文",
+        "3. 你不可以批量标记 ✅ — 每条必须独立检查并附证据",
+        "4. 你不可以跳过任何检查项",
+        "",
+        "### 执行流程",
+        "",
+        `阶段 A: 对抗性审查`,
+        `  对每一条门禁检查项（${gatesSection}）：`,
+        "    1. 读取产物文件的相关部分",
+        "    2. 引用具体内容（章节名/行号 + 引文）",
+        "    3. 标注 ❌ + 问题描述 + 修复方案，或 ✅ + 证据（引用原文）",
+        "  → 产出完整审查报告",
+        "",
+        "阶段 B: 强制修复",
+        "  对审查报告中的每一个 ❌ 和 ⚠️ 项：",
+        "    1. 按修复方案逐项修复",
+        `    2. 修复后重写完整产物到: ${targetPaths.join(" 或 ")}`,
+        "    3. 不允许只报告不修复",
+        "",
+        "阶段 C: 独立重审（强制）",
+        "  修复完成后，你必须再次调用 [sf] 审查 工具进行独立重审。",
+        "  这不是可选的——这是强制性的质量保证步骤。",
+        "  独立重审会以全新视角重新加载门禁规则，确保审查不受修复过程的偏见影响。",
+        `  如果重审发现问题 → 回到阶段 B 继续修复（最多 ${maxIterations} 轮）。`,
+        "",
+        "### 终止条件",
+        "",
+        "1. 审查报告零 ❌/⚠️ 项 → 结束，报告「审查通过」",
+        `2. 达到最大 ${maxIterations} 轮 → 结束，报告剩余未修复项`,
+        "",
+        "### 输出要求",
+        "",
+        `- 每轮修复后必须将完整产物写入: ${targetPaths.join(" 或 ")}`,
+        "- 最终输出审查通过的产物内容",
+        "- 附上迭代摘要：修复了哪些问题、经过几轮",
+        "",
+        "⚠️ 绝对不允许只输出审查报告就停下来。必须看到产物被修复并通过审查。",
+        "⚠️ 绝对不允许无证据地批量标记 ✅。",
+    ].join("\n");
+}
+/**
+ * 构建 extract 操作的质量纪律指令。
+ *
+ * extract 是首次创建产物，无迭代循环也无上游对比。
+ * 此函数注入创建质量纪律，防止 AI 产出空洞内容。
+ */
+export function buildExtractQualityDirective(operation, targetName, targetPaths, gateNames) {
+    // 仅 extract 操作需要此指令
+    if (operation !== "extract")
+        return "";
+    const gatesSection = gateNames.length > 0
+        ? `门禁检查：${gateNames.map((g) => `「${g}」`).join("、")}`
+        : "结构完整性检查";
+    return [
+        "## 创建质量纪律（强制）",
+        "",
+        `你正在创建「${targetName}」。以下纪律不可违反：`,
+        "",
+        "### 禁止空洞（anti-laziness 基线）",
+        "1. 每个模板章节必须填写完整内容，禁止留空、使用占位符（如「待补充」「TBD」）",
+        "2. 必须穷尽上游产物中引用的所有实体/流程/字段 — 上游提到的每个名词都必须在产物中有对应描述",
+        "3. 无上游内容的章节必须基于模板要求自行补全，不可以「上游未提供」为由留空",
+        "",
+        "### 完整性自检（产出后必须执行）",
+        `产出完成后，逐条核对以下${gatesSection}：`,
+        "- 对每条门禁：引用你产物中的具体内容作为证据",
+        "- 如果任何门禁无法提供证据 → 立即补充内容，不要停下来问用户",
+        "- 自检不通过 → 修复 → 重新自检（最多 5 轮）",
+        "",
+        "### 输出要求",
+        `- 完整产物写入: ${targetPaths.join(" 或 ")}`,
+        "- 附自检报告：每条门禁 ✅ + 证据 或 ❌ + 修复说明",
+    ].join("\n");
+}
+// ── 核心函数 ──
+/**
+ * 四层编排共享内核 — 单产物操作统一入口。
+ *
+ * @param params.kind - 产物类型（ArtifactKind）
+ * @param params.operation - 操作类型（extract/review/fix/iterate）
+ * @param params.projectPath - 项目根路径
+ * @returns 编排结果（OrchestrateResult）
+ */
+export async function orchestrateSingleArtifact(params) {
+    const { kind, operation, projectPath, original_command } = params;
+    // ── Step 0: 获取 alias 元数据 ──
+    const alias = findArtifactAlias(kind);
+    if (!alias) {
+        return {
+            mode: "single_artifact",
+            status: "error",
+            error: `未注册的产物类型: "${kind}"`,
+            target_kind: kind,
+            target_name: kind,
+            target_paths: [],
+        };
+    }
+    // ── Step 0b: 确保产物文件名与 canonical_paths 一致，再查找 ──
+    ensureCanonicalPaths(kind, projectPath);
+    const existingPaths = findArtifactPathsByKind(kind, projectPath);
+    // ── Layer 1: 模板层 ──
+    const templatePath = alias.template
+        ? findTemplatePath(alias.template, projectPath)
+        : null;
+    if (!templatePath) {
+        return {
+            mode: "single_artifact",
+            status: "no_template",
+            error: alias.template
+                ? `找不到模板文件: "${alias.template}"`
+                : `产物类型「${alias.defaultName}」无模板定义，不支持自动编排`,
+            target_kind: kind,
+            target_name: alias.defaultName,
+            target_paths: existingPaths,
+        };
+    }
+    const templateRaw = fs.readFileSync(templatePath, "utf-8");
+    const templateParsed = matter(templateRaw);
+    const fm = (templateParsed.data ?? {});
+    // 解析 frontmatter 字段 — 支持 structured YAML 和 旧字符串格式
+    const fmConsumes = fm.consumes ?? [];
+    const fmCompanionRules = fm.companion_rules;
+    const fmCompanionGates = fm.companion_gates;
+    const fmRequiresContext = fm.requires_context ?? [];
+    // 老系统管线专属规则：companion_rules_legacy 仅在 systemType="老系统" 时合并
+    if (params.systemType === "老系统") {
+        const legacyRules = fm.companion_rules_legacy;
+        if (legacyRules && legacyRules.length > 0) {
+            fmCompanionRules.push(...legacyRules);
+        }
+    }
+    // ── Layer 2: Consumes 解析（上游输入加载） ──
+    const upstreamInputs = [];
+    for (const ref of fmConsumes) {
+        // 跳过 mechanism ID（mc- 前缀）——不是产物 kind
+        if (typeof ref === "string" && ref.startsWith("mc-")) {
+            continue;
+        }
+        // 策略 1：已注册的 artifact kind → 查 canonical_paths
+        if (hasArtifactAlias(ref)) {
+            ensureCanonicalPaths(ref, projectPath);
+            const resolvedPaths = findArtifactPathsByKind(ref, projectPath);
+            const contents = loadInputContents(resolvedPaths, projectPath);
+            const missing = resolvedPaths.length === 0;
+            upstreamInputs.push({ ref, resolved_kind: ref, paths: resolvedPaths, contents, missing });
+            continue;
+        }
+        // 策略 2：非 kind 路径兜底（如 docs/api/openapi.yaml）
+        const fullPath = path.join(projectPath, ref);
+        if (fs.existsSync(fullPath)) {
+            const contents = loadInputContents([ref], projectPath);
+            upstreamInputs.push({ ref, paths: [ref], contents, missing: false });
+        }
+        else {
+            // 非核心路径缺失不阻断（如 openapi.yaml 可能还未生成）
+            upstreamInputs.push({ ref, paths: [], contents: {}, missing: false });
+        }
+    }
+    // ── Consumes OR 替代：缺失的 kind 查 consumes_alternatives ──
+    // 当模板 frontmatter 声明了 consumes_alternatives（如 prototype_spec → data_lineage_diagram），
+    // 缺失的 kind 会尝试用替代产物补充
+    const fmAlternatives = fm.consumes_alternatives;
+    if (fmAlternatives) {
+        for (let i = 0; i < upstreamInputs.length; i++) {
+            const input = upstreamInputs[i];
+            if (!input.missing || !input.resolved_kind)
+                continue;
+            const alternatives = fmAlternatives[input.ref] ?? fmAlternatives[input.resolved_kind];
+            if (!alternatives || alternatives.length === 0)
+                continue;
+            for (const altKind of alternatives) {
+                if (!hasArtifactAlias(altKind))
+                    continue;
+                ensureCanonicalPaths(altKind, projectPath);
+                const altPaths = findArtifactPathsByKind(altKind, projectPath);
+                if (altPaths.length > 0) {
+                    const altContents = loadInputContents(altPaths, projectPath);
+                    upstreamInputs[i] = {
+                        ref: `${input.ref}(替代:${altKind})`,
+                        resolved_kind: altKind,
+                        paths: altPaths,
+                        contents: altContents,
+                        missing: false,
+                    };
+                    break;
+                }
+            }
+        }
+    }
+    // ── 缺失上游检测 ──
+    const missingInputs = upstreamInputs.filter((i) => i.missing);
+    const availableInputs = upstreamInputs.filter((i) => !i.missing);
+    if (missingInputs.length > 0) {
+        const missingWithTemplates = missingInputs.map((input) => {
+            const inputAlias = input.resolved_kind ? findArtifactAlias(input.resolved_kind) : undefined;
+            const templatePathForMissing = inputAlias?.template
+                ? findTemplatePath(inputAlias.template, projectPath)
+                : null;
+            return {
+                ref: input.ref,
+                kind: input.resolved_kind,
+                template_name: inputAlias?.template,
+                template_path: templatePathForMissing,
+                available_upstream: availableInputs.map((ai) => ({
+                    ref: ai.ref,
+                    kind: ai.resolved_kind,
+                    paths: ai.paths,
+                    missing: ai.missing,
+                })),
+                message: `上游产物「${inputAlias?.defaultName ?? input.ref}」缺失`,
+            };
+        });
+        return {
+            mode: "single_artifact",
+            status: "missing_upstream",
+            target_kind: kind,
+            target_name: alias.defaultName,
+            target_paths: existingPaths,
+            missing_inputs: missingWithTemplates,
+            available_inputs: availableInputs.map((ai) => ({
+                ref: ai.ref,
+                kind: ai.resolved_kind,
+                paths: ai.paths,
+                missing: ai.missing,
+            })),
+            suggested_action: {
+                produce_first: `请先读取模板产出缺失的上游产物，已有上游内容已附在 available_inputs 中`,
+                then_resume: original_command
+                    ? `上游产物就绪后，重新执行: ${original_command}`
+                    : `上游产物就绪后，重新执行操作`,
+            },
+            original_task: {
+                kind,
+                description: alias.defaultName,
+                command: original_command ?? "",
+            },
+        };
+    }
+    // ── 非 extract 操作 + 产物不存在 → 引导补产 ──
+    // review/fix/iterate 要求产物已存在，不存在时应引导用户先 extract
+    if (operation !== "extract" && existingPaths.length === 0) {
+        return {
+            mode: "single_artifact",
+            status: "missing_upstream",
+            target_kind: kind,
+            target_name: alias.defaultName,
+            target_paths: [],
+            missing_inputs: [{
+                    ref: kind,
+                    kind,
+                    template_name: alias.template,
+                    template_path: alias.template ? findTemplatePath(alias.template, projectPath) : null,
+                    available_upstream: availableInputs.map((ai) => ({
+                        ref: ai.ref,
+                        kind: ai.resolved_kind,
+                        paths: ai.paths,
+                        missing: ai.missing,
+                    })),
+                    message: `目标产物「${alias.defaultName}」尚未创建，${operation} 操作要求产物已存在`,
+                }],
+            available_inputs: availableInputs.map((ai) => ({
+                ref: ai.ref,
+                kind: ai.resolved_kind,
+                paths: ai.paths,
+                missing: ai.missing,
+            })),
+            suggested_action: {
+                produce_first: `请先使用 extract 操作创建「${alias.defaultName}」，模板和上游内容已准备就绪`,
+                then_resume: original_command
+                    ? `产物创建完成后，重新执行: ${original_command}`
+                    : `产物创建完成后，重新执行 ${operation} 操作`,
+            },
+            original_task: {
+                kind,
+                description: alias.defaultName,
+                command: original_command ?? "",
+            },
+        };
+    }
+    // ── 目标路径解析 ──
+    // 合并已存在路径 + 缺失的精确 canonical_paths（存在则覆盖，不存在则新建）
+    // 通配符路径由 expandGlob 展开到 existingPaths，不再额外添加 pattern
+    const targetPaths = [...existingPaths];
+    for (const cp of alias.canonical_paths) {
+        // 跳过通配符路径（已由 expandGlob 展开）
+        if (cp.includes("*") || cp.includes("**"))
+            continue;
+        if (!targetPaths.includes(cp)) {
+            targetPaths.push(cp);
+        }
+    }
+    // ── Layer 3: 上下文引擎 ──
+    let contextAnalysis;
+    if (fmRequiresContext.length > 0) {
+        try {
+            const { resolveContext } = await import("../context_engine/index.js");
+            const { getView, dispatchView } = await import("../context_engine/view_registry.js");
+            for (const viewName of fmRequiresContext) {
+                const resolved = resolveContext({ view: viewName, source: "auto" }, null, // single_artifact 无管线阶段
+                { scopeRoots: targetPaths });
+                if (getView(resolved.view)) {
+                    const vr = await dispatchView(resolved.view, projectPath, {
+                        targets: resolved.targets,
+                        scope: resolved.scope,
+                    });
+                    if (!contextAnalysis)
+                        contextAnalysis = vr.summary;
+                    else
+                        contextAnalysis += "\n\n" + vr.summary;
+                }
+            }
+        }
+        catch {
+            // 上下文引擎失败不阻断
+        }
+    }
+    // ── Layer 4 + 5: 规则层 + 门禁层 ──
+    const companionOperation = OPERATION_TO_COMPANION[operation];
+    const companionResult = injectCompanions({
+        baseDir: projectPath,
+        companion_rules: fmCompanionRules,
+        companion_gates: fmCompanionGates,
+        operation: companionOperation,
+        systemType: params.systemType,
+    });
+    // ── Layer 6: 范围约束 ──
+    const consumedPaths = upstreamInputs.flatMap((input) => input.paths);
+    // ── 注入上游对比指令（review/fix 操作必须对比上游） ──
+    const upstreamComparisonDirective = buildUpstreamComparisonDirective(operation, alias.defaultName, upstreamInputs);
+    // ── 注入迭代循环指令（iterate 操作的自循环协议） ──
+    const iterateDirective = buildIterateDirective(operation, alias.defaultName, targetPaths, companionResult.gates.map((g) => g.name));
+    // ── 注入创建质量纪律（extract 操作的 anti-laziness） ──
+    const extractQualityDirective = buildExtractQualityDirective(operation, alias.defaultName, targetPaths, companionResult.gates.map((g) => g.name));
+    const finalInjectionText = [
+        upstreamComparisonDirective,
+        companionResult.injection_text,
+        extractQualityDirective,
+        iterateDirective,
+    ].filter(Boolean).join("\n\n");
+    // ── 构建结果 ──
+    return {
+        mode: "single_artifact",
+        status: "ready",
+        operation,
+        // 产物信息
+        target_kind: kind,
+        target_name: alias.defaultName,
+        target_paths: targetPaths,
+        suggested_target_paths: undefined,
+        // 模板
+        template_name: alias.template,
+        template_body: templateParsed.content,
+        // Layer 2: 上游输入
+        upstream_inputs: upstreamInputs.map((input) => ({
+            ref: input.ref,
+            kind: input.resolved_kind,
+            paths: input.paths,
+            missing: input.missing,
+            contents: input.contents,
+        })),
+        // Layer 3: 引擎分析
+        context_analysis: contextAnalysis,
+        // Layer 4 + 5: 规则与门禁
+        rules: companionResult.rules,
+        missing_rules: companionResult.missing_rules,
+        gates: companionResult.gates,
+        missing_gates: companionResult.missing_gates,
+        injection_text: finalInjectionText,
+        // Layer 6: 范围约束
+        scope: {
+            allowed_paths: targetPaths,
+            read_only_paths: consumedPaths,
+        },
+    };
+}
+/** 将单产物状态映射为阶段级摘要状态 */
+function mapSingleStatus(status) {
+    if (status === "ready")
+        return "ready";
+    if (status === "missing_upstream" || status === "need_target_info")
+        return "missing_upstream";
+    if (status === "no_template")
+        return "no_template";
+    return "missing_target";
+}
+/** 构建阶段级审查 injection_text */
+export function buildStageReviewInjection(stage, results, gates) {
+    const ready = results.filter((r) => r.status === "ready");
+    const skipped = results.filter((r) => r.status !== "ready");
+    const lines = [];
+    // 标题
+    lines.push(`# 阶段级审查 —「${stage}」`);
+    lines.push("");
+    // 审查范围
+    lines.push("## 审查范围");
+    lines.push("");
+    if (ready.length > 0) {
+        lines.push("### 可审查产物");
+        for (const item of ready) {
+            lines.push(`- **${item.name}** (${item.kind}): ${item.paths.join(", ")}`);
+        }
+        lines.push("");
+    }
+    if (skipped.length > 0) {
+        lines.push("### 跳过的产物（缺失上游或无模板）");
+        for (const item of skipped) {
+            lines.push(`- ~~${item.name}~~ (${item.status}): ${item.error ?? item.status}`);
+        }
+        lines.push("");
+    }
+    // 审查顺序
+    lines.push("## 阶段级审查-修复循环协议（强制）");
+    lines.push("");
+    lines.push(`你现在必须执行「${stage}」阶段全部 ${ready.length} 个产物的审查-修复循环，禁止中途停下来。`);
+    lines.push("");
+    lines.push("### 审查顺序");
+    for (let i = 0; i < ready.length; i++) {
+        lines.push(`${i + 1}. 审查「${ready[i].name}」`);
+    }
+    lines.push("");
+    // ── 审查原则（对抗性框架 — 同改造 3 统一原则）──
+    lines.push("### 审查原则（违反任何一条等同审查失败）");
+    lines.push("");
+    lines.push("1. **默认立场**：每一条门禁检查项都是 ❌，除非你能引用产物中的具体内容作为证据");
+    lines.push("2. **无证据的 ✅ 等同于 ❌** — 你必须引用章节名或行号 + 原文");
+    lines.push("3. **禁止批量标记 ✅** — 每条必须独立检查并附证据");
+    lines.push("4. **禁止跳过任何检查项** — 包括跨产物一致性检查");
+    lines.push("");
+    // ── 门禁 ──
+    const uniqueGates = [...new Map(gates.map((g) => [g.name, g])).values()];
+    if (uniqueGates.length > 0) {
+        lines.push("### 质量标准");
+        lines.push("");
+        lines.push(`门禁检查：${uniqueGates.map((g) => `「${g.name}」`).join("、")} — 全部通过才可结束`);
+        lines.push("");
+    }
+    // ── 每个产物的专属审查规则 ──
+    for (const item of ready) {
+        if (item.injection_text) {
+            lines.push(`## 「${item.name}」专属审查规则`);
+            lines.push("");
+            lines.push(item.injection_text);
+            lines.push("");
+        }
+    }
+    // ── 执行流程（三阶段：对抗审查 → 强制修复 → 独立重审）──
+    lines.push("### 执行流程");
+    lines.push("");
+    // 阶段 A: 对抗性审查
+    lines.push("**阶段 A: 对抗性审查**");
+    lines.push("");
+    lines.push(`对「${stage}」阶段全部 ${ready.length} 个产物执行逐个审查：`);
+    for (const item of ready) {
+        lines.push(`- 读取「${item.name}」产物的相关部分`);
+    }
+    lines.push("对每一条门禁检查项：");
+    lines.push("  1. 引用产物具体内容（章节名/行号 + 引文）");
+    lines.push("  2. 标注 ❌ + 问题描述 + 修复方案，或 ✅ + 证据（引用原文）");
+    lines.push("→ 产出完整审查报告");
+    lines.push("");
+    // 跨产物一致性（多产物时额外要求）
+    if (ready.length > 1) {
+        lines.push("**阶段 A-2: 跨产物一致性校验（强制）**");
+        lines.push("");
+        lines.push(`除逐个审查外，你还必须检查「${stage}」阶段内各产物之间的一致性：`);
+        lines.push("");
+        lines.push("1. **术语一致**：同一实体/概念在不同产物中的命名是否一致？引用两个产物中的原文作为证据");
+        lines.push("2. **引用一致**：产物 A 引用的设计决策/实体在产物 B 中是否有对应描述？引用对应段落");
+        lines.push("3. **覆盖完整**：架构设计文档中的每个模块是否都有对应的数据库表和 API 端点？逐一列出映射关系");
+        lines.push("4. **无冲突**：不同产物之间是否存在互相矛盾的描述？引用矛盾处原文");
+        lines.push("");
+        lines.push("⚠️ 跨产物一致性检查也适用审查原则：无证据的 ✅ 等同于 ❌。必须引用两个产物中的对应内容。");
+        lines.push("");
+    }
+    // 阶段 B: 强制修复
+    lines.push("**阶段 B: 强制修复**");
+    lines.push("");
+    lines.push("对审查报告中的每一个 ❌ 和 ⚠️ 项：");
+    lines.push("  1. 按修复方案逐项修复");
+    lines.push("  2. 修复后重写完整产物到对应文件");
+    lines.push("  3. 不允许只报告不修复");
+    lines.push("");
+    // 阶段 C: 独立重审
+    lines.push("**阶段 C: 独立重审（强制）**");
+    lines.push("");
+    lines.push("修复完成后，你必须再次调用 `[sf] 审查 ${stage}` 工具进行独立重审。");
+    lines.push("这不是可选的——这是强制性的质量保证步骤。");
+    lines.push("独立重审会以全新视角重新加载门禁规则，确保审查不受修复过程的偏见影响。");
+    lines.push("如果重审发现问题 → 回到阶段 B 继续修复（最多 5 轮）。");
+    lines.push("");
+    // 终止条件
+    lines.push("### 终止条件");
+    lines.push("");
+    lines.push("1. 全部产物审查报告零 ❌/⚠️ 项（含跨产物一致性） → 结束，报告「审查通过」");
+    lines.push("2. 达到最大 5 轮 → 结束，报告剩余未修复项");
+    lines.push("");
+    // 输出要求
+    lines.push("### 输出要求");
+    lines.push("");
+    lines.push("- 每轮修复后必须将完整产物写入对应文件");
+    lines.push("- 每条门禁检查项必须附证据：✅ + 引用原文 或 ❌ + 修复说明");
+    lines.push("- 最终输出阶段级审查通过的确认 + 迭代摘要");
+    lines.push("");
+    lines.push("⚠️ 绝对不允许只输出审查报告就停下来。必须看到所有产物被修复并通过审查。");
+    lines.push("⚠️ 绝对不允许无证据地批量标记 ✅。");
+    lines.push("⚠️ 独立重审是强制步骤，不是可选建议。");
+    return lines.join("\n");
+}
+/**
+ * 阶段级审查编排 — 审查指定阶段的全部产出。
+ *
+ * 对该阶段的所有注册产物逐一调用 orchestrateSingleArtifact(review)，
+ * 聚合结果为统一的 StageReviewResult。
+ */
+export async function orchestrateStageReview(params) {
+    const { stage, projectPath, original_command, systemType } = params;
+    const { getArtifactsByStage } = await import("./artifact_aliases.js");
+    const aliases = getArtifactsByStage(stage, systemType);
+    if (aliases.length === 0) {
+        return {
+            mode: "stage_review",
+            status: "no_artifacts",
+            stage,
+            artifact_results: [],
+            injection_text: `阶段「${stage}」没有可审查的产物。`,
+        };
+    }
+    // 逐一编排
+    const artifactResults = [];
+    const allReady = [];
+    const partialIssues = [];
+    const allGates = [];
+    const allAllowedPaths = [];
+    const allReadOnlyPaths = [];
+    for (const alias of aliases) {
+        let singleResult = await orchestrateSingleArtifact({
+            kind: alias.kind,
+            operation: "review",
+            projectPath,
+            original_command,
+            systemType,
+        });
+        // 阶段级审查：产物不存在（status=missing_upstream 且仅自身缺失）
+        // → 回退到 extract 模式创建+审查
+        // 条件：仅当缺失项只有产物本身（上游全部就绪），且 extract 产出非空 injection_text
+        const isOnlySelfMissing = singleResult.status === "missing_upstream"
+            && singleResult.missing_inputs?.length === 1
+            && singleResult.missing_inputs[0].ref === alias.kind
+            && singleResult.missing_inputs[0].message?.includes("尚未创建");
+        if (isOnlySelfMissing) {
+            // 额外守卫：
+            // 1. 根产物（consumes=[]）在空项目中无上游内容可创建，跳过回退
+            // 2. extract 必须产出非空 injection_text 才采纳
+            const hasUpstreamContent = singleResult.upstream_inputs
+                && singleResult.upstream_inputs.length > 0;
+            if (hasUpstreamContent) {
+                const extractResult = await orchestrateSingleArtifact({
+                    kind: alias.kind,
+                    operation: "extract",
+                    projectPath,
+                    original_command,
+                    systemType,
+                });
+                if (extractResult.status === "ready" && extractResult.injection_text) {
+                    singleResult = {
+                        ...extractResult,
+                        injection_text: `# 阶段审查 — 创建并审查「${alias.defaultName}」\n\n`
+                            + `此产物尚未存在，阶段级审查要求你先创建再审查。\n\n`
+                            + `---\n\n${extractResult.injection_text}`,
+                    };
+                }
+            }
+        }
+        const entry = {
+            kind: alias.kind,
+            name: alias.defaultName,
+            paths: singleResult.target_paths,
+            status: mapSingleStatus(singleResult.status),
+            injection_text: singleResult.injection_text,
+            upstream_inputs: singleResult.upstream_inputs,
+            template_body: singleResult.template_body,
+            rules: singleResult.rules,
+            gates: singleResult.gates,
+            missing_inputs: singleResult.missing_inputs,
+            error: singleResult.error,
+        };
+        artifactResults.push(entry);
+        // 收集 scope
+        if (singleResult.scope) {
+            allAllowedPaths.push(...singleResult.scope.allowed_paths);
+            allReadOnlyPaths.push(...singleResult.scope.read_only_paths);
+        }
+        // 收集门禁
+        if (singleResult.gates)
+            allGates.push(...singleResult.gates);
+        // 统计状态
+        if (singleResult.status === "ready") {
+            allReady.push(alias.defaultName);
+        }
+        else {
+            partialIssues.push(`「${alias.defaultName}」: ${singleResult.status}`);
+        }
+    }
+    // 构建聚合 injection_text
+    const injectionText = buildStageReviewInjection(stage, artifactResults, allGates);
+    // 总体状态
+    const overallStatus = partialIssues.length === 0
+        ? "ready"
+        : allReady.length > 0
+            ? "partial"
+            : "no_artifacts";
+    return {
+        mode: "stage_review",
+        status: overallStatus,
+        stage,
+        artifact_results: artifactResults,
+        injection_text: injectionText,
+        scope: {
+            allowed_paths: [...new Set(allAllowedPaths)],
+            read_only_paths: [...new Set(allReadOnlyPaths)],
+        },
+    };
+}
+//# sourceMappingURL=orchestrate_single_artifact.js.map