@luckychen1993/pm-mcp 0.1.1

package/dist/acceptance-report.js

@@ -0,0 +1,335 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { ACCEPTANCE_SCHEMA_VERSION, BaselineApprovalSchema, FrozenEvidencePointerSchema, ISO_25010_CHARACTERISTICS, ISO_25040_STAGES, MachineAssertionSchema, RISK_LEVELS, } from "./acceptance-model.js";
+import { pmPath } from "./paths.js";
+import { atomicWrite, withLedgerLock } from "./store.js";
+export const ACCEPTANCE_STANDARD_BASIS = [
+    "ISO/IEC 25010:2023",
+    "ISO/IEC 25023:2016",
+    "ISO/IEC 25030:2019",
+    "ISO/IEC 25040:2024",
+    "ISO/IEC/IEEE 29119-2:2021",
+];
+const IdSchema = z.string().trim().min(1).max(120).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+const TextSchema = z.string().trim().min(1).max(8_000);
+const TimestampSchema = z.string().datetime({ offset: true });
+const Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/i);
+function requireUniqueSet(values, expected, pathName, ctx) {
+    const actual = new Set(values);
+    if (actual.size !== values.length) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: [pathName], message: `${pathName} 包含重复项` });
+    }
+    if (expected) {
+        for (const item of expected) {
+            if (!actual.has(item))
+                ctx.addIssue({ code: z.ZodIssueCode.custom, path: [pathName], message: `${pathName} 缺少 "${item}"` });
+        }
+        if (values.length !== expected.length)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: [pathName], message: `${pathName} 数量必须为 ${expected.length}` });
+    }
+}
+export const AcceptanceFindingSchema = z
+    .object({
+    code: IdSchema,
+    severity: z.enum(["error", "warning"]),
+    subject: TextSchema,
+    message: TextSchema,
+})
+    .strict();
+export const AcceptanceReportSchema = z
+    .object({
+    schema_version: z.literal(ACCEPTANCE_SCHEMA_VERSION),
+    report_id: IdSchema,
+    evaluation_id: IdSchema,
+    report_generated_at: TimestampSchema,
+    product: TextSchema,
+    scope: TextSchema,
+    baseline: z
+        .object({
+        id: IdSchema,
+        version: z.string().min(1),
+        title: TextSchema,
+        fingerprint_sha256: Sha256Schema,
+        approval: BaselineApprovalSchema,
+    })
+        .strict(),
+    evaluator: z
+        .object({
+        name: TextSchema,
+        organization: TextSchema,
+        role: TextSchema,
+        independent: z.boolean(),
+    })
+        .strict(),
+    standard_basis: z.tuple([
+        z.literal(ACCEPTANCE_STANDARD_BASIS[0]),
+        z.literal(ACCEPTANCE_STANDARD_BASIS[1]),
+        z.literal(ACCEPTANCE_STANDARD_BASIS[2]),
+        z.literal(ACCEPTANCE_STANDARD_BASIS[3]),
+        z.literal(ACCEPTANCE_STANDARD_BASIS[4]),
+    ]),
+    verdict: z.enum(["accepted", "rejected"]),
+    summary: z
+        .object({
+        applicable_characteristics: z.number().int().min(0),
+        accepted_characteristics: z.number().int().min(0),
+        requirements_total: z.number().int().min(0),
+        requirements_passed: z.number().int().min(0),
+        tests_total: z.number().int().min(0),
+        tests_passed: z.number().int().min(0),
+        risks_total: z.number().int().min(0),
+        risks_controlled: z.number().int().min(0),
+        stages_total: z.number().int().min(0),
+        stages_completed: z.number().int().min(0),
+        errors: z.number().int().min(0),
+        warnings: z.number().int().min(0),
+    })
+        .strict(),
+    stage_results: z.array(z.object({
+        stage: z.enum(ISO_25040_STAGES),
+        status: z.enum(["completed", "blocked", "not_started"]),
+        passed: z.boolean(),
+        evidence_ids: z.array(IdSchema),
+        result_note: TextSchema,
+    }).strict()),
+    characteristic_results: z.array(z.object({
+        id: z.enum(ISO_25010_CHARACTERISTICS),
+        status: z.enum(["accepted", "rejected", "tailored_out"]),
+        requirement_ids: z.array(IdSchema),
+        tailoring_reason: TextSchema.nullable(),
+    }).strict()),
+    requirement_results: z.array(z.object({
+        id: IdSchema,
+        characteristic: z.enum(ISO_25010_CHARACTERISTICS),
+        metric_name: TextSchema,
+        unit: TextSchema,
+        direction: z.enum(["at_least", "at_most", "equal"]),
+        threshold: z.number().finite(),
+        tolerance: z.number().finite().min(0),
+        observed_value: z.number().finite().nullable(),
+        measurement_source: FrozenEvidencePointerSchema,
+        passed: z.boolean(),
+        risk_ids: z.array(IdSchema),
+        test_ids: z.array(IdSchema),
+        evidence_ids: z.array(IdSchema),
+    }).strict()),
+    test_results: z.array(z.object({
+        id: IdSchema,
+        status: z.enum(["passed", "failed", "blocked", "not_run", "missing"]),
+        verification_mode: z.enum(["automated", "manual"]),
+        assertion: MachineAssertionSchema.nullable(),
+        passed: z.boolean(),
+        evidence_ids: z.array(IdSchema),
+    }).strict()),
+    risk_results: z.array(z.object({
+        id: IdSchema,
+        owner: TextSchema,
+        likelihood: z.enum(["rare", "unlikely", "possible", "likely", "almost_certain"]),
+        impact: z.enum(["negligible", "minor", "moderate", "major", "severe"]),
+        inherent_level: z.enum(RISK_LEVELS),
+        compensating_controls: z.array(TextSchema).min(1),
+        residual_level: z.enum(RISK_LEVELS).nullable(),
+        disposition: z.enum(["mitigated", "accepted", "open", "missing"]),
+        accepted_by: TextSchema.nullable(),
+        evidence_ids: z.array(IdSchema),
+        controlled: z.boolean(),
+    }).strict()),
+    traceability_matrix: z.array(z.object({
+        requirement_id: IdSchema,
+        risk_ids: z.array(IdSchema),
+        test_ids: z.array(IdSchema),
+        evidence_ids: z.array(IdSchema),
+        complete: z.boolean(),
+    }).strict()),
+    findings: z.array(AcceptanceFindingSchema),
+    conclusion: TextSchema,
+})
+    .strict()
+    .superRefine((report, ctx) => {
+    requireUniqueSet(report.stage_results.map((item) => item.stage), ISO_25040_STAGES, "stage_results", ctx);
+    requireUniqueSet(report.characteristic_results.map((item) => item.id), ISO_25010_CHARACTERISTICS, "characteristic_results", ctx);
+    requireUniqueSet(report.requirement_results.map((item) => item.id), null, "requirement_results", ctx);
+    requireUniqueSet(report.test_results.map((item) => item.id), null, "test_results", ctx);
+    requireUniqueSet(report.risk_results.map((item) => item.id), null, "risk_results", ctx);
+    requireUniqueSet(report.traceability_matrix.map((item) => item.requirement_id), null, "traceability_matrix", ctx);
+    const requirementIds = new Set(report.requirement_results.map((item) => item.id));
+    const traceIds = new Set(report.traceability_matrix.map((item) => item.requirement_id));
+    for (const id of requirementIds) {
+        if (!traceIds.has(id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["traceability_matrix"], message: `追踪矩阵缺少需求 "${id}"` });
+    }
+    for (const id of traceIds) {
+        if (!requirementIds.has(id))
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["traceability_matrix"], message: `追踪矩阵包含未知需求 "${id}"` });
+    }
+    const errors = report.findings.filter((finding) => finding.severity === "error").length;
+    const warnings = report.findings.filter((finding) => finding.severity === "warning").length;
+    const expected = {
+        applicable_characteristics: report.characteristic_results.filter((item) => item.status !== "tailored_out").length,
+        accepted_characteristics: report.characteristic_results.filter((item) => item.status === "accepted").length,
+        requirements_total: report.requirement_results.length,
+        requirements_passed: report.requirement_results.filter((item) => item.passed).length,
+        tests_total: report.test_results.length,
+        tests_passed: report.test_results.filter((item) => item.passed).length,
+        risks_total: report.risk_results.length,
+        risks_controlled: report.risk_results.filter((item) => item.controlled).length,
+        stages_total: report.stage_results.length,
+        stages_completed: report.stage_results.filter((item) => item.passed).length,
+        errors,
+        warnings,
+    };
+    for (const [key, value] of Object.entries(expected)) {
+        if (report.summary[key] !== value) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["summary", key], message: `汇总值应为 ${value}` });
+        }
+    }
+    if ((errors === 0) !== (report.verdict === "accepted")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["verdict"], message: "verdict 必须与 error finding 一致" });
+    }
+});
+export const AcceptanceReportManifestSchema = z
+    .object({
+    schema_version: z.literal(ACCEPTANCE_SCHEMA_VERSION),
+    report_id: IdSchema,
+    generated_at: TimestampSchema,
+    json_sha256: Sha256Schema,
+    markdown_sha256: Sha256Schema,
+})
+    .strict();
+function md(value) {
+    return String(value ?? "").replace(/\|/g, "\\|").replace(/[\r\n]+/g, " ");
+}
+function list(values) {
+    return values.length === 0 ? "—" : values.map(md).join(", ");
+}
+export function renderAcceptanceReportMarkdown(input) {
+    const report = AcceptanceReportSchema.parse(input);
+    const lines = [
+        `# 产品质量正式评价报告：${report.product}`,
+        "",
+        `- 报告 ID：${report.report_id}`,
+        `- 评价 ID：${report.evaluation_id}`,
+        `- 基线：${report.baseline.id}@${report.baseline.version}`,
+        `- 基线 SHA-256：\`${report.baseline.fingerprint_sha256}\``,
+        `- 基线审批：${report.baseline.approval.status}`,
+        `- 评价人：${report.evaluator.name}（${report.evaluator.organization}，${report.evaluator.role}）`,
+        `- 独立评价：${report.evaluator.independent ? "是" : "否"}`,
+        `- 报告生成时间：${report.report_generated_at}`,
+        `- 最终结论：**${report.verdict === "accepted" ? "通过" : "不通过"}**`,
+        "",
+        "## 适用标准",
+        "",
+        ...report.standard_basis.map((standard) => `- ${standard}`),
+        "",
+        "## 评价摘要",
+        "",
+        "| 项目 | 通过 / 总数 |",
+        "|---|---:|",
+        `| ISO/IEC 25010 适用质量特性 | ${report.summary.accepted_characteristics} / ${report.summary.applicable_characteristics} |`,
+        `| 量化质量需求 | ${report.summary.requirements_passed} / ${report.summary.requirements_total} |`,
+        `| 验收测试 | ${report.summary.tests_passed} / ${report.summary.tests_total} |`,
+        `| 残余风险受控 | ${report.summary.risks_controlled} / ${report.summary.risks_total} |`,
+        `| ISO/IEC 25040 评价阶段 | ${report.summary.stages_completed} / ${report.summary.stages_total} |`,
+        `| 错误 / 警告 | ${report.summary.errors} / ${report.summary.warnings} |`,
+        "",
+        "## ISO/IEC 25040 阶段记录",
+        "",
+        "| 阶段 | 状态 | 证据 | 结论 |",
+        "|---|---|---|---|",
+        ...report.stage_results.map((item) => `| ${item.stage} | ${item.status} | ${list(item.evidence_ids)} | ${md(item.result_note)} |`),
+        "",
+        "## ISO/IEC 25010 质量特性",
+        "",
+        "| 特性 | 状态 | 需求 | 裁剪理由 |",
+        "|---|---|---|---|",
+        ...report.characteristic_results.map((item) => `| ${item.id} | ${item.status} | ${list(item.requirement_ids)} | ${md(item.tailoring_reason ?? "—")} |`),
+        "",
+        "## 量化需求结果",
+        "",
+        "| 需求 | 特性 | 指标 | 阈值 | 实测 | 冻结数据源 | 结果 | 证据 |",
+        "|---|---|---|---:|---:|---|---|---|",
+        ...report.requirement_results.map((item) => {
+            const operator = item.direction === "at_least" ? ">=" : item.direction === "at_most" ? "<=" : "=";
+            return `| ${item.id} | ${item.characteristic} | ${md(item.metric_name)} (${md(item.unit)}) | ${operator} ${item.threshold} | ${item.observed_value ?? "—"} | ${item.measurement_source.evidence_id}#${md(item.measurement_source.json_pointer)} | ${item.passed ? "通过" : "不通过"} | ${list(item.evidence_ids)} |`;
+        }),
+        "",
+        "## 验收测试与冻结断言",
+        "",
+        "| 测试 | 验证模式 | 冻结断言 | 状态 | 结果 | 证据 |",
+        "|---|---|---|---|---|---|",
+        ...report.test_results.map((item) => {
+            const assertion = item.assertion
+                ? `${item.assertion.evidence_id}#${item.assertion.json_pointer} ${item.assertion.operator} ${JSON.stringify(item.assertion.expected)}`
+                : "人工评价";
+            return `| ${item.id} | ${item.verification_mode} | ${md(assertion)} | ${item.status} | ${item.passed ? "通过" : "不通过"} | ${list(item.evidence_ids)} |`;
+        }),
+        "",
+        "## 需求—风险—测试—证据追踪矩阵",
+        "",
+        "| 需求 | 风险 | 测试 | 证据 | 完整 |",
+        "|---|---|---|---|---|",
+        ...report.traceability_matrix.map((item) => `| ${item.requirement_id} | ${list(item.risk_ids)} | ${list(item.test_ids)} | ${list(item.evidence_ids)} | ${item.complete ? "是" : "否"} |`),
+        "",
+        "## 残余风险",
+        "",
+        "| 风险 | Owner | 可能性 | 影响 | 固有等级 | 补偿控制 | 残余等级 | 处置 | 接受人 | 受控 | 证据 |",
+        "|---|---|---|---|---|---|---|---|---|---|---|",
+        ...report.risk_results.map((item) => `| ${item.id} | ${md(item.owner)} | ${item.likelihood} | ${item.impact} | ${item.inherent_level} | ${list(item.compensating_controls)} | ${item.residual_level ?? "—"} | ${item.disposition} | ${md(item.accepted_by ?? "—")} | ${item.controlled ? "是" : "否"} | ${list(item.evidence_ids)} |`),
+        "",
+        "## 发现项",
+        "",
+    ];
+    if (report.findings.length === 0) {
+        lines.push("无阻断项或警告。", "");
+    }
+    else {
+        lines.push("| 严重度 | 代码 | 对象 | 说明 |", "|---|---|---|---|", ...report.findings.map((item) => `| ${item.severity} | ${item.code} | ${md(item.subject)} | ${md(item.message)} |`), "");
+    }
+    lines.push("## 正式结论", "", report.conclusion, "");
+    return lines.join("\n");
+}
+export function acceptanceReportPaths(root, reportId) {
+    const safe = IdSchema.parse(reportId);
+    const dir = pmPath(path.resolve(root), "acceptance", "reports");
+    return {
+        json_file: path.join(dir, `${safe}.json`),
+        markdown_file: path.join(dir, `${safe}.md`),
+        manifest_file: path.join(dir, `${safe}.sha256.json`),
+    };
+}
+function sha256(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+export function writeAcceptanceReport(root, input) {
+    const report = AcceptanceReportSchema.parse(input);
+    const files = acceptanceReportPaths(root, report.report_id);
+    const jsonContent = JSON.stringify(report, null, 2) + "\n";
+    const markdownContent = renderAcceptanceReportMarkdown(report);
+    const manifest = AcceptanceReportManifestSchema.parse({
+        schema_version: ACCEPTANCE_SCHEMA_VERSION,
+        report_id: report.report_id,
+        generated_at: report.report_generated_at,
+        json_sha256: sha256(jsonContent),
+        markdown_sha256: sha256(markdownContent),
+    });
+    const manifestContent = JSON.stringify(manifest, null, 2) + "\n";
+    return withLedgerLock(path.resolve(root), () => {
+        fs.mkdirSync(path.dirname(files.json_file), { recursive: true });
+        const existing = [files.json_file, files.markdown_file, files.manifest_file].filter((file) => fs.existsSync(file));
+        if (existing.length > 0) {
+            const allMatch = existing.length === 3
+                && fs.readFileSync(files.json_file, "utf8") === jsonContent
+                && fs.readFileSync(files.markdown_file, "utf8") === markdownContent
+                && fs.readFileSync(files.manifest_file, "utf8") === manifestContent;
+            if (!allMatch)
+                throw new Error(`正式验收报告不可覆盖或修补（三件套）：${report.report_id}；请使用新的 report_id。`);
+            return files;
+        }
+        atomicWrite(files.json_file, jsonContent);
+        atomicWrite(files.markdown_file, markdownContent);
+        atomicWrite(files.manifest_file, manifestContent);
+        return files;
+    });
+}

package/dist/acceptance-tools.js

@@ -0,0 +1,318 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { AcceptanceBaselineSchema, AcceptanceEvaluationSchema, JsonPointerSchema, acceptanceBaselinePath, loadAcceptanceBaseline, saveAcceptanceBaseline, } from "./acceptance-model.js";
+import { acceptanceBaselineFingerprint, evaluateAcceptance } from "./acceptance-evaluator.js";
+import { writeAcceptanceReport } from "./acceptance-report.js";
+import { requireInitialized } from "./paths.js";
+import { loadJson, saveJson, withLedgerLock } from "./store.js";
+import { tool } from "./tool-base.js";
+import { refreshDerived } from "./dashboard.js";
+const IdSchema = z.string().trim().min(1).max(120).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/);
+const SemVerSchema = z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/);
+const JsonPathSchema = z.string().trim().min(1).max(1_000);
+const Sha256Schema = z.string().regex(/^[a-f0-9]{64}$/i);
+function inside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+export function acceptanceDataRoot(root) {
+    return path.resolve(root, ".pm", "acceptance");
+}
+/** Resolve an existing ordinary file without permitting lexical or symlink escape. */
+export function resolveAcceptanceFile(root, locator, requireJson = false) {
+    const projectRoot = path.resolve(root);
+    const allowedRoot = acceptanceDataRoot(projectRoot);
+    const candidate = path.resolve(projectRoot, locator);
+    if (!inside(allowedRoot, candidate))
+        throw new Error(`路径必须位于项目内 .pm/acceptance：${locator}`);
+    if (requireJson && path.extname(candidate).toLowerCase() !== ".json")
+        throw new Error(`只允许读取 JSON 文件：${locator}`);
+    if (!fs.existsSync(allowedRoot))
+        throw new Error(`验收目录不存在：${allowedRoot}`);
+    if (!fs.existsSync(candidate))
+        throw new Error(`文件不存在：${locator}`);
+    if (fs.lstatSync(candidate).isSymbolicLink())
+        throw new Error(`不允许使用符号链接作为验收文件：${locator}`);
+    const realAllowedRoot = fs.realpathSync(allowedRoot);
+    const realCandidate = fs.realpathSync(candidate);
+    if (!inside(realAllowedRoot, realCandidate))
+        throw new Error(`文件真实路径逃逸 .pm/acceptance：${locator}`);
+    if (!fs.statSync(realCandidate).isFile())
+        throw new Error(`验收路径必须是普通文件：${locator}`);
+    return realCandidate;
+}
+export function readAcceptanceJson(root, locator, schema) {
+    const file = resolveAcceptanceFile(root, locator, true);
+    const parsed = loadJson(file, schema);
+    if (parsed === undefined)
+        throw new Error(`文件不存在：${locator}`);
+    return parsed;
+}
+export function sha256AcceptanceFile(file) {
+    const digest = createHash("sha256");
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    const handle = fs.openSync(file, "r");
+    try {
+        const before = fs.fstatSync(handle);
+        let offset = 0;
+        while (offset < before.size) {
+            const read = fs.readSync(handle, buffer, 0, Math.min(buffer.length, before.size - offset), offset);
+            if (read === 0)
+                break;
+            digest.update(buffer.subarray(0, read));
+            offset += read;
+        }
+        const after = fs.fstatSync(handle);
+        if (offset !== before.size || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+            throw new Error(`证据文件在摘要计算期间发生变化：${file}`);
+        }
+        return digest.digest("hex");
+    }
+    finally {
+        fs.closeSync(handle);
+    }
+}
+export function verifyEvaluationEvidence(root, evaluation) {
+    for (const evidence of evaluation.evidence) {
+        const file = resolveAcceptanceFile(root, evidence.locator, false);
+        const actual = sha256AcceptanceFile(file);
+        if (actual.toLowerCase() !== evidence.sha256.toLowerCase()) {
+            throw new Error(`证据摘要不一致：${evidence.id} 声明 ${evidence.sha256}，实际 ${actual}`);
+        }
+    }
+}
+const FORBIDDEN_POINTER_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);
+/** Safe RFC 6901 resolver: own properties only, canonical array indexes only. */
+export function resolveJsonPointer(document, pointerInput) {
+    const pointer = JsonPointerSchema.parse(pointerInput);
+    if (pointer === "")
+        return document;
+    let current = document;
+    for (const encoded of pointer.slice(1).split("/")) {
+        const token = encoded.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (FORBIDDEN_POINTER_SEGMENTS.has(token))
+            throw new Error(`JSON Pointer 包含禁止字段：${token}`);
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9]\d*)$/.test(token))
+                throw new Error(`JSON Pointer 数组索引非法：${token}`);
+            const index = Number(token);
+            if (!Number.isSafeInteger(index) || index >= current.length)
+                throw new Error(`JSON Pointer 数组越界：${token}`);
+            current = current[index];
+            continue;
+        }
+        if (current !== null && typeof current === "object") {
+            if (!Object.prototype.hasOwnProperty.call(current, token))
+                throw new Error(`JSON Pointer 字段不存在：${token}`);
+            current = current[token];
+            continue;
+        }
+        throw new Error(`JSON Pointer 无法继续解析：${token}`);
+    }
+    return current;
+}
+function readVerifiedJsonEvidence(root, evidence) {
+    const file = resolveAcceptanceFile(root, evidence.locator, false);
+    const bytes = fs.readFileSync(file);
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (digest.toLowerCase() !== evidence.sha256.toLowerCase()) {
+        throw new Error(`证据摘要不一致：${evidence.id} 声明 ${evidence.sha256}，实际 ${digest}`);
+    }
+    try {
+        return JSON.parse(bytes.toString("utf8"));
+    }
+    catch (error) {
+        throw new Error(`机器断言证据不是合法 JSON：${evidence.id}: ${error.message}`);
+    }
+}
+function machineAssertionPassed(actual, assertion) {
+    if (assertion.operator === "at_least" || assertion.operator === "at_most") {
+        if (typeof actual !== "number" || !Number.isFinite(actual) || typeof assertion.expected !== "number") {
+            throw new Error(`${assertion.operator} 断言的实际值和期望值必须是有限数字`);
+        }
+        return assertion.operator === "at_least" ? actual >= assertion.expected : actual <= assertion.expected;
+    }
+    const equal = Object.is(actual, assertion.expected);
+    return assertion.operator === "equal" ? equal : !equal;
+}
+/**
+ * Reconstruct observed values and automated test outcomes from the approved
+ * baseline's frozen JSON evidence pointers. Evaluation fields are assertions
+ * about evidence, never an alternative source of truth.
+ */
+export function verifyFrozenAcceptanceAssertions(root, baseline, evaluation) {
+    const evidenceById = new Map(evaluation.evidence.map((item) => [item.id, item]));
+    const measurementById = new Map(evaluation.measurements.map((item) => [item.requirement_id, item]));
+    const testResultById = new Map(evaluation.test_results.map((item) => [item.test_id, item]));
+    const documents = new Map();
+    const documentFor = (evidenceId) => {
+        const evidence = evidenceById.get(evidenceId);
+        if (!evidence)
+            throw new Error(`基线冻结的机器证据不存在：${evidenceId}`);
+        if (!documents.has(evidenceId))
+            documents.set(evidenceId, readVerifiedJsonEvidence(root, evidence));
+        return documents.get(evidenceId);
+    };
+    for (const requirement of baseline.requirements) {
+        const measurement = measurementById.get(requirement.id);
+        if (!measurement)
+            throw new Error(`缺少基线需求的测量结果：${requirement.id}`);
+        const source = requirement.measurement_source;
+        if (!measurement.evidence_ids.includes(source.evidence_id)) {
+            throw new Error(`测量 ${requirement.id} 未引用冻结证据 ${source.evidence_id}`);
+        }
+        const actual = resolveJsonPointer(documentFor(source.evidence_id), source.json_pointer);
+        if (typeof actual !== "number" || !Number.isFinite(actual)) {
+            throw new Error(`测量源 ${requirement.id}${source.json_pointer} 不是有限数字`);
+        }
+        if (!Object.is(actual, measurement.observed_value)) {
+            throw new Error(`伪造或过期测量值：${requirement.id} 填写 ${measurement.observed_value}，证据实际 ${actual}`);
+        }
+    }
+    for (const definition of baseline.tests) {
+        if (definition.verification_mode === "manual")
+            continue;
+        const assertion = definition.assertion;
+        const result = testResultById.get(definition.id);
+        if (!result)
+            throw new Error(`缺少基线测试结果：${definition.id}`);
+        if (!result.evidence_ids.includes(assertion.evidence_id)) {
+            throw new Error(`测试 ${definition.id} 未引用冻结断言证据 ${assertion.evidence_id}`);
+        }
+        const actual = resolveJsonPointer(documentFor(assertion.evidence_id), assertion.json_pointer);
+        const passed = machineAssertionPassed(actual, assertion);
+        const expectedStatus = passed ? "passed" : "failed";
+        if (result.status !== expectedStatus) {
+            throw new Error(`伪造或不一致测试状态：${definition.id} 填写 ${result.status}，机器断言结果为 ${expectedStatus}`);
+        }
+    }
+}
+export function listAcceptanceBaselines(root) {
+    const base = path.join(acceptanceDataRoot(root), "baselines");
+    if (!fs.existsSync(base))
+        return [];
+    const summaries = [];
+    for (const idEntry of fs.readdirSync(base, { withFileTypes: true })) {
+        if (!idEntry.isDirectory() || idEntry.isSymbolicLink())
+            continue;
+        const id = IdSchema.parse(idEntry.name);
+        const idDir = path.join(base, idEntry.name);
+        for (const versionEntry of fs.readdirSync(idDir, { withFileTypes: true })) {
+            if (!versionEntry.isFile() || path.extname(versionEntry.name).toLowerCase() !== ".json")
+                continue;
+            const version = SemVerSchema.parse(path.basename(versionEntry.name, ".json"));
+            const value = loadAcceptanceBaseline(root, id, version);
+            summaries.push({
+                id: value.baseline_id,
+                version: value.baseline_version,
+                title: value.title,
+                status: value.approval.status,
+                fingerprint_sha256: acceptanceBaselineFingerprint(value),
+                requirements: value.requirements.length,
+                risks: value.risks.length,
+                tests: value.tests.length,
+                file: path.relative(path.resolve(root), acceptanceBaselinePath(root, id, version)).replace(/\\/g, "/"),
+            });
+        }
+    }
+    return summaries.sort((left, right) => `${left.id}@${left.version}`.localeCompare(`${right.id}@${right.version}`, "en"));
+}
+export function saveDraftAcceptanceBaselineFile(root, locator) {
+    const baseline = readAcceptanceJson(root, locator, AcceptanceBaselineSchema);
+    if (baseline.approval.status !== "draft")
+        throw new Error("save_acceptance_baseline_draft 只接受 approval.status=draft 的基线。");
+    return saveAcceptanceBaseline(root, baseline);
+}
+/** Atomic compare-fingerprint-and-approve transaction; never nests the model lock. */
+export function approveAcceptanceBaseline(root, input) {
+    const parsed = {
+        baseline_id: IdSchema.parse(input.baseline_id),
+        baseline_version: SemVerSchema.parse(input.baseline_version),
+        expected_fingerprint_sha256: Sha256Schema.parse(input.expected_fingerprint_sha256).toLowerCase(),
+        approved_by: z.string().trim().min(1).parse(input.approved_by),
+        approval_rationale: z.string().trim().min(8).parse(input.approval_rationale),
+        approved_at: input.approved_at ? z.string().datetime({ offset: true }).parse(input.approved_at) : new Date().toISOString(),
+    };
+    return withLedgerLock(path.resolve(root), () => {
+        const current = loadAcceptanceBaseline(root, parsed.baseline_id, parsed.baseline_version);
+        if (current.approval.status !== "draft")
+            throw new Error(`只有 draft 基线可批准；当前状态为 ${current.approval.status}。`);
+        const fingerprint = acceptanceBaselineFingerprint(current);
+        if (fingerprint.toLowerCase() !== parsed.expected_fingerprint_sha256) {
+            throw new Error(`基线 fingerprint 已变化：期望 ${parsed.expected_fingerprint_sha256}，当前 ${fingerprint}；请重新审阅，修改内容必须升版。`);
+        }
+        if (Date.parse(parsed.approved_at) < Date.parse(current.created_at))
+            throw new Error("批准时间不得早于基线创建时间。");
+        const approved = AcceptanceBaselineSchema.parse({
+            ...current,
+            approval: {
+                status: "approved",
+                approved_by: parsed.approved_by,
+                approved_at: parsed.approved_at,
+                rationale: parsed.approval_rationale,
+            },
+        });
+        saveJson(acceptanceBaselinePath(root, approved.baseline_id, approved.baseline_version), approved);
+        return approved;
+    });
+}
+export function evaluateAcceptanceFile(root, input) {
+    const baseline = loadAcceptanceBaseline(root, IdSchema.parse(input.baseline_id), SemVerSchema.parse(input.baseline_version));
+    const evaluation = readAcceptanceJson(root, input.evaluation_file, AcceptanceEvaluationSchema);
+    verifyEvaluationEvidence(root, evaluation);
+    verifyFrozenAcceptanceAssertions(root, baseline, evaluation);
+    const report = evaluateAcceptance(baseline, evaluation);
+    const files = writeAcceptanceReport(root, report);
+    refreshDerived(root);
+    return { report, ...files };
+}
+export function registerAcceptanceTools(server, root) {
+    tool(server, "list_acceptance_baselines", "列出版本化验收基线、审批状态、当前 fingerprint 和规模。", {}, () => {
+        requireInitialized(root);
+        return JSON.stringify(listAcceptanceBaselines(root), null, 2);
+    });
+    tool(server, "get_acceptance_baseline", "读取一个验收基线；默认返回摘要，full=true 返回严格 JSON。", {
+        baseline_id: IdSchema,
+        baseline_version: SemVerSchema,
+        full: z.boolean().optional(),
+    }, (args) => {
+        requireInitialized(root);
+        const baseline = loadAcceptanceBaseline(root, args.baseline_id, args.baseline_version);
+        if (args.full)
+            return JSON.stringify(baseline, null, 2);
+        return JSON.stringify(listAcceptanceBaselines(root).find((item) => item.id === args.baseline_id && item.version === args.baseline_version), null, 2);
+    });
+    tool(server, "save_acceptance_baseline_draft", "从项目内 .pm/acceptance 下的严格 JSON 保存 draft 基线；批准后的同版本不可覆盖。", {
+        baseline_file: JsonPathSchema,
+    }, (args) => {
+        requireInitialized(root);
+        const baseline = saveDraftAcceptanceBaselineFile(root, args.baseline_file);
+        return `✅ draft ${baseline.baseline_id}@${baseline.baseline_version} 已保存；fingerprint=${acceptanceBaselineFingerprint(baseline)}`;
+    });
+    tool(server, "approve_acceptance_baseline", "按当前 SHA-256 fingerprint 原子批准基线；fingerprint 变化即拒绝，批准后修改必须升版。", {
+        baseline_id: IdSchema,
+        baseline_version: SemVerSchema,
+        expected_fingerprint_sha256: Sha256Schema,
+        approved_by: z.string().trim().min(1),
+        approval_rationale: z.string().trim().min(8),
+        approved_at: z.string().datetime({ offset: true }).optional(),
+    }, (args) => {
+        requireInitialized(root);
+        const approved = approveAcceptanceBaseline(root, args);
+        return `✅ baseline ${approved.baseline_id}@${approved.baseline_version} 已批准；approved fingerprint=${acceptanceBaselineFingerprint(approved)}`;
+    });
+    tool(server, "evaluate_acceptance", "读取项目内 .pm/acceptance evaluation JSON，逐项复算证据 SHA-256，再生成不可手填、不可覆盖的正式报告。", {
+        baseline_id: IdSchema,
+        baseline_version: SemVerSchema,
+        evaluation_file: JsonPathSchema,
+    }, (args) => {
+        requireInitialized(root);
+        const result = evaluateAcceptanceFile(root, args);
+        const relativeJson = path.relative(path.resolve(root), result.json_file).replace(/\\/g, "/");
+        const relativeMarkdown = path.relative(path.resolve(root), result.markdown_file).replace(/\\/g, "/");
+        const relativeManifest = path.relative(path.resolve(root), result.manifest_file).replace(/\\/g, "/");
+        return `${result.report.verdict === "accepted" ? "✅ PASS" : "🚩 FAIL"} ${result.report.report_id} · errors=${result.report.summary.errors} · JSON=${relativeJson} · Markdown=${relativeMarkdown} · SHA256=${relativeManifest}`;
+    });
+}