sdd-flow-kit 1.3.6 → 1.3.12

package/dist/core/prdSemanticDiff.js

@@ -0,0 +1,365 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVerifiableSignals = extractVerifiableSignals;
+exports.classifyPrdAtom = classifyPrdAtom;
+exports.atomRequiresAutomatedTest = atomRequiresAutomatedTest;
+exports.findSourceFiles = findSourceFiles;
+exports.findAllTestFiles = findAllTestFiles;
+exports.buildCodeCorpus = buildCodeCorpus;
+exports.searchSignalInCorpus = searchSignalInCorpus;
+exports.parseEvidenceRefs = parseEvidenceRefs;
+exports.verifyEvidenceRefs = verifyEvidenceRefs;
+exports.runPrdSemanticDiff = runPrdSemanticDiff;
+exports.renderSemanticDiffReportMarkdown = renderSemanticDiffReportMarkdown;
+exports.writeSemanticDiffArtifacts = writeSemanticDiffArtifacts;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("./fs");
+const SOURCE_EXT = /\.(vue|tsx?|jsx?|json|css|less|scss)$/i;
+const TEST_EXT = /\.(spec|test)\.(t|j)sx?$/i;
+const E2E_DIR_RE = /(^|\/)(e2e|playwright)(\/|$)/i;
+const UI_KEYWORDS = /按钮|toast|提示|文案|placeholder|tooltip|列|字段|筛选项|弹窗|对话框|表单|输入框|下拉|标签页|tab|列表|导出|导入|审核|禁用|必填|校验|message\.|getByText|getByRole/i;
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", "coverage", "openspec"]);
+/** 从 PRD 文本提取可机械比对的字面量（引号内文案、toast 等） */
+function extractVerifiableSignals(text) {
+    var _a;
+    const signals = [];
+    const patterns = [
+        /[「『]([^」』]{2,120})[」』]/g,
+        /"([^"]{2,120})"/g,
+        /'([^']{2,120})'/g,
+        /`([^`]{2,120})`/g,
+    ];
+    for (const re of patterns) {
+        for (const m of text.matchAll(re)) {
+            const s = ((_a = m[1]) !== null && _a !== void 0 ? _a : "").trim();
+            if (s.length >= 2)
+                signals.push(s);
+        }
+    }
+    return [...new Set(signals)];
+}
+function classifyPrdAtom(atom) {
+    const signals = extractVerifiableSignals(atom.text);
+    if (signals.length > 0)
+        return "ui-verifiable";
+    if (UI_KEYWORDS.test(atom.text) && atom.text.length >= 6)
+        return "behavior-verifiable";
+    if (atom.kind === "heading")
+        return "structural";
+    if (atom.text.length < 12)
+        return "structural";
+    return "narrative";
+}
+function atomRequiresAutomatedTest(classification, signals) {
+    return classification === "ui-verifiable" || classification === "behavior-verifiable" || signals.length > 0;
+}
+async function walkDir(dir, filter, out) {
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        if (SKIP_DIRS.has(ent.name))
+            continue;
+        const full = path_1.default.join(dir, ent.name);
+        if (ent.isDirectory()) {
+            await walkDir(full, filter, out);
+        }
+        else if (filter.test(ent.name)) {
+            out.push(full);
+        }
+    }
+}
+async function findSourceFiles(pkgRoot) {
+    const roots = ["src", "frontend/src", "app", "pages", "components", "lib"];
+    const files = [];
+    for (const r of roots) {
+        await walkDir(path_1.default.join(pkgRoot, r), SOURCE_EXT, files);
+    }
+    return [...new Set(files)];
+}
+async function findAllTestFiles(pkgRoot) {
+    const roots = ["e2e", "tests", "test", "__tests__", "playwright", "src", "frontend/src"];
+    const files = [];
+    for (const r of roots) {
+        await walkDir(path_1.default.join(pkgRoot, r), TEST_EXT, files);
+    }
+    return [...new Set(files)];
+}
+async function buildCodeCorpus(pkgRoot) {
+    const sourceFiles = await findSourceFiles(pkgRoot);
+    const testFiles = await findAllTestFiles(pkgRoot);
+    const all = [...new Set([...sourceFiles, ...testFiles])];
+    const entries = [];
+    for (const file of all) {
+        const content = await (0, fs_1.readFileIfExists)(file);
+        if (content === null)
+            continue;
+        const rel = path_1.default.relative(pkgRoot, file).replace(/\\/g, "/");
+        entries.push({
+            file,
+            rel,
+            content,
+            lines: content.split("\n"),
+            isTest: TEST_EXT.test(file),
+            isE2e: E2E_DIR_RE.test(rel),
+        });
+    }
+    return entries;
+}
+function searchSignalInCorpus(corpus, signal) {
+    var _a;
+    const hits = [];
+    if (signal.length < 2)
+        return hits;
+    for (const entry of corpus) {
+        const idx = entry.content.indexOf(signal);
+        if (idx === -1)
+            continue;
+        const line = entry.content.slice(0, idx).split("\n").length;
+        const snippet = ((_a = entry.lines[line - 1]) !== null && _a !== void 0 ? _a : "").trim().slice(0, 200);
+        hits.push({ file: entry.rel, line, snippet });
+        if (hits.length >= 5)
+            break;
+    }
+    return hits;
+}
+/** 解析 08 报告证据列中的 file:line */
+function parseEvidenceRefs(evidence) {
+    const refs = [];
+    const re = /([A-Za-z0-9_./@-]+\.(?:vue|tsx?|jsx?|spec\.tsx?|test\.tsx?)):(\d+)/g;
+    for (const m of evidence.matchAll(re)) {
+        refs.push({ rel: m[1].replace(/^\.\//, ""), line: Number(m[2]) });
+    }
+    return refs;
+}
+async function verifyEvidenceRefs(pkgRoot, evidence, signals) {
+    var _a;
+    const refs = parseEvidenceRefs(evidence);
+    if (refs.length === 0) {
+        return { ok: false, detail: "证据中未解析到 file:line 路径" };
+    }
+    for (const ref of refs) {
+        const abs = path_1.default.join(pkgRoot, ref.rel);
+        const content = await (0, fs_1.readFileIfExists)(abs);
+        if (content === null) {
+            return { ok: false, detail: `证据路径不存在: ${ref.rel}` };
+        }
+        const lines = content.split("\n");
+        const lineText = (_a = lines[ref.line - 1]) !== null && _a !== void 0 ? _a : "";
+        if (!lineText.trim()) {
+            return { ok: false, detail: `${ref.rel}:${ref.line} 为空行` };
+        }
+        if (signals.length > 0) {
+            const anySignalOnLine = signals.some((s) => lineText.includes(s) || evidence.includes(s));
+            const anySignalInFile = signals.some((s) => content.includes(s));
+            if (!anySignalOnLine && !anySignalInFile) {
+                return {
+                    ok: false,
+                    detail: `${ref.rel}:${ref.line} 未包含 PRD 字面量「${signals[0]}」等可核对内容`,
+                };
+            }
+        }
+    }
+    return { ok: true, detail: "证据路径与字面量可核对" };
+}
+function hasTestCoverageForAtom(atomId, signals, testCorpus) {
+    let hasTest = false;
+    let hasE2e = false;
+    for (const entry of testCorpus) {
+        const hasId = entry.content.includes(atomId) || entry.content.includes(`[${atomId}]`);
+        const hasSignal = signals.some((s) => s.length >= 4 && entry.content.includes(s));
+        if (hasId || hasSignal) {
+            hasTest = true;
+            if (entry.isE2e)
+                hasE2e = true;
+        }
+    }
+    return { hasTest, hasE2e };
+}
+function reconcileStatusWithReport(semanticStatus, verdict, classification, signals) {
+    if (!verdict)
+        return { consistent: false, detail: "08 报告无此行" };
+    if (verdict === "一致") {
+        if (semanticStatus === "matched" || semanticStatus === "unverifiable") {
+            return { consistent: true, detail: "08 一致且语义匹配" };
+        }
+        return {
+            consistent: false,
+            detail: `08 标「一致」但脚本 diff=${semanticStatus}`,
+        };
+    }
+    if (verdict === "不一致-按PRD修复") {
+        if (semanticStatus === "missing_in_code" || semanticStatus === "partial") {
+            return { consistent: true, detail: "08 不一致与脚本 diff 吻合" };
+        }
+        return {
+            consistent: false,
+            detail: `08 标「不一致」但脚本 diff=${semanticStatus}`,
+        };
+    }
+    if (verdict === "待人工确认") {
+        if (semanticStatus === "unverifiable" ||
+            (classification === "behavior-verifiable" && signals.length === 0)) {
+            return { consistent: true, detail: "待人工确认与不可机械验证一致" };
+        }
+        if (semanticStatus === "missing_in_code" || semanticStatus === "partial") {
+            return { consistent: true, detail: "待人工确认：脚本发现缺口，等待人工裁定" };
+        }
+        return {
+            consistent: false,
+            detail: `08 标「待人工确认」但脚本已完全匹配(diff=${semanticStatus})，应标「一致」`,
+        };
+    }
+    return { consistent: false, detail: `非法结论: ${verdict}` };
+}
+/**
+ * PRD × 代码语义 diff：提取字面量、搜索代码库、校验 08 证据、检查测试覆盖。
+ */
+async function runPrdSemanticDiff(args) {
+    var _a;
+    const corpus = await buildCodeCorpus(args.pkgRoot);
+    const testCorpus = corpus.filter((c) => c.isTest);
+    const items = [];
+    for (const atom of args.atoms) {
+        const classification = classifyPrdAtom(atom);
+        const signals = extractVerifiableSignals(atom.text);
+        const requiresAutomatedTest = atomRequiresAutomatedTest(classification, signals);
+        const report = args.reportRows.get(atom.id);
+        const verdict = (_a = report === null || report === void 0 ? void 0 : report.verdict) !== null && _a !== void 0 ? _a : null;
+        let codeHits = [];
+        const missingSignals = [];
+        for (const signal of signals) {
+            const hits = searchSignalInCorpus(corpus.filter((c) => !c.isTest), signal);
+            if (hits.length === 0) {
+                missingSignals.push(signal);
+            }
+            else {
+                codeHits = codeHits.concat(hits);
+            }
+        }
+        let status;
+        if (classification === "structural") {
+            status = "unverifiable";
+        }
+        else if (signals.length === 0 && classification === "narrative") {
+            status = "unverifiable";
+        }
+        else if (signals.length === 0 && classification === "behavior-verifiable") {
+            const { hasTest } = hasTestCoverageForAtom(atom.id, signals, testCorpus);
+            status = hasTest ? "matched" : "missing_in_code";
+        }
+        else if (missingSignals.length === 0 && signals.length > 0) {
+            status = "matched";
+        }
+        else if (missingSignals.length > 0 && missingSignals.length < signals.length) {
+            status = "partial";
+        }
+        else if (signals.length > 0) {
+            status = "missing_in_code";
+        }
+        else {
+            status = "unverifiable";
+        }
+        const { hasTest, hasE2e } = hasTestCoverageForAtom(atom.id, signals, testCorpus);
+        let reportEvidenceValid = false;
+        if (report === null || report === void 0 ? void 0 : report.codeEvidence) {
+            const ev = await verifyEvidenceRefs(args.pkgRoot, report.codeEvidence, signals);
+            reportEvidenceValid = ev.ok;
+        }
+        const reconcile = reconcileStatusWithReport(status, verdict, classification, signals);
+        let reportConsistent = reconcile.consistent;
+        if (verdict === "一致" && !reportEvidenceValid && signals.length > 0) {
+            reportConsistent = false;
+        }
+        if (!reportConsistent && verdict) {
+            status = "report_mismatch";
+        }
+        const humanPending = verdict === "待人工确认";
+        const waiveTestRequirement = humanPending && classification !== "ui-verifiable";
+        items.push({
+            atomId: atom.id,
+            atomText: atom.text,
+            sectionPath: atom.sectionPath,
+            classification,
+            signals,
+            status,
+            codeHits: codeHits.slice(0, 8),
+            missingSignals,
+            requiresAutomatedTest: requiresAutomatedTest && !waiveTestRequirement,
+            hasAutomatedTest: hasTest,
+            hasE2eTest: hasE2e,
+            reportVerdict: verdict,
+            reportEvidenceValid,
+            reportConsistent,
+            detail: reconcile.detail,
+        });
+    }
+    const openHuman = items.filter((i) => i.reportVerdict === "待人工确认").length;
+    const summary = {
+        total: items.length,
+        matched: items.filter((i) => i.status === "matched").length,
+        partial: items.filter((i) => i.status === "partial").length,
+        missing: items.filter((i) => i.status === "missing_in_code").length,
+        unverifiable: items.filter((i) => i.status === "unverifiable").length,
+        reportMismatch: items.filter((i) => i.status === "report_mismatch").length,
+        requiresTest: items.filter((i) => i.requiresAutomatedTest).length,
+        missingTest: items.filter((i) => i.requiresAutomatedTest && !i.hasAutomatedTest).length,
+        missingE2e: items.filter((i) => i.requiresAutomatedTest && !i.hasE2eTest).length,
+    };
+    const ok = summary.missing === 0 &&
+        summary.partial === 0 &&
+        summary.reportMismatch === 0 &&
+        summary.missingTest === 0 &&
+        summary.missingE2e === 0 &&
+        openHuman === 0;
+    return { ok, items, summary };
+}
+function renderSemanticDiffReportMarkdown(result) {
+    const lines = [
+        "# 09-PRD语义diff报告（脚本自动生成）",
+        "",
+        "> 本报告由 `sdd-flow-kit prd-diff` 机械生成，用于校验 PRD 字面量是否在代码/测试中出现。",
+        "> **不揣摩**：无法提取字面量的条目标为 `unverifiable`，须在 08 报告中标 `待人工确认`。",
+        "",
+        "## 摘要",
+        "",
+        `- 总条目: ${result.summary.total}`,
+        `- 代码匹配 matched: ${result.summary.matched}`,
+        `- 部分匹配 partial: ${result.summary.partial}`,
+        `- 代码缺失 missing_in_code: ${result.summary.missing}`,
+        `- 不可机械验证 unverifiable: ${result.summary.unverifiable}`,
+        `- 08 报告与脚本不一致 report_mismatch: ${result.summary.reportMismatch}`,
+        `- 须自动化测试: ${result.summary.requiresTest}，缺测试: ${result.summary.missingTest}，缺 E2E: ${result.summary.missingE2e}`,
+        "",
+        "## 逐条 diff",
+        "",
+        "| PRD-ID | 分类 | 状态 | PRD 信号 | 代码命中 | 缺测试 | 08 一致 | 说明 |",
+        "|--------|------|------|---------|---------|--------|---------|------|",
+    ];
+    for (const item of result.items) {
+        const signals = item.signals.slice(0, 2).join("；") || "—";
+        const hits = item.codeHits.length > 0
+            ? item.codeHits
+                .slice(0, 2)
+                .map((h) => `${h.file}:${h.line}`)
+                .join("；")
+            : "—";
+        const missTest = item.requiresAutomatedTest && !item.hasAutomatedTest ? "是" : "—";
+        const ok08 = item.reportConsistent ? "是" : "否";
+        lines.push(`| ${item.atomId} | ${item.classification} | ${item.status} | ${signals.replace(/\|/g, "/")} | ${hits} | ${missTest} | ${ok08} | ${item.detail.replace(/\|/g, "/")} |`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+async function writeSemanticDiffArtifacts(outputRoot, result) {
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, ".prd-semantic-diff.json"), `${JSON.stringify(result, null, 2)}\n`);
+    await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, "09-PRD语义diff报告.md"), renderSemanticDiffReportMarkdown(result));
+}

package/dist/core/sessionState.js

@@ -33,6 +33,7 @@ function defaultSession(args) {
         createdAtISO: new Date().toISOString(),
         implGitBaseline: null,
         validateRetryCount: 0,
+        prdFixRetryCount: 0,
     };
 }
 /** 将旧版 session（无 phase 字段）迁移为当前结构 */
@@ -53,5 +54,6 @@ function normalizeSession(raw, outputRoot) {
         createdAtISO: String((_e = raw.createdAtISO) !== null && _e !== void 0 ? _e : new Date().toISOString()),
         implGitBaseline: raw.implGitBaseline ? String(raw.implGitBaseline) : null,
         validateRetryCount: typeof raw.validateRetryCount === "number" ? raw.validateRetryCount : 0,
+        prdFixRetryCount: typeof raw.prdFixRetryCount === "number" ? raw.prdFixRetryCount : 0,
     };
 }

package/dist/core/writeNext.js

@@ -63,6 +63,11 @@ async function writeInitialNext(outputRoot, projectRoot, runId) {
         "",
         "## 6. 阶段 E — 验收签收与交付",
         "```bash",
+        `npx sdd-flow-kit prd-review --project-root "${pr}" --run-id ${runId}`,
+        "# 在 AI 工具执行 08-PRD一致性复查提示词.md（最细粒度逐条对比，禁止揣摩）",
+        `npx sdd-flow-kit prd-diff --project-root "${pr}" --run-id ${runId}`,
+        "# 若失败：每项最多 3 次自动修复（附上次错误摘要）；validate 内置；亦可手动 prd-remediate --change <name>",
+        `npx sdd-flow-kit gate --project-root "${pr}" --run-id ${runId} --expect prd-coverage`,
         `npx sdd-flow-kit validate --project-root "${pr}" --run-id ${runId} --change <kebab-name>`,
         `npx sdd-flow-kit phase advance --project-root "${pr}" --run-id ${runId} --to validate-done --change <kebab-name>`,
         "# 在 05 中将 P0 标为已验收，签收状态改为已签收",

package/dist/steps/runDeliver.js

@@ -42,6 +42,19 @@ async function runDeliver(options) {
             detail: "ac-signed gate 未通过，禁止交付（请在 05-验收清单.md 完成 P0 签收）",
         };
     }
+    const prdCoverageGate = await (0, runGate_1.runGate)({
+        projectRoot: options.projectRoot,
+        runId: loaded.resolved.runId,
+        expect: "prd-coverage",
+        change: options.change,
+    });
+    if (!prdCoverageGate.ok) {
+        (0, runGate_1.printGateResult)(prdCoverageGate);
+        return {
+            ok: false,
+            detail: "prd-coverage gate 未通过，禁止交付（请完成 08-PRD一致性复查报告.md）",
+        };
+    }
     const installRoot = (0, projectRoots_1.resolveInstallRoot)(options.projectRoot);
     const pkgRoot = await (0, projectRoots_1.resolvePackageRoot)(installRoot);
     const agent = options.agent || "cursor";

package/dist/steps/runGate.js

@@ -7,6 +7,7 @@ exports.runGate = runGate;
 exports.printGateResult = printGateResult;
 const path_1 = __importDefault(require("path"));
 const prdArtifacts_1 = require("../core/prdArtifacts");
+const prdCoverage_1 = require("../core/prdCoverage");
 const gitDiffGuard_1 = require("../core/gitDiffGuard");
 const acMatrix_1 = require("../core/acMatrix");
 const projectRoots_1 = require("../core/projectRoots");
@@ -179,6 +180,15 @@ async function runGate(options) {
         checks.push({ name: "acceptance-checklist-signed", ...signed });
         return pass(checks, options.expect, runId);
     }
+    if (options.expect === "prd-coverage") {
+        const installRoot = (0, projectRoots_1.resolveInstallRoot)(options.projectRoot);
+        const pkgRoot = await (0, projectRoots_1.resolvePackageRoot)(installRoot);
+        const coverage = await (0, prdCoverage_1.checkPrdCoverage)(outputRoot, pkgRoot);
+        for (const c of coverage.checks) {
+            checks.push({ name: c.name, ok: c.ok, detail: c.detail });
+        }
+        return pass(checks, options.expect, runId);
+    }
     if (options.expect === "propose-ready") {
         const changeName = await readActiveChange(options.projectRoot, session, options.change);
         if (!changeName) {
@@ -287,7 +297,30 @@ async function runGate(options) {
                 break;
             }
         }
-        // 2) 验收报告签收文件
+        // 2) PRD 一致性复查签收
+        const prdMarker = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, ".prd-coverage-pass.json"));
+        if (prdMarker) {
+            try {
+                const j = JSON.parse(prdMarker);
+                const ok = !j.change || j.change === changeName;
+                checks.push({
+                    name: "prd-coverage-pass",
+                    ok,
+                    detail: ok ? "PRD 一致性复查已通过" : "prd-coverage-pass.json 与 change 不匹配",
+                });
+            }
+            catch {
+                checks.push({ name: "prd-coverage-pass", ok: false, detail: ".prd-coverage-pass.json 解析失败" });
+            }
+        }
+        else {
+            checks.push({
+                name: "prd-coverage-pass",
+                ok: false,
+                detail: "缺少 .prd-coverage-pass.json，请先 gate prd-coverage 或 validate",
+            });
+        }
+        // 3) 验收报告签收文件
         const marker = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, ".validate-pass.json"));
         if (marker) {
             try {

package/dist/steps/runPhaseAdvance.js

@@ -172,6 +172,10 @@ async function runPhaseAdvance(options) {
                 "在 AI 工具中执行：`/opsx-apply`（必须先完成 tasks.md 全部 [x]）",
                 "完成后验收：",
                 "```bash",
+                `npx sdd-flow-kit prd-review --project-root ${options.projectRoot} --run-id ${runId}`,
+                "# AI 执行 08-PRD一致性复查提示词.md（最细粒度，禁止揣摩）",
+                `npx sdd-flow-kit prd-diff --project-root ${options.projectRoot} --run-id ${runId}`,
+                `npx sdd-flow-kit gate --project-root ${options.projectRoot} --run-id ${runId} --expect prd-coverage`,
                 `npx sdd-flow-kit validate --project-root ${options.projectRoot} --run-id ${runId} --change ${changeName}`,
                 `npx sdd-flow-kit phase advance --project-root ${options.projectRoot} --run-id ${runId} --to validate-done --change ${changeName}`,
                 "```",

package/dist/steps/runPrdDiff.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrdDiff = runPrdDiff;
+const path_1 = __importDefault(require("path"));
+const resolveRun_1 = require("./resolveRun");
+const fs_1 = require("../core/fs");
+const prdParse_1 = require("../core/prdParse");
+const prdCoverage_1 = require("../core/prdCoverage");
+const projectRoots_1 = require("../core/projectRoots");
+const prdSemanticDiff_1 = require("../core/prdSemanticDiff");
+/**
+ * 脚本级 PRD × 代码语义 diff（不依赖 AI 填表结论）。
+ */
+async function runPrdDiff(options) {
+    const loaded = await (0, resolveRun_1.loadRunSession)(options.projectRoot, options.runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved)) {
+        return { ok: false, detail: "未找到 PRD run", semantic: null };
+    }
+    const outputRoot = loaded.resolved.outputRoot;
+    const installRoot = (0, projectRoots_1.resolveInstallRoot)(options.projectRoot);
+    const pkgRoot = await (0, projectRoots_1.resolvePackageRoot)(installRoot);
+    const prdContent = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, "source", "PRD.md"));
+    if (!prdContent) {
+        return { ok: false, detail: "缺少 source/PRD.md", semantic: null };
+    }
+    let atoms = await (0, prdCoverage_1.loadPrdAtomsFromManifest)(outputRoot);
+    if (atoms.length === 0)
+        atoms = (0, prdParse_1.parsePrdAtoms)(prdContent);
+    const reportContent = await (0, fs_1.readFileIfExists)(path_1.default.join(outputRoot, "08-PRD一致性复查报告.md"));
+    const reportRows = new Map();
+    if (reportContent) {
+        for (const row of (0, prdCoverage_1.parseReviewReportTable)(reportContent)) {
+            reportRows.set(row.prdId, { verdict: row.verdict, codeEvidence: row.codeEvidence });
+        }
+    }
+    if (options.dryRun) {
+        return {
+            ok: true,
+            detail: `dry-run: would semantic-diff ${atoms.length} atoms in ${pkgRoot}`,
+            semantic: null,
+        };
+    }
+    const semantic = await (0, prdSemanticDiff_1.runPrdSemanticDiff)({ pkgRoot, atoms, reportRows });
+    await (0, prdSemanticDiff_1.writeSemanticDiffArtifacts)(outputRoot, semantic);
+    if (!semantic.ok) {
+        const parts = [];
+        if (semantic.summary.missing > 0)
+            parts.push(`代码缺失 ${semantic.summary.missing}`);
+        if (semantic.summary.partial > 0)
+            parts.push(`部分匹配 ${semantic.summary.partial}`);
+        if (semantic.summary.reportMismatch > 0)
+            parts.push(`08不一致 ${semantic.summary.reportMismatch}`);
+        if (semantic.summary.missingTest > 0)
+            parts.push(`缺自动化测试 ${semantic.summary.missingTest}`);
+        if (semantic.summary.missingE2e > 0)
+            parts.push(`缺E2E ${semantic.summary.missingE2e}`);
+        return {
+            ok: false,
+            detail: `PRD 语义 diff 未通过: ${parts.join(", ")}。见 09-PRD语义diff报告.md`,
+            semantic,
+        };
+    }
+    return {
+        ok: true,
+        detail: `PRD 语义 diff 通过（${semantic.summary.total} 条，matched=${semantic.summary.matched}）`,
+        semantic,
+    };
+}

package/dist/steps/runPrdRemediate.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrdRemediate = runPrdRemediate;
+const resolveRun_1 = require("./resolveRun");
+const projectRoots_1 = require("../core/projectRoots");
+const runPrdDiff_1 = require("./runPrdDiff");
+const prdRemediate_1 = require("../core/prdRemediate");
+const sessionState_1 = require("../core/sessionState");
+/**
+ * PRD 不一致自动修复：按 09 报告调 /opsx-apply 修复，每项最多 3 次，再 prd-diff；失败项 escalated 到人工确认清单。
+ */
+async function runPrdRemediate(options) {
+    var _a;
+    const loaded = await (0, resolveRun_1.loadRunSession)(options.projectRoot, options.runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved)) {
+        return { ok: false, detail: "未找到 PRD run", attempts: 0, escalated: false, needUserConfirm: false };
+    }
+    if (!options.change) {
+        return { ok: false, detail: "需要 --change <name>", attempts: 0, escalated: false, needUserConfirm: false };
+    }
+    const outputRoot = loaded.resolved.outputRoot;
+    const installRoot = (0, projectRoots_1.resolveInstallRoot)(options.projectRoot);
+    const pkgRoot = await (0, projectRoots_1.resolvePackageRoot)(installRoot);
+    const result = await (0, prdRemediate_1.runPrdRemediateLoop)({
+        projectRoot: pkgRoot,
+        outputRoot,
+        runId: loaded.resolved.runId,
+        change: options.change,
+        agent: options.agent,
+        dryRun: options.dryRun,
+        maxAttempts: (_a = options.maxAttempts) !== null && _a !== void 0 ? _a : prdRemediate_1.MAX_PRD_FIX_RETRIES,
+        runDiff: async () => {
+            const diff = await (0, runPrdDiff_1.runPrdDiff)({
+                projectRoot: options.projectRoot,
+                runId: loaded.resolved.runId,
+                dryRun: false,
+            });
+            return { ok: diff.ok, semantic: diff.semantic };
+        },
+    });
+    if (loaded.session) {
+        await (0, sessionState_1.writeSession)(outputRoot, {
+            ...loaded.session,
+            prdFixRetryCount: result.attempts,
+            status: result.ok ? "validate_in_progress" : result.escalated ? "awaiting_user_confirmation" : "apply_in_progress",
+        });
+    }
+    return result;
+}

package/dist/steps/runPrdReview.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrdReview = runPrdReview;
+const path_1 = __importDefault(require("path"));
+const templates_1 = require("../core/templates");
+const fs_1 = require("../core/fs");
+const prdParse_1 = require("../core/prdParse");
+const prdCoverage_1 = require("../core/prdCoverage");
+const resolveRun_1 = require("./resolveRun");
+const prdCoverage_2 = require("../core/prdCoverage");
+function renderReportSkeleton(atoms, template) {
+    const tableRows = atoms
+        .map((a) => `| ${a.id} | ${a.text.replace(/\|/g, "\\|").slice(0, 120)} | （文件:行号 或 选择器 + 断言原文） | 待填写 | ${a.sectionPath} L${a.line} |`)
+        .join("\n");
+    return template
+        .replace("{{ATOM_COUNT}}", String(atoms.length))
+        .replace("{{REVIEW_TABLE_ROWS}}", tableRows)
+        .replace("{{GENERATED_AT}}", new Date().toISOString());
+}
+/**
+ * 从 PRD 生成最细粒度原子清单，并初始化/刷新 08-PRD一致性复查报告.md 骨架。
+ */
+async function runPrdReview(options) {
+    const loaded = await (0, resolveRun_1.loadRunSession)(options.projectRoot, options.runId);
+    if (!(loaded === null || loaded === void 0 ? void 0 : loaded.resolved)) {
+        return { ok: false, detail: "未找到 PRD run", atomCount: 0 };
+    }
+    const outputRoot = loaded.resolved.outputRoot;
+    const prdPath = path_1.default.join(outputRoot, "source", "PRD.md");
+    const prdContent = await (0, fs_1.readFileIfExists)(prdPath);
+    if (!prdContent) {
+        return { ok: false, detail: "缺少 source/PRD.md", atomCount: 0 };
+    }
+    const atoms = (0, prdParse_1.parsePrdAtoms)(prdContent);
+    if (atoms.length === 0) {
+        return { ok: false, detail: "PRD 未解析到原子条目", atomCount: 0 };
+    }
+    if (options.dryRun) {
+        return {
+            ok: true,
+            detail: `dry-run: 将生成 ${atoms.length} 条 PRD 原子与 08 报告骨架`,
+            atomCount: atoms.length,
+        };
+    }
+    await (0, prdCoverage_1.writePrdAtomsManifest)(outputRoot, atoms);
+    const reportPath = path_1.default.join(outputRoot, "08-PRD一致性复查报告.md");
+    const existing = await (0, fs_1.readFileIfExists)(reportPath);
+    const reviewComplete = existing && /复查状态[：:]\s*[`「]*复查完成/.test(existing);
+    if (!existing || !reviewComplete) {
+        const template = await (0, templates_1.loadTemplateText)("artifacts/08-PRD一致性复查报告.template.md");
+        const promptTemplate = await (0, templates_1.loadTemplateText)("prompts/08-prd-consistency-review-prompt.md");
+        const body = renderReportSkeleton(atoms, template);
+        await (0, fs_1.writeTextFileEnsuredDir)(reportPath, body);
+        await (0, fs_1.writeTextFileEnsuredDir)(path_1.default.join(outputRoot, "08-PRD一致性复查提示词.md"), promptTemplate.replace(/\{\{ATOM_COUNT\}\}/g, String(atoms.length)));
+    }
+    const coverage = await (0, prdCoverage_2.checkPrdCoverage)(outputRoot, options.projectRoot);
+    if (coverage.ok) {
+        return {
+            ok: true,
+            detail: `PRD 一致性复查通过（${atoms.length} 条原子条目）`,
+            atomCount: atoms.length,
+        };
+    }
+    const failed = coverage.checks.filter((c) => !c.ok).map((c) => c.name);
+    return {
+        ok: false,
+        detail: `已生成/更新 08 报告骨架（${atoms.length} 条）。待完成复查: ${failed.join(", ")}。请执行 08-PRD一致性复查提示词.md 后重试 gate prd-coverage`,
+        atomCount: atoms.length,
+    };
+}