@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/workflows/dag/backend-test-markdown-workflow.js

@@ -0,0 +1,1984 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { connect } from "node:net";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
+import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { parseJacocoXml, } from "./backend-test-coverage-contract.js";
+import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
+const execFileAsync = promisify(execFile);
+// Canonical contract is three digits (BE-MODULE-001). Readers accept legacy/
+// model-drift two-digit suffixes and canonicalize them in memory so one bad
+// heading width cannot collapse the whole manifest/report to zero cases.
+const CASE_ID = /\bBE-[A-Z0-9_-]+-\d{2,3}\b/g;
+const CANONICAL_CASE_ID = /\bBE-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}\b/;
+const SHARED_SETUP_REF_LINE = /^\s*引用前置\s*:\s*(\S+)\s*#\s*([A-Za-z0-9_.\-\u4e00-\u9fa5]+)\s*$/;
+const sharedSetupAnchorRe = /^SS-[A-Z0-9][A-Z0-9._-]*$/i;
+export function extractBackendSharedSetupRefs(markdown) {
+    const refs = [];
+    for (const line of markdown.split("\n")) {
+        const match = SHARED_SETUP_REF_LINE.exec(line);
+        if (match) {
+            refs.push({ raw: match[0].trim(), path: match[1], anchor: match[2] });
+        }
+    }
+    return refs;
+}
+const AC_ID = /\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
+const SECRET = /(?:password|passwd|secret|token|api[_-]?key|private[_-]?key|authorization)\s*[:=]\s*\S+/i;
+const SECRET_ASSIGNMENT = /\b(password|passwd|secret|token|api[_-]?key|private[_-]?key|authorization|cookie|set-cookie|credential)\b\s*[:=]\s*([^\r\n,;]+)/gi;
+const SECRET_VALUE = /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:ghp|github_pat|xox[baprs]|AKIA)[-_A-Za-z0-9]{12,}\b|\bsk[-_][-_A-Za-z0-9]{10,}\b/i;
+const PLACEHOLDER_SECRET_VALUE = /^(?:<[^>]+>|\$\{[^}]+\}|\*+|x+|redacted|masked|example(?:[-_].*)?|sample(?:[-_].*)?|dummy(?:[-_].*)?|test(?:[-_].*)?|your[-_].*)$/i;
+const PLACEHOLDER = /\b(?:TODO|TBD|FIXME)\b|后续补充|暂不实现|接口正常|结果正确|按实际情况处理/i;
+const CASE_SECTION_ALIASES = {
+    acceptanceCriteria: ["Acceptance Criteria", "验收标准"],
+    sourceReferences: ["Source References", "需求依据"],
+    preconditions: ["Preconditions", "前置条件"],
+    testData: ["Test Data", "测试数据"],
+    steps: ["Steps", "操作步骤"],
+    expectedResults: ["Expected Results", "预期结果"],
+    automationNotes: ["Automation Notes", "自动化映射", "自动化说明"],
+    testPurpose: ["Test Purpose", "测试目的", "测试场景"],
+};
+const REQUIRED_CASE_SECTIONS = [
+    CASE_SECTION_ALIASES.preconditions,
+    CASE_SECTION_ALIASES.steps,
+    CASE_SECTION_ALIASES.expectedResults,
+];
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function mappedScriptExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function existingPaths(root, candidates) {
+    const found = [];
+    for (const candidate of candidates) {
+        if (await exists(path.join(root, candidate)))
+            found.push(candidate);
+    }
+    return found;
+}
+function unique(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+export function requiredBackendMarkdownCaseAcIds(criteria) {
+    const downstreamEvidence = /(?:pytest|junit|html|stdout|stderr|traceability|markdown|readme|human-readable|skip|xfail|吞(?:断言|异常)|生产代码|生产配置|配置写入|写入边界|中文(?:用例|文档|结构|展示)?|用例(?:索引|结构|文档)|测试目的|需求依据|操作步骤|预期结果|自动化映射|追溯|一一映射|一一追溯|执行并产生|执行结果|测试报告|失败分类|证据)/i;
+    return unique([...criteria]
+        .filter((criterion) => !downstreamEvidence.test(criterion))
+        .flatMap((criterion) => criterion.match(/\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []));
+}
+function extractFixtures(markdown) {
+    return unique([
+        ...markdown.matchAll(/(?:@pytest\.fixture(?:\([^)]*\))?\s*(?:\r?\n)+\s*def\s+|def\s+)([A-Za-z_][A-Za-z0-9_]*)\s*\(/g),
+    ]
+        .map((match) => match[1])
+        .filter(Boolean));
+}
+export async function inspectBackendTestEnvironment(input) {
+    const pytestConfigs = await existingPaths(input.workspaceRoot, [
+        "pytest.ini",
+        "pyproject.toml",
+        "setup.cfg",
+        "tox.ini",
+    ]);
+    const testRoots = await existingPaths(input.workspaceRoot, [
+        "testcase",
+        "tests",
+        "test",
+        "src/tests",
+        "app/tests",
+    ]);
+    const conftestFiles = await existingPaths(input.workspaceRoot, [
+        "conftest.py",
+        "testcase/conftest.py",
+        "tests/conftest.py",
+        "test/conftest.py",
+    ]);
+    const serverEntries = await existingPaths(input.workspaceRoot, [
+        "server.py",
+        "app.py",
+        "main.py",
+        "manage.py",
+        "src/server.py",
+        "src/main.py",
+        "app/main.py",
+        "server.js",
+        "server.ts",
+        "src/server.js",
+        "src/server.ts",
+    ]);
+    const fixtures = [];
+    for (const relativePath of conftestFiles) {
+        const content = await readFile(path.join(input.workspaceRoot, relativePath), "utf8");
+        if (SECRET.test(content)) {
+            // Do not copy conftest content into evidence. Fixture names are still safe to discover.
+        }
+        fixtures.push(...extractFixtures(content));
+    }
+    const hasPytestHtml = /--html\b/.test(input.pytestHelp);
+    const htmlRenderer = hasPytestHtml
+        ? "pytest-html --self-contained-html"
+        : "missing pytest-html (required: pip install pytest-html)";
+    const warnings = [
+        ...(pytestConfigs.length === 0
+            ? ["No explicit pytest configuration file was found."]
+            : []),
+        ...(!hasPytestHtml
+            ? [
+                "pytest-html is not installed; the backend-test pipeline requires it to render the self-contained HTML report. Install with: pip install pytest-html",
+            ]
+            : []),
+        ...(conftestFiles.length === 0
+            ? ["No bounded conftest.py candidate was found."]
+            : []),
+        ...(serverEntries.length === 0
+            ? [
+                "No bounded server entry candidate was found; Markdown cases must document an external or library target explicitly.",
+            ]
+            : []),
+    ];
+    const lines = [
+        "# Backend Test Environment",
+        "",
+        "## Status",
+        "",
+        "PASS",
+        "",
+        "## Runtime",
+        "",
+        `- Python: ${input.pythonVersion.trim()}`,
+        `- Pytest: ${input.pytestVersion.trim()}`,
+        "- Shell environment: clean",
+        "",
+        "## Project Discovery",
+        "",
+        `- Pytest config: ${pytestConfigs.join(", ") || "not found"}`,
+        `- Existing test roots: ${testRoots.join(", ") || "not found (testcase will be generated)"}`,
+        `- Conftest files: ${conftestFiles.join(", ") || "not found"}`,
+        `- Server entry candidates: ${serverEntries.join(", ") || "not found"}`,
+        `- Fixtures: ${unique(fixtures).join(", ") || "none discovered"}`,
+        "",
+        "## HTML Report",
+        "",
+        `- Selected renderer: ${htmlRenderer}`,
+        "",
+        "## Bounded Discovery Policy",
+        "",
+        "- No .env value, credential file, dependency tree, build output, coverage output, or runtime directory was inspected.",
+        "- External readiness must be represented by an explicitly configured verify command or a documented safe health endpoint; secret values are never printed.",
+        "",
+        "## Warnings",
+        "",
+        ...(warnings.length > 0
+            ? warnings.map((warning) => `- ${warning}`)
+            : ["- None"]),
+    ];
+    return {
+        markdown: `${lines.join("\n")}\n`,
+        fixtures: unique(fixtures),
+        pytestConfigs,
+        testRoots,
+        conftestFiles,
+        serverEntries,
+    };
+}
+export async function markdownFiles(root, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const directory = path.join(root, ...resolved.markdownDir.split("/"));
+    const entries = await readdir(directory, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"))
+        .map((entry) => path.join(directory, entry.name))
+        .sort();
+}
+function canonicalBackendCaseId(value) {
+    const upper = value.toUpperCase();
+    const match = upper.match(/^(BE-[A-Z0-9_-]+)-(\d{2,3})$/);
+    if (!match)
+        return upper;
+    const modulePart = match[1]
+        .replaceAll("_", "-")
+        .replace(/-+/g, "-")
+        .replace(/-$/, "");
+    return `${modulePart}-${match[2].padStart(3, "0")}`;
+}
+function caseIdsInText(value) {
+    return unique((value.match(CASE_ID) ?? []).map(canonicalBackendCaseId));
+}
+function splitCases(markdown) {
+    const headings = [
+        ...markdown.matchAll(/^##\s+(BE-[A-Z0-9_-]+-\d{2,3})\b.*$/gm),
+    ];
+    return headings.map((match, index) => ({
+        id: canonicalBackendCaseId(match[1]),
+        rawId: match[1],
+        body: markdown.slice(match.index, headings[index + 1]?.index ?? markdown.length),
+    }));
+}
+function sectionBody(body, headings) {
+    const headingPattern = headings.map(escapeRegExp).join("|");
+    const marker = new RegExp(`^###\\s+(?:${headingPattern})\\s*$`, "mi");
+    const match = marker.exec(body);
+    if (!match)
+        return "";
+    const remainder = body.slice(match.index + match[0].length);
+    const next = /^###\s+/m.exec(remainder);
+    return remainder.slice(0, next?.index ?? remainder.length);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isTaskRelativeSourcePath(value) {
+    return /^source\/(?:需求\.md|执行约束\.md|references\/[^\s`'"()[\]{}（）。，；：#]+)$/.test(value);
+}
+function extractLegacySourceReferences(sourceSection) {
+    const inlineCode = [
+        ...sourceSection.matchAll(/`(source\/(?:需求\.md|执行约束\.md|references\/[^`\r\n]+))`/g),
+    ].map((match) => match[1].trim());
+    const plain = [
+        ...sourceSection.matchAll(/(?:^|[\s('"（])(source\/(?:需求\.md|执行约束\.md|references\/[^\s`'"()[\]{}（）。，；：#]+))(?=$|[\s`'"()（）\]，。；：#])/gm),
+    ].map((match) => match[1]);
+    return unique([...inlineCode, ...plain].filter(isTaskRelativeSourcePath));
+}
+function extractSourceReferences(input) {
+    const citedPaths = extractLegacySourceReferences(input.sourceSection);
+    if (!input.sourceBinding) {
+        return citedPaths;
+    }
+    const boundMatches = input.sourceBinding.sources
+        .map((source) => source.path)
+        .filter(isTaskRelativeSourcePath)
+        .filter((sourcePath) => {
+        const escaped = escapeRegExp(sourcePath);
+        return new RegExp(`(?:^|[\\s(\`'\"（])${escaped}(?=$|[\\s)\`'\"）\\]，。；：#])`, "m").test(input.sourceSection);
+    });
+    // Preserve explicitly cited unknown paths so resolveBoundSourceReference()
+    // rejects them instead of silently accepting a nearby bound prefix.
+    return unique([...boundMatches, ...citedPaths]);
+}
+function hasStructuredMarkdownTable(value, headerPattern) {
+    const rows = value.split(/\r?\n/).filter((line) => /^\s*\|.*\|\s*$/.test(line));
+    if (rows.length < 3 || !headerPattern.test(rows[0]))
+        return false;
+    return /^\s*\|(?:\s*:?-{3,}:?\s*\|)+\s*$/i.test(rows[1]) && rows.slice(2).some((row) => row.split("|").some((cell) => cell.trim().length > 0));
+}
+function hasNumberedListItem(value) {
+    return (/^\s*\d+[.)]\s+\S+/m.test(value) ||
+        /^\s*\|\s*\d+\s*\|\s*\S+/m.test(value) ||
+        hasStructuredMarkdownTable(value, /(?:步骤|操作|测试点|参数|step|action|operation|test point|parameter)/i));
+}
+function hasAssertableExpectedResult(value) {
+    return (/^\s*(?:\d+[.)]|[-*+])\s+\S+/m.test(value) ||
+        hasStructuredMarkdownTable(value, /(?:预期|期望|断言|状态|结果|expected|assert|status|result)/i));
+}
+function resolveBoundSourceReference(input) {
+    if (!input.sourceBinding) {
+        return path.join(input.workspaceRoot, input.sourceRef);
+    }
+    const member = input.sourceBinding.sources.find((source) => source.path === input.sourceRef);
+    if (!member) {
+        throw new Error(`source reference is not present in DAG sourceBinding: ${input.sourceRef}`);
+    }
+    const taskRoot = path.join(input.workspaceRoot, ".harness", "tasks", input.sourceBinding.taskId);
+    const resolved = path.resolve(taskRoot, member.path);
+    const relative = path.relative(taskRoot, resolved);
+    if (relative.startsWith("..") ||
+        path.isAbsolute(relative)) {
+        throw new Error(`unsafe task-relative source path: ${input.sourceRef}`);
+    }
+    return resolved;
+}
+function leadingWhitespace(value) {
+    return value.match(/^\s*/)?.[0].length ?? 0;
+}
+function isCleanupStatement(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+        return true;
+    if (/^(?:with|if)\b/.test(trimmed))
+        return false;
+    if (/\b(?:assert|pytest\.fail|raise)\b/.test(trimmed))
+        return false;
+    if (/\b[A-Za-z_][A-Za-z0-9_.]*request\s*\(\s*["']DELETE["']/i.test(trimmed))
+        return true;
+    return /(?:^|[._])(?:cleanup|clean_up|teardown|delete|remove|close|release|rollback|disconnect|dispose|unlink)(?:[_(.]|$)/i.test(trimmed);
+}
+function findUnsafeSwallowedException(source) {
+    const lines = source.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const exceptMatch = lines[index].match(/^(\s*)except(?:\s+([^:]+))?\s*:\s*(?:(pass)\s*)?(?:#.*)?$/);
+        if (!exceptMatch)
+            continue;
+        const indent = exceptMatch[1].length;
+        const inlinePass = exceptMatch[3] === "pass";
+        let handlerIndex = index + 1;
+        while (!inlinePass &&
+            handlerIndex < lines.length &&
+            (!lines[handlerIndex].trim() || lines[handlerIndex].trim().startsWith("#"))) {
+            handlerIndex += 1;
+        }
+        if (!inlinePass &&
+            (handlerIndex >= lines.length ||
+                leadingWhitespace(lines[handlerIndex]) <= indent ||
+                lines[handlerIndex].trim() !== "pass")) {
+            continue;
+        }
+        const exceptionType = exceptMatch[2]?.trim() || "bare except";
+        const narrowDecodeTypes = exceptionType
+            .replace(/[()]/g, "")
+            .split(",")
+            .map((value) => value.trim())
+            .filter(Boolean);
+        const precedingDecodeRegion = lines.slice(Math.max(0, index - 8), index).join("\n");
+        if (narrowDecodeTypes.length > 0 &&
+            narrowDecodeTypes.every((value) => value === "UnicodeDecodeError" || value === "json.JSONDecodeError") &&
+            /\.json\s*\(\s*\)/.test(precedingDecodeRegion)) {
+            continue;
+        }
+        if (!new Set(["requests.RequestException", "urllib.error.URLError", "httpx.RequestError"]).has(exceptionType)) {
+            return exceptionType;
+        }
+        let tryIndex = index - 1;
+        while (tryIndex >= 0) {
+            const candidate = lines[tryIndex];
+            if (!candidate.trim() || candidate.trim().startsWith("#")) {
+                tryIndex -= 1;
+                continue;
+            }
+            if (leadingWhitespace(candidate) === indent &&
+                candidate.trim() === "try:") {
+                break;
+            }
+            if (leadingWhitespace(candidate) <= indent)
+                break;
+            tryIndex -= 1;
+        }
+        if (tryIndex < 0 || lines[tryIndex].trim() !== "try:") {
+            return exceptionType;
+        }
+        const tryBody = lines.slice(tryIndex + 1, index);
+        const executable = tryBody.filter((line) => line.trim() && !line.trim().startsWith("#"));
+        if (executable.length === 0 ||
+            executable.some((line) => leadingWhitespace(line) <= indent || !isCleanupStatement(line))) {
+            return exceptionType;
+        }
+    }
+    return null;
+}
+function resolvesSharedLoggingHelper(source) {
+    return /\b(?:LoggedHttpClient|LoggedApiClient|LoggingHttpClient|HttpLoggingClient)\b/.test(source);
+}
+function httpLoggingFindings(relativeScript, source) {
+    if (resolvesSharedLoggingHelper(source))
+        return [];
+    const hasHttpRequest = /\b(?:requests\.(?:get|post|put|patch|delete|request)|httpx\.(?:get|post|put|patch|delete|request)|(?:client|session|api_client)\.(?:get|post|put|patch|delete|request))\s*\(/i.test(source);
+    if (!hasHttpRequest)
+        return [];
+    const findings = [];
+    const hasRequestLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:request|请求)[^\n]*(?:method|url|path|params|query|json|body|payload|参数)/i.test(source)
+        || /["']record["']\s*:\s*["']request["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log[A-Za-z0-9_]*\s*\(\s*["'](?:HTTP|API)_REQUEST["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /print\s*\(\s*f?["'](?:HTTP|API)(?:_|\s+)REQUEST\b/i.test(source) && /["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log\s*\(\s*["']REQUEST["'][\s\S]{0,600}["'](?:method|url|path|params|query|json|body|payload)["']\s*:/i.test(source);
+    const hasResponseLog = /(?:print|log(?:ger)?\.(?:debug|info|warning|error))\s*\([^\n]*(?:response|响应)[^\n]*(?:status|status_code|body|json|text|result|结果)/i.test(source)
+        || /["']record["']\s*:\s*["']response["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log[A-Za-z0-9_]*\s*\(\s*["'](?:HTTP|API)_RESPONSE["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /print\s*\(\s*f?["'](?:HTTP|API)(?:_|\s+)RESPONSE\b/i.test(source) && /["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source)
+        || /\b[A-Za-z_][A-Za-z0-9_]*log\s*\(\s*["']RESPONSE["'][\s\S]{0,600}["'](?:status|status_code|body|json|text|result)["']\s*:/i.test(source);
+    const hasSanitizer = /\b(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(|\b[A-Za-z0-9_]*(?:sanitize|sanitise|redact|mask)[A-Za-z0-9_]*\s*\(/i.test(source)
+        || /(?:SENSITIVE_KEYS|sensitive_keys)[\s\S]{0,1600}["']<redacted>["']/i.test(source);
+    const hasBoundedOutput = /(?:MAX_[A-Z_]*(?:LOG|BODY|RESPONSE)|max_(?:log|body|response)|truncate|truncat|\[:\s*\d{3,}\s*\])/i.test(source);
+    if (!hasRequestLog)
+        findings.push(`request logging evidence is missing in mapped backend pytest: ${relativeScript}`);
+    if (!hasResponseLog)
+        findings.push(`response logging evidence is missing in mapped backend pytest: ${relativeScript}`);
+    if (!hasSanitizer)
+        findings.push(`recursive redaction evidence is missing in mapped backend pytest: ${relativeScript}`);
+    if (!hasBoundedOutput)
+        findings.push(`bounded log truncation evidence is missing in mapped backend pytest: ${relativeScript}`);
+    return findings;
+}
+function markdownSecretFindings(relativeFile, markdown) {
+    const findings = [];
+    if (SECRET_VALUE.test(markdown)) {
+        findings.push(`secret-shaped value detected in ${relativeFile}`);
+    }
+    for (const match of markdown.matchAll(SECRET_ASSIGNMENT)) {
+        const value = match[2]
+            .trim()
+            .replace(/^bearer\s+/i, "")
+            .replace(/^['"`]|['"`]$/g, "");
+        if (!PLACEHOLDER_SECRET_VALUE.test(value)) {
+            findings.push(`secret-shaped ${match[1].toLowerCase()} value detected in ${relativeFile}`);
+        }
+    }
+    return unique(findings);
+}
+export function hasBlockingBackendMarkdownSafetyFindings(report) {
+    return /^## Safety Status\s*\r?\n\s*BLOCKED\s*$/m.test(report);
+}
+export function hasBlockingBackendMarkdownModuleStemFindings(report) {
+    return /^## Module Stem Status\s*\r?\n\s*BLOCKED\s*$/m.test(report);
+}
+export async function validateBackendMarkdownCases(input) {
+    const layout = input.layout ?? resolveBackendTestLayout(undefined);
+    const findings = [];
+    const safetyFindings = [];
+    const moduleStemFindings = [];
+    let files = [];
+    try {
+        files = await markdownFiles(input.workspaceRoot, layout);
+    }
+    catch {
+        findings.push(`missing ${layout.markdownDir} directory`);
+    }
+    const readme = path.join(input.workspaceRoot, ...layout.readmePath.split("/"));
+    if (!(await exists(readme)))
+        findings.push(`missing ${layout.readmePath}`);
+    const moduleFiles = files.filter((file) => path.basename(file).toLowerCase() !== "readme.md");
+    if (moduleFiles.length === 0)
+        findings.push(`no ${layout.markdownDir} module case file found`);
+    const seen = new Map();
+    const coveredAc = new Set();
+    let caseCount = 0;
+    for (const file of moduleFiles) {
+        const relativeFile = path.relative(input.workspaceRoot, file).replaceAll(path.sep, "/");
+        if (isPriorityOnlyBackendTestModuleStem(path.basename(file, path.extname(file)))) {
+            moduleStemFindings.push(`priority-only-module-stem: ${relativeFile}; regenerate the README Module Index with a stable business resource/domain stem`);
+        }
+        const markdown = await readFile(file, "utf8");
+        safetyFindings.push(...markdownSecretFindings(relativeFile, markdown));
+        if (!markdown.trim()) {
+            findings.push(`empty Markdown case file: ${relativeFile}`);
+            continue;
+        }
+        if (PLACEHOLDER.test(markdown)) {
+            findings.push(`placeholder or non-assertable wording in ${relativeFile}`);
+        }
+        const sharedSetupRefs = extractBackendSharedSetupRefs(markdown);
+        for (const ref of sharedSetupRefs) {
+            if (!input.sharedSetup) {
+                findings.push(`shared setup reference without a bound document: ${ref.raw} in ${relativeFile}`);
+            }
+            else if (ref.path !== input.sharedSetup.path) {
+                findings.push(`shared setup reference cites unbound path ${ref.path} (bound: ${input.sharedSetup.path}) in ${relativeFile}`);
+            }
+            else if (ref.anchor !== "SS-DEFAULT" && !sharedSetupAnchorRe.test(ref.anchor)) {
+                findings.push(`shared setup reference anchor is not a stable SS ID and not SS-DEFAULT: ${ref.raw} in ${relativeFile}`);
+            }
+        }
+        const cases = splitCases(markdown);
+        if (cases.length === 0) {
+            findings.push(`no BE-<MODULE>-<NNN> case heading in ${relativeFile}`);
+            continue;
+        }
+        for (const testCase of cases) {
+            caseCount += 1;
+            if (!CANONICAL_CASE_ID.test(testCase.rawId)) {
+                findings.push(`${testCase.rawId} uses a non-canonical Case ID; use ${testCase.id} (hyphen-separated module, three-digit sequence)`);
+            }
+            const previous = seen.get(testCase.id);
+            if (previous) {
+                findings.push(`duplicate case id ${testCase.id}: ${previous} and ${relativeFile}`);
+            }
+            else {
+                seen.set(testCase.id, relativeFile);
+            }
+            for (const sectionAliases of REQUIRED_CASE_SECTIONS) {
+                const sectionPattern = sectionAliases.map(escapeRegExp).join("|");
+                if (!new RegExp(`^###\\s+(?:${sectionPattern})\\s*$`, "mi").test(testCase.body)) {
+                    findings.push(`${testCase.id} missing section: ${sectionAliases.join(" or ")}`);
+                }
+            }
+            const bindingFinding = markdownTestPointBindingFinding(testCase.id, testCase.body);
+            if (bindingFinding)
+                findings.push(bindingFinding);
+            const payloadLabelFinding = markdownPayloadLabelFinding(testCase.id, testCase.body);
+            if (payloadLabelFinding)
+                findings.push(payloadLabelFinding);
+            const scenarioIntentFinding = markdownScenarioIntentFinding(testCase.id, testCase.body);
+            if (scenarioIntentFinding)
+                findings.push(scenarioIntentFinding);
+            const acIds = unique(testCase.body.match(AC_ID) ?? []);
+            acIds.forEach((id) => coveredAc.add(id));
+            const steps = sectionBody(testCase.body, CASE_SECTION_ALIASES.steps);
+            const expected = sectionBody(testCase.body, CASE_SECTION_ALIASES.expectedResults);
+            if (!hasNumberedListItem(steps)) {
+                findings.push(`${testCase.id} has no numbered executable step`);
+            }
+            if (!hasAssertableExpectedResult(expected)) {
+                findings.push(`${testCase.id} has no structured expected result`);
+            }
+            const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, layout);
+            const mappedScripts = extractMappedPytestScripts(testCase.body);
+            if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
+                // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and keep only assertion/cross-cutting TPs.
+            }
+            else if (mappedScripts.length === 0) {
+                findings.push(`${testCase.id} has no mapped pytest script in Automation Notes/自动化映射 (expected ${expectedScript} from module ${path.basename(relativeFile)})`);
+            }
+            else {
+                for (const script of mappedScripts) {
+                    if (script !== expectedScript) {
+                        findings.push(`${testCase.id} automation mapping ${script} must equal module one-to-one path ${expectedScript} (from ${path.basename(relativeFile)})`);
+                    }
+                }
+            }
+        }
+    }
+    const missing = input.requiredRequirementIds.filter((id) => !coveredAc.has(id));
+    if (missing.length > 0) {
+        findings.push(`required AC IDs are not covered by final Markdown cases: ${missing.join(", ")}`);
+    }
+    findings.push(...moduleStemFindings);
+    const status = findings.length === 0 ? "PASS" : "FAIL";
+    const report = [
+        "# Backend Markdown Case Validation",
+        "",
+        "## Status",
+        "",
+        status,
+        "",
+        `- Markdown files: ${files.length}`,
+        `- Module files: ${moduleFiles.length}`,
+        `- Cases: ${caseCount}`,
+        `- Covered AC IDs: ${[...coveredAc].sort().join(", ") || "none"}`,
+        `- Environment evidence present: ${input.environmentMarkdown.trim() ? "yes" : "no"}`,
+        `- Findings: ${findings.length}`,
+        "- Required sections: Preconditions/前置条件, Steps/操作步骤, Expected Results/预期结果",
+        "- Source-reference validity check: not applied",
+        "- Markdown quality sensitive-information finding: not advisory; see Safety Status",
+        "",
+        "## Module Stem Status",
+        "",
+        moduleStemFindings.length > 0 ? "BLOCKED" : "PASS",
+        "",
+        ...(moduleStemFindings.length > 0
+            ? moduleStemFindings.map((finding) => `- ${finding}`)
+            : ["- All Markdown modules use non-priority business stems."]),
+        "",
+        "## Safety Status",
+        "",
+        safetyFindings.length > 0 ? "BLOCKED" : "PASS",
+        "",
+        ...(safetyFindings.length > 0
+            ? safetyFindings.map((finding) => `- ${finding}`)
+            : ["- No secret-shaped values detected."]),
+        "",
+        "## Findings",
+        "",
+        ...(findings.length > 0 ? findings.map((finding) => `- ${finding}`) : ["- None"]),
+    ];
+    return `${report.join("\n")}\n`;
+}
+function collectMarkdownCaseIds(markdown) {
+    return splitCases(markdown).map((testCase) => testCase.id);
+}
+/**
+ * Derive the stable module stem used for Markdown ↔ pytest one-to-one mapping.
+ * `testcase/md/<module>.md` → stem → `testcase/test_<stem>.py`.
+ * Example: `BE-HEALTH.md` / `be-health.md` / `order-api.md` → `be_health` / `order_api`.
+ */
+export function normalizeBackendTestModuleStem(moduleFileName) {
+    const base = path.basename(moduleFileName).replace(/\.md$/i, "");
+    const stem = base
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .replace(/_+/g, "_");
+    if (!stem) {
+        throw new Error(`cannot derive backend-test module stem from: ${moduleFileName}`);
+    }
+    return stem;
+}
+/** Expected pytest script path for a Markdown module file (basename or relative path). */
+export function expectedBackendTestPytestScriptForMarkdownModule(moduleFileName, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    return `${resolved.scriptDir}/test_${normalizeBackendTestModuleStem(moduleFileName)}.py`;
+}
+function extractMappedPytestScripts(testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return [];
+    return unique([...automation.matchAll(/`?(testcase\/[A-Za-z0-9_./-]*test_[A-Za-z0-9_.-]*\.py)`?/gi)]
+        .map((match) => match[1].replaceAll("\\", "/"))
+        .filter((value) => !value.includes("..")));
+}
+function markdownScenarioIntentFinding(testCaseId, testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return null;
+    const variantLine = /^(?:\s*[-*+]\s*)?(?:变体测试点|Variant Test Points)\s*[：:]\s*(.*)$/im.exec(automation)?.[1] ?? "";
+    const variants = unique(variantLine.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
+    if (variants.length === 0)
+        return null;
+    const localIntentIds = unique([...testCaseBody.matchAll(/(?:场景意图|Scenario Intent)\s*[：:]\s*(TP-[A-Z0-9-]+)/gi)].map((match) => match[1].toUpperCase()));
+    const missing = variants.filter((id) => !localIntentIds.includes(id.toUpperCase()));
+    return missing.length > 0
+        ? `${testCaseId} variant Test Points require a local Scenario Intent line inside the same Case: missing=${missing.join(", ")}`
+        : null;
+}
+function markdownPayloadLabelFinding(testCaseId, testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return null;
+    const payloadLabel = /Payload (?:Contract|Required Paths|Allowed Paths|Enum)\s*[:：]/gi;
+    for (const line of automation.split(/\r?\n/)) {
+        const matches = line.match(payloadLabel) ?? [];
+        if (matches.length === 0)
+            continue;
+        if (matches.length !== 1 || !/^\s*[-*+]\s*Payload (?:Contract|Required Paths|Allowed Paths|Enum)\s*[:：]/i.test(line)) {
+            return `${testCaseId} payload contract labels must each occupy one independent machine-readable list line`;
+        }
+    }
+    return null;
+}
+function markdownTestPointBindingFinding(testCaseId, testCaseBody) {
+    const declaredSection = sectionBody(testCaseBody, ["测试点", "Test Points"]);
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!declaredSection.trim() || !automation.trim())
+        return null;
+    const declared = unique(declaredSection.match(/\bTP-[A-Z0-9-]+\b/g) ?? []);
+    const bindingLines = [
+        /^(?:\s*[-*+]\s*)?(?:变体测试点|Variant Test Points)\s*[：:]\s*(.*)$/gim,
+        /^(?:\s*[-*+]\s*)?(?:场景断言测试点|Assertion Test Points)\s*[：:]\s*(.*)$/gim,
+        /^(?:\s*[-*+]\s*)?(?:横切证据测试点|Cross-Cutting Test Points)\s*[：:]\s*(.*)$/gim,
+    ];
+    const bound = unique(bindingLines.flatMap((pattern) => [...automation.matchAll(pattern)].flatMap((match) => match[1]?.match(/\bTP-[A-Z0-9-]+\b/g) ?? [])));
+    const missingBindings = declared.filter((id) => !bound.includes(id));
+    const undeclaredBindings = bound.filter((id) => !declared.includes(id));
+    if (missingBindings.length === 0 && undeclaredBindings.length === 0)
+        return null;
+    return `${testCaseId} Test Point set must exactly equal variant/assertion/cross-cutting binding union: unclassified=${missingBindings.join(", ") || "none"}; undeclared-bindings=${undeclaredBindings.join(", ") || "none"}`;
+}
+function isEvidenceOnlyMarkdownCaseBody(testCaseBody) {
+    const automation = sectionBody(testCaseBody, CASE_SECTION_ALIASES.automationNotes);
+    if (!automation.trim())
+        return false;
+    const scriptLine = /^\s*[-*+]\s*(?:脚本|script)\s*[：:]\s*(.*)$/im.exec(automation)?.[1]?.replaceAll("`", "").trim() ??
+        "";
+    const primaryLine = /^\s*[-*+]\s*(?:primary symbol|Primary Symbol|主测试符号)\s*[：:]\s*(.*)$/im.exec(automation)?.[1]
+        ?.replaceAll("`", "")
+        .trim() ?? "";
+    const noneLike = /^(?:none|无|n\/a|not-applicable)(?:\s*[（(].*[）)])?$/i;
+    const scriptIsNone = noneLike.test(scriptLine) || scriptLine.length === 0;
+    const primaryIsNone = noneLike.test(primaryLine) || primaryLine.length === 0;
+    const hasMappedScript = extractMappedPytestScripts(testCaseBody).length > 0;
+    const hasPrimary = /\btest_[A-Za-z0-9_]+\b/.test(primaryLine);
+    const hasVariant = /(?:变体测试点|Variant Test Points)\s*[：:]\s*(?!\s*(?:无|none)\b)[^\n]*\bTP-[A-Z0-9-]+/i.test(automation);
+    const hasAssertionOrCross = /(?:场景断言测试点|Assertion Test Points|横切证据测试点|Cross-Cutting Test Points)\s*[：:]\s*(?!\s*(?:无|none)\b)[^\n]*\bTP-[A-Z0-9-]+/i.test(automation);
+    return scriptIsNone && primaryIsNone && !hasMappedScript && !hasPrimary && !hasVariant && hasAssertionOrCross;
+}
+function isSafeBackendPytestScript(script, workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const absolute = path.resolve(workspaceRoot, script);
+    const relative = path.relative(workspaceRoot, absolute).replaceAll(path.sep, "/");
+    const allowedRoots = [`${resolved.testRoot}/`];
+    return (!relative.startsWith("..") &&
+        !path.isAbsolute(relative) &&
+        allowedRoots.some((prefix) => script.startsWith(prefix)) &&
+        !script.includes("..") &&
+        /^test_.*\.py$/i.test(path.basename(script)));
+}
+function testFunctionRegion(input) {
+    const functionLineStart = input.source.lastIndexOf("\n", input.functionIndex - 1) + 1;
+    const functionLine = input.source.slice(functionLineStart, input.functionHeaderEnd);
+    const indent = functionLine.match(/^\s*/)?.[0] ?? "";
+    let regionStart = functionLineStart;
+    let cursor = functionLineStart;
+    while (cursor > 0) {
+        const previousEnd = cursor - 1;
+        const previousStart = input.source.lastIndexOf("\n", previousEnd - 1) + 1;
+        const previousLine = input.source.slice(previousStart, previousEnd).replace(/\r$/, "");
+        if (!previousLine.trim())
+            break;
+        if (new RegExp(`^${escapeRegExp(indent)}@`).test(previousLine)) {
+            regionStart = previousStart;
+            cursor = previousStart;
+            continue;
+        }
+        break;
+    }
+    const lines = input.source.slice(input.functionHeaderEnd).split(/\r?\n/);
+    let consumed = 0;
+    for (const line of lines) {
+        const boundary = line.match(/^(\s*)(?:(?:async\s+)?def|class)\s+[A-Za-z_][A-Za-z0-9_]*\b/);
+        if (boundary && boundary[1].length <= indent.length)
+            break;
+        consumed += line.length + 1;
+    }
+    const regionEnd = Math.min(input.source.length, input.functionHeaderEnd + consumed);
+    return input.source
+        .slice(regionStart, regionEnd)
+        .split(/\r?\n/)
+        .filter((line) => !line.trimStart().startsWith("#"))
+        .join("\n");
+}
+function symbolCaseId(symbol) {
+    const match = symbol.match(/^test_(BE(?:_[A-Z0-9]+)+?_\d{2,3})(?:_|$)/i);
+    return match
+        ? canonicalBackendCaseId(match[1].replaceAll("_", "-"))
+        : undefined;
+}
+export async function validateBackendMarkdownTraceability(workspaceRoot, layout) {
+    const files = await markdownFiles(workspaceRoot, layout);
+    const markdownIds = new Set();
+    const expectedIdsByScript = new Map();
+    const findings = [];
+    for (const file of files) {
+        if (path.basename(file).toLowerCase() === "readme.md")
+            continue;
+        const content = await readFile(file, "utf8");
+        for (const testCase of splitCases(content)) {
+            const scripts = extractMappedPytestScripts(testCase.body);
+            if (isEvidenceOnlyMarkdownCaseBody(testCase.body)) {
+                continue;
+            }
+            markdownIds.add(testCase.id);
+            if (scripts.length === 0) {
+                findings.push(`${testCase.id} has no mapped pytest script in Automation Notes/自动化映射`);
+                continue;
+            }
+            for (const script of scripts) {
+                const bucket = expectedIdsByScript.get(script) ?? new Set();
+                bucket.add(testCase.id);
+                expectedIdsByScript.set(script, bucket);
+            }
+        }
+    }
+    const resolvedLayout = layout ?? resolveBackendTestLayout(undefined);
+    const mappings = new Map();
+    const automationIds = new Set();
+    let requestResponseLoggingFindingCount = 0;
+    for (const [relativeScript, expectedIds] of expectedIdsByScript) {
+        const absolute = path.resolve(workspaceRoot, relativeScript);
+        const relative = path.relative(workspaceRoot, absolute);
+        if (relative.startsWith("..") ||
+            path.isAbsolute(relative) ||
+            !relativeScript.startsWith(`${resolvedLayout.testRoot}/`) ||
+            !/^test_.*\.py$/i.test(path.basename(relativeScript))) {
+            findings.push(`unsafe mapped pytest script: ${relativeScript}`);
+            continue;
+        }
+        if (!(await exists(absolute))) {
+            findings.push(`mapped pytest script is missing: ${relativeScript}`);
+            continue;
+        }
+        const content = await readFile(absolute, "utf8");
+        const loggingFindings = httpLoggingFindings(relativeScript, content);
+        requestResponseLoggingFindingCount += loggingFindings.length;
+        findings.push(...loggingFindings);
+        if (/pytest\.(?:skip|xfail)\s*\(|@pytest\.mark\.(?:skip|xfail)\b/.test(content)) {
+            findings.push(`skip/xfail is forbidden in mapped backend pytest: ${relativeScript}`);
+        }
+        const unsafeSwallowedException = findUnsafeSwallowedException(content);
+        if (unsafeSwallowedException) {
+            findings.push(`swallowed exception is forbidden in mapped backend pytest: ${relativeScript} (${unsafeSwallowedException})`);
+        }
+        for (const match of content.matchAll(/^(\s*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]+)\s*\([^)]*\)\s*(?:->\s*[^:\r\n]+)?\s*:/gm)) {
+            const symbol = match[2];
+            const region = testFunctionRegion({
+                source: content,
+                functionIndex: match.index,
+                functionHeaderEnd: match.index + match[0].length,
+            });
+            const associatedIds = new Set(caseIdsInText(region));
+            const fromSymbol = symbolCaseId(symbol);
+            if (fromSymbol)
+                associatedIds.add(fromSymbol);
+            for (const id of associatedIds) {
+                automationIds.add(id);
+                if (!expectedIds.has(id))
+                    continue;
+                const bucket = mappings.get(id) ?? [];
+                bucket.push(`${relativeScript}#${symbol}`);
+                mappings.set(id, bucket);
+            }
+        }
+    }
+    const missing = [...markdownIds].filter((id) => !mappings.has(id));
+    const multiple = [...mappings]
+        .filter(([, refs]) => refs.length > 1)
+        .map(([id]) => id);
+    const extra = [...automationIds].filter((id) => !markdownIds.has(id));
+    if (missing.length > 0) {
+        findings.push(`Markdown Case IDs without pytest mapping: ${missing.join(", ")}`);
+    }
+    const mappingCount = [...mappings.values()].reduce((total, refs) => total + refs.length, 0);
+    return ([
+        "# Backend Test Traceability",
+        "",
+        "## Status",
+        "",
+        findings.length === 0 ? "PASS" : "FAIL",
+        "",
+        `- Markdown Case IDs: ${markdownIds.size}`,
+        `- Covered Markdown Case IDs: ${mappings.size}`,
+        `- Pytest mappings: ${mappingCount}`,
+        `- Scanned pytest scripts: ${expectedIdsByScript.size}`,
+        `- Missing mappings: ${missing.length}${missing.length ? ` (${missing.join(", ")})` : ""}`,
+        `- Multiple mappings: ${multiple.length}${multiple.length ? ` (${multiple.join(", ")})` : ""}`,
+        `- Extra automation Case IDs: ${extra.length}${extra.length ? ` (${extra.join(", ")})` : ""}`,
+        `- Request/response logging findings: ${requestResponseLoggingFindingCount}`,
+        "- Logging scope: mapped scripts with detected HTTP client calls; findings are advisory",
+        "- Scan scope: pytest scripts explicitly mapped by Markdown cases only",
+        "",
+        "## Findings",
+        "",
+        ...(findings.length > 0 ? findings.map((finding) => `- ${finding}`) : ["- None"]),
+    ].join("\n") + "\n");
+}
+export async function resolveBackendTestMappedPytestScripts(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const files = await markdownFiles(workspaceRoot, resolved);
+    const expectedScripts = new Set();
+    const existingScripts = new Set();
+    const missingScripts = new Set();
+    const scriptOwners = new Map();
+    const recordScript = (script, owner, present) => {
+        const previousOwner = scriptOwners.get(script);
+        if (previousOwner && previousOwner !== owner) {
+            throw new Error(`conflicting Markdown pytest mapping: ${previousOwner} and ${owner} both map ${script}`);
+        }
+        scriptOwners.set(script, owner);
+        expectedScripts.add(script);
+        if (present)
+            existingScripts.add(script);
+        else
+            missingScripts.add(script);
+    };
+    for (const file of files) {
+        if (path.basename(file).toLowerCase() === "readme.md")
+            continue;
+        const relativeFile = path.relative(workspaceRoot, file).replaceAll(path.sep, "/");
+        const expectedScript = expectedBackendTestPytestScriptForMarkdownModule(relativeFile, resolved);
+        const markdown = await readFile(file, "utf8");
+        const mappedFromModule = new Set();
+        for (const testCase of splitCases(markdown)) {
+            for (const script of extractMappedPytestScripts(testCase.body)) {
+                mappedFromModule.add(script);
+            }
+        }
+        // Prefer explicit mappings, but recover to the deterministic module stem path
+        // when the model wrote the correct one-to-one file while Markdown still names
+        // a drifted script (common: health.md maps test_health.py but writer emitted
+        // test_be_health.py for BE-HEALTH.md, or the reverse). If neither exists, the
+        // deterministic module path is the only path a bounded repair may create.
+        if (mappedFromModule.size === 0) {
+            if (await mappedScriptExists(path.resolve(workspaceRoot, expectedScript))) {
+                recordScript(expectedScript, relativeFile, true);
+            }
+            continue;
+        }
+        for (const script of mappedFromModule) {
+            if (!isSafeBackendPytestScript(script, workspaceRoot, resolved)) {
+                throw new Error(`unsafe mapped pytest script: ${script}`);
+            }
+            if (await mappedScriptExists(path.resolve(workspaceRoot, script))) {
+                recordScript(script, relativeFile, true);
+                continue;
+            }
+            if (!isSafeBackendPytestScript(expectedScript, workspaceRoot, resolved)) {
+                throw new Error(`unsafe mapped pytest script: ${expectedScript}`);
+            }
+            recordScript(expectedScript, relativeFile, await mappedScriptExists(path.resolve(workspaceRoot, expectedScript)));
+        }
+    }
+    if (expectedScripts.size === 0) {
+        throw new Error("no pytest scripts are mapped by final Markdown cases");
+    }
+    return {
+        expectedScripts: unique(expectedScripts),
+        existingScripts: unique(existingScripts),
+        missingScripts: unique(missingScripts),
+    };
+}
+export async function collectBackendTestMappedPytestScripts(workspaceRoot, layout) {
+    const resolution = await resolveBackendTestMappedPytestScripts(workspaceRoot, layout);
+    if (resolution.missingScripts.length > 0) {
+        throw new Error(`mapped pytest script is missing: ${resolution.missingScripts[0]}`);
+    }
+    return resolution.existingScripts;
+}
+function cleanCaseTitle(rawHeading, id) {
+    return rawHeading
+        .replace(/^##\s+/, "")
+        // Strip either canonical or compatible two-digit heading ID.
+        .replace(/^BE-[A-Z0-9_-]+-\d{2,3}\s*(?:[｜|—–-]\s*)?/i, "")
+        .trim() || id;
+}
+export async function collectBackendTestHumanCaseCatalog(workspaceRoot, layout) {
+    const files = await markdownFiles(workspaceRoot, layout);
+    const catalog = new Map();
+    for (const file of files) {
+        if (path.basename(file).toLowerCase() === "readme.md")
+            continue;
+        const markdown = await readFile(file, "utf8");
+        for (const testCase of splitCases(markdown)) {
+            const heading = testCase.body.match(/^##\s+.*$/m)?.[0] ?? testCase.id;
+            const purpose = sectionBody(testCase.body, CASE_SECTION_ALIASES.testPurpose).trim();
+            const fallbackScenario = sectionBody(testCase.body, CASE_SECTION_ALIASES.expectedResults)
+                .replace(/^\s*(?:\d+[.)]|[-*+])\s+/gm, "")
+                .replace(/\s+/g, " ")
+                .trim();
+            catalog.set(testCase.id, {
+                id: testCase.id,
+                title: cleanCaseTitle(heading, testCase.id),
+                scenario: purpose.replace(/\s+/g, " ").trim() || fallbackScenario || "详见 Markdown 用例步骤与预期结果。",
+                markdownPath: path.relative(workspaceRoot, file).replaceAll(path.sep, "/"),
+                testFunctions: [],
+            });
+        }
+    }
+    const resolvedLayout = layout ?? resolveBackendTestLayout(undefined);
+    const testcaseRoot = path.join(workspaceRoot, ...resolvedLayout.testRoot.split("/"));
+    const pythonFiles = [];
+    async function walk(directory) {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const absolute = path.join(directory, entry.name);
+            if (entry.isDirectory())
+                await walk(absolute);
+            else if (/^test_.*\.py$/i.test(entry.name))
+                pythonFiles.push(absolute);
+        }
+    }
+    if (await exists(testcaseRoot))
+        await walk(testcaseRoot);
+    for (const file of pythonFiles) {
+        const content = await readFile(file, "utf8");
+        for (const match of content.matchAll(/^(\s*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]+)\s*\([^)]*\)\s*(?:->\s*[^:\r\n]+)?\s*:/gm)) {
+            const symbol = match[2];
+            const region = testFunctionRegion({ source: content, functionIndex: match.index, functionHeaderEnd: match.index + match[0].length });
+            const ids = new Set(caseIdsInText(region));
+            const fromSymbol = symbolCaseId(symbol);
+            if (fromSymbol)
+                ids.add(fromSymbol);
+            for (const id of ids) {
+                const item = catalog.get(id);
+                if (!item)
+                    continue;
+                item.scriptPath = path.relative(workspaceRoot, file).replaceAll(path.sep, "/");
+                if (!item.testFunctions.includes(symbol))
+                    item.testFunctions.push(symbol);
+            }
+        }
+    }
+    return [...catalog.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function junitCaseId(name) {
+    return symbolCaseId(name) ?? caseIdsInText(name)[0];
+}
+/** Prefer function-name Case ID; fall back to first BE-* in free text (docstring/log). */
+function extractCaseIdFromText(value) {
+    if (!value?.trim())
+        return undefined;
+    return junitCaseId(value) ?? caseIdsInText(value)[0];
+}
+function resolveReportCaseId(result, catalog) {
+    const fromName = extractCaseIdFromText(result.name);
+    if (fromName && catalog.has(fromName))
+        return fromName;
+    if (fromName)
+        return fromName;
+    // Match catalog by pytest function/method name when Case ID is only in docstring/md.
+    const byFunction = [...catalog.values()].find((item) => item.testFunctions.includes(result.name));
+    if (byFunction)
+        return byFunction.id;
+    const fromStdout = extractCaseIdFromText(result.stdout);
+    if (fromStdout && catalog.has(fromStdout))
+        return fromStdout;
+    if (fromStdout)
+        return fromStdout;
+    const fromDetails = extractCaseIdFromText(result.details);
+    if (fromDetails && catalog.has(fromDetails))
+        return fromDetails;
+    return "未关联";
+}
+function humanStatus(status) {
+    return status === "passed" ? "通过" : status === "failure" ? "失败" : status === "error" ? "错误" : "跳过";
+}
+function formatDuration(durationMs) {
+    return durationMs === undefined ? "未记录" : `${(durationMs / 1000).toFixed(3)} 秒`;
+}
+function inferredScriptPath(classname, filePath) {
+    if (filePath?.trim()) {
+        return filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    }
+    const moduleName = classname
+        .split(".")
+        .filter((part) => part && !/^Test[A-Z_]/.test(part) && part !== "Test")
+        .join("/");
+    if (!moduleName || moduleName === "unknown")
+        return "unknown.py";
+    return moduleName.endsWith(".py") ? moduleName : `${moduleName}.py`;
+}
+function resolveReportScriptPath(result, item) {
+    if (item?.scriptPath)
+        return item.scriptPath;
+    if (result.filePath?.trim()) {
+        return result.filePath.replaceAll("\\", "/").replace(/^\.\//, "");
+    }
+    return inferredScriptPath(result.classname, result.filePath);
+}
+export function redactBackendTestOutput(value) {
+    return value
+        .replace(/((?:password|passwd|secret|token|api[_-]?key|authorization)\s*[:=]\s*)\S+/gi, "$1[REDACTED]")
+        .replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [REDACTED]");
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+function reportOutputLines(value, prefix) {
+    if (!value?.trim())
+        return [];
+    // Accept both the underscore form ("HTTP_REQUEST") and the space-separated
+    // form ("HTTP REQUEST") that some generated pytest helpers emit. Keep the
+    // original line text so downstream parsers can read the kv payload.
+    const underscorePrefix = prefix;
+    const spacePrefix = prefix.replaceAll("_", " ");
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith(underscorePrefix) || line.startsWith(spacePrefix))
+        .map((line) => {
+        const trimmed = line.startsWith(underscorePrefix)
+            ? line.slice(underscorePrefix.length)
+            : line.slice(spacePrefix.length);
+        // Preserve a complete single-line JSON payload through parsing. Bounding
+        // happens after structural extraction; slicing here can corrupt valid JSON
+        // and make a large passed response appear as an empty body.
+        return redactBackendTestOutput(trimmed.trim());
+    });
+}
+/**
+ * Normalize alternate HTTP log dialects into HTTP_REQUEST / HTTP_RESPONSE lines.
+ * Supports common project helpers that emit [REQ]/[RESP] block style instead of
+ * the contract prefixes (keeps original HTTP_* lines unchanged).
+ */
+export function normalizeBackendTestHttpLogText(value) {
+    if (!value.trim())
+        return value;
+    const lines = value.split(/\r?\n/);
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        const raw = lines[i];
+        const line = raw.trim();
+        // Canonical and compatible single-line forms. Normalize case, separator,
+        // and an optional colon so downstream parsing only consumes the canonical
+        // HTTP_REQUEST / HTTP_RESPONSE protocol. Examples accepted here include
+        // `HTTP_REQUEST {...}`, `HTTP REQUEST method=...`, and the generated-helper
+        // dialect `HTTP request: {...}`.
+        const protocolLine = line.match(/^HTTP(?:_|\s+)(REQUEST|RESPONSE)\b\s*:?\s*(.*)$/i);
+        if (protocolLine) {
+            const canonicalPrefix = `HTTP_${protocolLine[1].toUpperCase()}`;
+            const payload = protocolLine[2]?.trim() ?? "";
+            out.push(payload ? `${canonicalPrefix} ${payload}` : canonicalPrefix);
+            i += 1;
+            continue;
+        }
+        // [REQ] METHOD path  OR  [REQ] METHOD url
+        const reqHead = line.match(/^\[REQ\]\s+([A-Z]+)\s+(\S+)\s*$/i);
+        if (reqHead) {
+            const method = reqHead[1].toUpperCase();
+            const url = reqHead[2];
+            let body = "";
+            let j = i + 1;
+            // Optional [REQ body] then JSON/text until separator or next tag.
+            if (j < lines.length && /^\[REQ\s*body\]/i.test(lines[j].trim())) {
+                j += 1;
+                const bodyLines = [];
+                while (j < lines.length &&
+                    !/^[=-]{3,}\s*$/.test(lines[j].trim()) &&
+                    !/^\[(?:REQ|RESP)/i.test(lines[j].trim()) &&
+                    !/^(HTTP_REQUEST|HTTP_RESPONSE|HTTP REQUEST|HTTP RESPONSE)\b/i.test(lines[j].trim())) {
+                    bodyLines.push(lines[j]);
+                    j += 1;
+                }
+                body = bodyLines.join("\n").trim();
+            }
+            const payload = { method, url };
+            if (body) {
+                try {
+                    payload.json = JSON.parse(body);
+                }
+                catch {
+                    payload.body = body.slice(0, 4000);
+                }
+            }
+            out.push(`HTTP_REQUEST ${JSON.stringify(payload)}`);
+            i = j;
+            continue;
+        }
+        // [RESP status] 200  OR  [RESP] 200
+        const respHead = line.match(/^\[RESP(?:\s+status)?\]\s+(\d{3})\b/i);
+        if (respHead) {
+            const status_code = Number(respHead[1]);
+            let body = "";
+            let j = i + 1;
+            if (j < lines.length && /^\[RESP\s*body\]/i.test(lines[j].trim())) {
+                j += 1;
+                const bodyLines = [];
+                while (j < lines.length &&
+                    !/^[=-]{3,}\s*$/.test(lines[j].trim()) &&
+                    !/^\[(?:REQ|RESP)/i.test(lines[j].trim()) &&
+                    !/^(HTTP_REQUEST|HTTP_RESPONSE|HTTP REQUEST|HTTP RESPONSE)\b/i.test(lines[j].trim())) {
+                    bodyLines.push(lines[j]);
+                    j += 1;
+                }
+                body = bodyLines.join("\n").trim();
+            }
+            const payload = { status_code };
+            if (body) {
+                try {
+                    payload.result = JSON.parse(body);
+                }
+                catch {
+                    payload.result = body.slice(0, 4000);
+                }
+            }
+            out.push(`HTTP_RESPONSE ${JSON.stringify(payload)}`);
+            i = j;
+            continue;
+        }
+        out.push(raw);
+        i += 1;
+    }
+    return out.join("\n");
+}
+function requestResponseSummary(result) {
+    const combined = normalizeBackendTestHttpLogText([result.stdout, result.stderr].filter(Boolean).join("\n"));
+    return {
+        requests: reportOutputLines(combined, "HTTP_REQUEST"),
+        responses: reportOutputLines(combined, "HTTP_RESPONSE"),
+    };
+}
+const HTTP_STATUS_TEXT = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    409: "Conflict",
+    500: "Internal Server Error",
+};
+/**
+ * Parse the kv payload of an HTTP log line into a structured entry.
+ *
+ * Accepts two shapes emitted by generated pytest helpers:
+ *   - legacy: a bare JSON object ({"method":"POST",...})
+ *   - current: kv pairs (method=POST url=... parameters={...} / status_code=201 result={...})
+ */
+function parseHttpLogPayload(line, kind) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return {};
+    let parsedJson;
+    let kv = {};
+    // Try JSON first (legacy HTTP_REQUEST {"method":...} shape).
+    if (trimmed.startsWith("{")) {
+        try {
+            parsedJson = JSON.parse(trimmed);
+            for (const [key, value] of Object.entries(parsedJson)) {
+                kv[key.toLowerCase()] = typeof value === "string" ? value : safeStringify(value);
+            }
+        }
+        catch {
+            // Fall through to kv extraction below.
+        }
+    }
+    if (Object.keys(kv).length === 0) {
+        kv = extractKvPairs(trimmed);
+    }
+    if (kind === "request") {
+        const queryEnvelope = asHttpLogRecord(parsedJson?.query);
+        const method = kv.method ?? httpLogScalar(queryEnvelope?.method);
+        const url = kv.url ?? kv.path ?? httpLogScalar(queryEnvelope?.url) ?? httpLogScalar(queryEnvelope?.path);
+        let body = kv.parameters ?? kv.payload ?? kv.data;
+        if (!body && parsedJson) {
+            const parameters = {};
+            if (queryEnvelope) {
+                const businessQuery = Object.fromEntries(Object.entries(queryEnvelope).filter(([key]) => !["method", "url", "path"].includes(key)));
+                parameters.query = businessQuery;
+            }
+            else if (Object.hasOwn(parsedJson, "query")) {
+                parameters.query = parsedJson.query;
+            }
+            for (const key of ["body", "json"]) {
+                if (Object.hasOwn(parsedJson, key))
+                    parameters[key] = parsedJson[key];
+            }
+            if (Object.keys(parameters).length > 0)
+                body = boundedHttpLogBody(parameters);
+        }
+        return {
+            method,
+            url,
+            body: boundedHttpLogBody(body ?? kv.body ?? kv.json ?? kv.query),
+        };
+    }
+    const nestedJson = asHttpLogRecord(parsedJson?.json);
+    const nestedTransport = !kv.status_code && !kv.status
+        && Boolean(nestedJson && (Object.hasOwn(nestedJson, "status_code") || Object.hasOwn(nestedJson, "body")));
+    const status = kv.status_code ?? kv.status
+        ?? (nestedTransport ? httpLogScalar(nestedJson?.status_code ?? nestedJson?.status) : undefined);
+    const body = kv.result
+        ?? (nestedTransport ? boundedHttpLogBody(nestedJson?.body ?? nestedJson) : kv.json)
+        ?? kv.body
+        ?? kv.text;
+    return {
+        method: kv.method,
+        url: kv.url ?? kv.path,
+        status,
+        statusText: kv.status_text ?? (status ? HTTP_STATUS_TEXT[status] : undefined),
+        body: boundedHttpLogBody(body),
+    };
+}
+function asHttpLogRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function httpLogScalar(value) {
+    return typeof value === "string" || typeof value === "number"
+        ? String(value)
+        : undefined;
+}
+function boundedHttpLogBody(value) {
+    if (value === undefined)
+        return undefined;
+    const text = typeof value === "string" ? value : safeStringify(value);
+    const maxChars = 4000;
+    return text.length <= maxChars
+        ? text
+        : `${text.slice(0, maxChars)}\n… [truncated ${text.length - maxChars} chars]`;
+}
+function extractKvPairs(value) {
+    const result = {};
+    // Split on top-level spaces but keep {...}/[...] payloads intact.
+    let depth = 0;
+    let buffer = "";
+    const flush = () => {
+        const segment = buffer.trim();
+        buffer = "";
+        if (!segment)
+            return;
+        const eq = segment.indexOf("=");
+        if (eq <= 0)
+            return;
+        const key = segment.slice(0, eq).trim();
+        const val = segment.slice(eq + 1).trim();
+        if (key)
+            result[key] = val;
+    };
+    for (const ch of value) {
+        if (ch === "{" || ch === "[")
+            depth += 1;
+        else if (ch === "}" || ch === "]")
+            depth = Math.max(0, depth - 1);
+        if (ch === " " && depth === 0) {
+            flush();
+        }
+        else {
+            buffer += ch;
+        }
+    }
+    flush();
+    return result;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function reportDetails(title, values, emptyText) {
+    const body = values.length > 0
+        ? values.map((value) => `<pre>${escapeHtml(value)}</pre>`).join("")
+        : `<p class="muted">${escapeHtml(emptyText)}</p>`;
+    return `<details class="io-details" open><summary>${escapeHtml(title)} <span>${values.length}</span></summary>${body}</details>`;
+}
+function parseAdvisorySummary(markdown) {
+    if (!markdown?.trim())
+        return { status: "Unavailable", findings: undefined, firstFinding: "未提供证据" };
+    const explicitStatus = markdown.match(/^## Status\s*\r?\n\s*(PASS|FAIL)\s*$/mi)?.[1]
+        ?? markdown.trim().match(/^(PASS|FAIL)$/i)?.[1]?.toUpperCase();
+    const status = explicitStatus;
+    const findings = Number(markdown.match(/^- Findings:\s*(\d+)\s*$/mi)?.[1]);
+    const findingLines = markdown
+        .split(/\r?\n/)
+        .slice(markdown.split(/\r?\n/).findIndex((line) => /^## Findings\s*$/.test(line.trim())) + 1)
+        .map((line) => line.trim())
+        .filter((line) => /^-\s+/.test(line) && !/^- None$/i.test(line));
+    const resolvedFindings = Number.isFinite(findings) ? findings : findingLines.length;
+    return {
+        status: status ?? "Unavailable",
+        findings: resolvedFindings,
+        firstFinding: findingLines[0]?.replace(/^-\s+/, "") ?? "无",
+    };
+}
+function advisoryBadge(status) {
+    const className = status === "PASS" ? "passed" : status === "FAIL" ? "failure" : "skipped";
+    return `<span class="status ${className}">${status === "Unavailable" ? "不可用" : status}</span>`;
+}
+function conclusionIcon(failed) {
+    return failed
+        ? `<svg class="conclusion-icon" viewBox="0 0 48 48" role="img" aria-label="测试未通过"><circle cx="24" cy="24" r="20"/><path d="M24 14v13"/><circle cx="24" cy="34" r="1.5" class="icon-dot"/></svg>`
+        : `<svg class="conclusion-icon" viewBox="0 0 48 48" role="img" aria-label="测试通过"><circle cx="24" cy="24" r="20"/><path d="m14 24 7 7 14-15"/></svg>`;
+}
+function reportDetailSection(title, content, open = false) {
+    return `<details class="report-detail"${open ? " open" : ""}><summary>${escapeHtml(title)}</summary><div class="report-detail-body">${content}</div></details>`;
+}
+/** Render a pretty "prettified" body block: if it looks like JSON/kv, reformat; otherwise show raw. */
+function renderLogBody(raw, emptyText) {
+    const text = (raw ?? "").trim();
+    if (!text || text === "{}" || text === "null") {
+        return `<pre style="white-space:pre-wrap;background:#f6f8fa;color:#1f2937;padding:10px 12px;border-radius:8px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.78rem;margin-top:6px;border:1px solid #eceef2;line-height:1.6">${escapeHtml(emptyText)}</pre>`;
+    }
+    let pretty = text;
+    // Best-effort: pretty-print JSON payloads.
+    if (text.startsWith("{") || text.startsWith("[")) {
+        try {
+            pretty = JSON.stringify(JSON.parse(text), null, 2);
+        }
+        catch {
+            // Keep original kv text.
+        }
+    }
+    else if (text.includes(":") || text.includes("=")) {
+        // kv-style "key: value" or "key=value" → one per line.
+        pretty = text
+            .replace(/\s+(?=[A-Za-z_]+[:=])/g, "\n")
+            .trim();
+    }
+    return `<pre style="white-space:pre-wrap;background:#f6f8fa;color:#1f2937;padding:10px 12px;border-radius:8px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.78rem;margin-top:6px;border:1px solid #eceef2;line-height:1.6">${escapeHtml(pretty)}</pre>`;
+}
+function statusColor(status) {
+    if (status === "passed")
+        return { fg: "#067647", bg: "#ecfdf3" };
+    if (status === "skipped")
+        return { fg: "#9a6700", bg: "#fffaeb" };
+    return { fg: "#b42318", bg: "#fef3f2" };
+}
+function methodBadge(method) {
+    const m = (method ?? "?").toUpperCase();
+    const bg = m === "GET" ? "#2563eb" : m === "POST" ? "#16a34a" : m === "DELETE" ? "#b42318" : m === "PUT" || m === "PATCH" ? "#d97706" : "#475467";
+    return `<span style="display:inline-block;padding:2px 8px;border-radius:5px;background:${bg};color:#fff;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.72rem;font-weight:700">${escapeHtml(m)}</span>`;
+}
+function statusPill(status, fallback) {
+    const code = Number(status);
+    if (!Number.isFinite(code) || code === 0) {
+        return `<span style="color:#98a2b3;font-size:0.74rem">${escapeHtml(fallback)}</span>`;
+    }
+    const color = code >= 200 && code < 300 ? { fg: "#067647", bg: "#ecfdf3" } : code >= 400 ? { fg: "#b42318", bg: "#fef3f2" } : { fg: "#9a6700", bg: "#fffaeb" };
+    return `<span style="display:inline-block;padding:2px 9px;border-radius:999px;font-weight:700;font-size:0.72rem;color:${color.fg};background:${color.bg}">${code}</span>`;
+}
+/** Pair request lines with their matching response lines (by method+url or order). */
+function pairHttpCalls(requests, responses) {
+    const parsedRequests = requests.map((line) => parseHttpLogPayload(line, "request"));
+    const parsedResponses = responses.map((line) => parseHttpLogPayload(line, "response"));
+    const used = new Set();
+    return parsedRequests.map((request) => {
+        let matchIndex = -1;
+        for (let i = 0; i < parsedResponses.length; i += 1) {
+            if (used.has(i))
+                continue;
+            const candidate = parsedResponses[i];
+            if (candidate.method && request.method && candidate.method.toUpperCase() === request.method.toUpperCase()
+                && candidate.url && request.url && candidate.url === request.url) {
+                matchIndex = i;
+                break;
+            }
+        }
+        // Fallback: first unused response in order.
+        if (matchIndex < 0) {
+            for (let i = 0; i < parsedResponses.length; i += 1) {
+                if (!used.has(i)) {
+                    matchIndex = i;
+                    break;
+                }
+            }
+        }
+        if (matchIndex >= 0) {
+            used.add(matchIndex);
+            return { request, response: parsedResponses[matchIndex] };
+        }
+        return { request };
+    });
+}
+function renderHttpCallCard(call) {
+    // method/url come from the request line; status/result come from the response.
+    // Some log formats (HTTP RESPONSE status=... result=...) omit method/url on
+    // the response line, so prefer the request for those fields.
+    const method = call.request.method ?? call.response?.method;
+    const url = call.request.url ?? call.response?.url ?? "未知 URL";
+    const header = `<div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap">${methodBadge(method)}<code style="font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.78rem;color:#344054">${escapeHtml(url)}</code><span style="flex:1"></span>${call.response ? statusPill(call.response.status, call.response.statusText ?? "") : "<span style=\"color:#98a2b3;font-size:0.74rem\">无响应</span>"}${call.response?.statusText ? `<span style="color:#98a2b3;font-size:0.74rem">${escapeHtml(call.response.statusText)}</span>` : ""}</div>`;
+    const requestBlock = `<div style="color:#667085;font-size:0.74rem;font-weight:600;margin-bottom:3px;margin-top:10px">请求参数 / 请求体</div>${renderLogBody(call.request.body, "无")}`;
+    const responseBlock = call.response
+        ? `<div style="color:#667085;font-size:0.74rem;font-weight:600;margin-bottom:3px;margin-top:10px">响应结果</div>${renderLogBody(call.response.body, "无")}`
+        : "";
+    return `<div style="border:1px solid #eef0f3;border-radius:10px;padding:12px 14px;margin-top:10px;background:#fcfdff">${header}${requestBlock}${responseBlock}</div>`;
+}
+function analyzeBackendTestFailure(result) {
+    const evidence = [result.message, result.details].filter(Boolean).join("\n");
+    const statusPatterns = [
+        { pattern: /实际(?:\s*HTTP)?\s*状态码\s*[:：]?\s*(\d{3})[\s\S]{0,80}?预期(?:\s*HTTP)?\s*状态码?\s*[:：]?\s*(\d{3})/i, actualGroup: 1, expectedGroup: 2 },
+        { pattern: /预期(?:\s*HTTP)?\s*状态码\s*[:：]?\s*(\d{3})[\s\S]{0,80}?实际(?:\s*HTTP)?\s*状态码?\s*[:：]?\s*(\d{3})/i, actualGroup: 2, expectedGroup: 1 },
+        { pattern: /assert\s+(\d{3})\s*==\s*(\d{3})/i, actualGroup: 1, expectedGroup: 2 },
+        { pattern: /expected\s*[:=]?\s*(\d{3})[\s\S]{0,80}?(?:actual|received|got)\s*[:=]?\s*(\d{3})/i, actualGroup: 2, expectedGroup: 1 },
+    ];
+    for (const candidate of statusPatterns) {
+        const match = evidence.match(candidate.pattern);
+        if (match) {
+            const actual = match[candidate.actualGroup];
+            const expected = match[candidate.expectedGroup];
+            if (actual && expected) {
+                return `HTTP 状态码不符合预期：期望 ${expected}，实际 ${actual}。建议核对接口错误码契约、异常映射与测试前置数据。`;
+            }
+        }
+    }
+    const contentTypeMatch = evidence.match(/assert\s+(['"])(.*?)\1\.startswith\(\s*(['"])application\/json\3\s*\)/i);
+    if (contentTypeMatch) {
+        const actual = contentTypeMatch[2];
+        const actualLabel = actual ? `为 ${actual}` : "为空值";
+        return `响应 Content-Type 不符合预期：期望以 application/json 开头，实际${actualLabel}。建议核对接口响应头设置。`;
+    }
+    const assertionEvidence = (result.details ?? "")
+        .split(/\r?\n/)
+        .map((line) => line.trim().replace(/^E\s+/, ""))
+        .find((line) => /^assert\b/i.test(line));
+    const rawMessage = /^\d+:\s*AssertionError\s*$/i.test(result.message?.trim() ?? "") && assertionEvidence
+        ? assertionEvidence
+        : result.message || assertionEvidence || humanStatus(result.status);
+    const message = rawMessage.replace(/\s+/g, " ").trim().slice(0, 240);
+    if (result.status === "error") {
+        return `测试执行发生错误：${message}。建议优先检查 fixture、依赖导入、环境连接与运行时异常。`;
+    }
+    return `断言未满足：${message}。建议结合失败详情及请求/响应证据核对接口行为与用例预期。`;
+}
+export function renderBackendTestHtml(input) {
+    const failed = input.parsed.failed + input.parsed.errors > 0;
+    const passRate = input.parsed.tests > 0 ? input.parsed.passed / input.parsed.tests : 0;
+    const catalog = new Map((input.cases ?? []).map((item) => [item.id, item]));
+    const caseValidation = parseAdvisorySummary(input.caseValidationSummary);
+    const caseCoverage = parseAdvisorySummary(input.caseCoverageSummary);
+    const traceability = parseAdvisorySummary(input.traceabilitySummary);
+    const correspondence = parseAdvisorySummary(input.correspondenceSummary);
+    const failures = input.parsed.cases.filter((result) => result.status !== "passed");
+    const headColor = failed ? { fg: "#b42318", bg: "linear-gradient(135deg,#fef3f2 0,#fee4e2 100%)", border: "#fda29b", icon: "✗" } : { fg: "#067647", bg: "linear-gradient(135deg,#ecfdf3 0,#d1fadf 100%)", border: "#abefc6", icon: "✓" };
+    const orderedCases = input.parsed.cases
+        .map((result, index) => ({ result, index }))
+        .sort((left, right) => {
+        const leftFailed = left.result.status === "failure" || left.result.status === "error" ? 0 : 1;
+        const rightFailed = right.result.status === "failure" || right.result.status === "error" ? 0 : 1;
+        return leftFailed - rightFailed || left.index - right.index;
+    })
+        .map(({ result }) => result);
+    const caseCards = orderedCases.map((result) => {
+        const caseId = resolveReportCaseId(result, catalog);
+        const item = caseId === "未关联" ? undefined : catalog.get(caseId);
+        const io = requestResponseSummary(result);
+        const calls = pairHttpCalls(io.requests, io.responses);
+        const statusColors = statusColor(result.status);
+        const logSection = calls.length > 0
+            ? `<div style="margin-top:12px;display:flex;align-items:baseline;gap:8px"><span style="color:#17365d;font-size:0.9rem;font-weight:700">执行日志</span><span style="color:#98a2b3;font-size:0.76rem">共 ${calls.length} 次接口调用</span></div>${calls.map(renderHttpCallCard).join("")}`
+            : "";
+        const failureBlock = result.status === "passed"
+            ? ""
+            : `<div style="margin-top:12px;padding:10px 12px;border-radius:8px;background:#fef3f2;border:1px solid #fda29b;color:#b42318;font-size:0.84rem"><strong>${escapeHtml(result.message || humanStatus(result.status))}</strong>${result.details ? `<details style="margin-top:6px"><summary style="cursor:pointer;color:#b42318;font-size:0.78rem">失败详情</summary><pre style="white-space:pre-wrap;background:#f6f8fa;color:#1f2937;padding:10px 12px;border-radius:8px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.78rem;margin-top:6px;border:1px solid #eceef2;line-height:1.6">${escapeHtml(result.details)}</pre></details>` : ""}</div>`;
+        const scriptPath = resolveReportScriptPath(result, item);
+        return `<details style="background:#fff;border:1px solid #e6eaf0;border-radius:12px;margin-top:10px"><summary style="display:flex;align-items:center;gap:12px;padding:12px 16px;cursor:pointer;list-style:none"><span style="background:#e8edf5;color:#2b3a55;padding:2px 9px;border-radius:6px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.76rem;font-weight:600;white-space:nowrap">${escapeHtml(caseId)}</span><div style="flex:1;min-width:0"><div style="font-weight:600;color:#172033;font-size:0.92rem">${escapeHtml(item?.title ?? result.name)}</div><code style="font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.74rem;color:#98a2b3">${escapeHtml(result.name)}</code></div><span style="color:#98a2b3;font-size:0.8rem;white-space:nowrap">${formatDuration(result.durationMs)}</span><span style="display:inline-block;padding:2px 10px;border-radius:999px;font-weight:700;font-size:0.72rem;color:${statusColors.fg};background:${statusColors.bg}">${humanStatus(result.status)}</span><span style="color:#aab2bf;font-size:0.8rem">▾</span></summary><div style="padding:4px 16px 14px 16px;border-top:1px solid #f0f3f7"><div style="margin-top:10px"><div style="color:#667085;font-size:0.74rem;font-weight:600;margin-bottom:3px">自动化脚本</div><code style="background:#eef2f7;color:#344054;padding:1px 6px;border-radius:5px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.8rem">${escapeHtml(scriptPath)}</code></div>${item?.scenario ? `<div style="margin-top:12px"><div style="color:#667085;font-size:0.74rem;font-weight:600;margin-bottom:3px">验收场景</div><div style="color:#475467;font-size:0.86rem;line-height:1.75">${escapeHtml(item.scenario)}</div></div>` : ""}${logSection}${failureBlock}</div></details>`;
+    }).join("");
+    const metricCard = (label, value, valueColor = "#172033") => `<div style="padding:14px 16px;border:1px solid #e3e8ef;border-radius:12px;background:#fbfcfe"><span style="color:#667085;font-size:0.78rem">${escapeHtml(label)}</span><div style="font-size:22px;font-weight:700;color:${valueColor}">${value}</div></div>`;
+    const metrics = `<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(130px,1fr));gap:12px;margin-top:14px">${metricCard("用例总数", input.parsed.tests)}${metricCard("通过", input.parsed.passed, "#067647")}${metricCard("失败", input.parsed.failed)}${metricCard("错误", input.parsed.errors)}${metricCard("跳过", input.parsed.skipped)}<div style="padding:14px 16px;border:1px solid #e3e8ef;border-radius:12px;background:#fbfcfe"><span style="color:#667085;font-size:0.78rem">通过率</span><div style="font-size:22px;font-weight:700;color:#067647">${(passRate * 100).toFixed(2)}%</div><span style="color:#667085;font-size:0.78rem">耗时 ${formatDuration(input.parsed.durationMs)}</span></div></div>`;
+    const summaryBanner = `<div style="display:flex;align-items:center;gap:16px;padding:16px 18px;border-radius:14px;background:${headColor.bg};border:1px solid ${headColor.border}"><div style="flex:0 0 auto;width:44px;height:44px;border-radius:999px;background:${headColor.fg};display:flex;align-items:center;justify-content:center;color:#fff;font-size:24px;font-weight:900;box-shadow:0 4px 12px ${headColor.fg}4d">${headColor.icon}</div><div><div style="color:${headColor.fg};font-size:1.05rem;font-weight:800;line-height:1.3">${failed ? "本轮测试未通过" : "本轮测试通过"}</div><div style="color:${headColor.fg};font-size:0.88rem;margin-top:2px">${failed ? `${input.parsed.failed + input.parsed.errors} 条用例失败或错误` : `${input.parsed.passed} 条用例全部执行成功`}</div></div></div>`;
+    const qualityBlock = `<div style="margin-top:18px"><div style="color:#17365d;font-size:16px;font-weight:700;margin:0 4px 6px">质量校验</div><div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:12px;margin-top:8px">${renderQualityCard("Markdown 用例校验", caseValidation, input.caseValidationSummary)}${renderQualityCard("用例场景覆盖分析", caseCoverage, input.caseCoverageSummary)}${renderQualityCard("Markdown → pytest 追溯", traceability, input.traceabilitySummary)}${renderQualityCard("Markdown → pytest 一一对应", correspondence, input.correspondenceSummary)}</div></div>`;
+    const failureOverview = failures.length > 0
+        ? `<div style="margin-top:18px"><div style="color:#17365d;font-size:16px;font-weight:700;margin:0 4px 6px">失败概览</div><div style="display:grid;gap:10px;margin-top:8px">${failures.map((result) => {
+            const caseId = resolveReportCaseId(result, catalog);
+            const c = statusColor(result.status);
+            return `<div style="border-left:4px solid ${c.fg};background:${c.bg};padding:10px 12px;border-radius:8px"><div style="font-weight:600;color:#172033;font-size:0.88rem">${escapeHtml(caseId)} · ${escapeHtml(catalog.get(caseId)?.title ?? result.name)}</div><div style="color:${c.fg};font-size:0.82rem;margin-top:4px"><strong>原始失败：</strong>${escapeHtml(result.message || humanStatus(result.status))}</div><div style="color:#475467;font-size:0.82rem;margin-top:5px"><strong style="color:#17365d">原因分析：</strong>${escapeHtml(analyzeBackendTestFailure(result))}</div></div>`;
+        }).join("")}</div></div>`
+        : "";
+    return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(input.title)}</title></head><body style="margin:0;background:linear-gradient(180deg,#eef2f7 0,#f7f9fc 40rem);color:#172033;font-family:system-ui,'Microsoft YaHei','PingFang SC',sans-serif;line-height:1.6"><div style="max-width:1000px;margin:0 auto;padding:32px 22px 56px"><div style="padding:8px 0 4px"><div style="color:#315f93;font-weight:700;letter-spacing:0.06em;font-size:0.76rem">后端自动化测试报告</div><h1 style="margin:6px 0 0;color:#17365d;font-size:24px;line-height:1.35">${escapeHtml(input.title)}</h1><p style="color:#667085;margin:8px 0 0;font-size:0.9rem">执行事实来自同一次 pytest 执行；用例默认折叠，点击任意用例可展开执行日志（接口、请求参数、响应结果）与检查点。</p></div><div style="background:#fff;border:1px solid #e3e8ef;border-radius:16px;padding:18px 20px;margin-top:16px;box-shadow:0 1px 2px rgba(16,24,40,0.04)">${summaryBanner}${metrics}</div><div style="background:#fff;border:1px solid #e3e8ef;border-radius:16px;padding:18px 20px;margin-top:16px;box-shadow:0 1px 2px rgba(16,24,40,0.04)">${qualityBlock}<div style="margin-top:12px;padding:10px 12px;background:#f6f8fa;border-radius:8px;font-size:0.82rem;color:#475467"><strong style="color:#667085">执行环境</strong>：${escapeHtml((input.environmentSummary || "不可用").split("\n").slice(0, 3).join(" ").slice(0, 200))}</div></div>${failureOverview}<div style="margin-top:18px"><div style="display:flex;align-items:baseline;justify-content:space-between;margin:0 4px 6px"><span style="color:#17365d;font-size:16px;font-weight:700">用例执行明细</span><span style="color:#98a2b3;font-size:0.8rem">共 ${input.parsed.cases.length} 条 · 点击展开</span></div>${caseCards || '<div style="padding:16px;border:1px dashed #e3e8ef;border-radius:12px;color:#667085;background:#fbfcfe;text-align:center">未发现可展示的用例。</div>'}</div></div></body></html>`;
+}
+function renderQualityCard(title, summary, rawSummary) {
+    const colors = summary.status === "PASS" ? { fg: "#067647", bg: "#ecfdf3" } : summary.status === "FAIL" ? { fg: "#b42318", bg: "#fef3f2" } : { fg: "#9a6700", bg: "#fffaeb" };
+    const label = summary.status === "Unavailable" ? "不可用" : summary.status;
+    const details = rawSummary?.trim()
+        ? `<details style="margin-top:9px;padding-top:8px;border-top:1px solid #e3e8ef"><summary style="cursor:pointer;color:#315f93;font-size:0.78rem;font-weight:700">查看详情 · ${escapeHtml(title)}详情</summary><pre style="white-space:pre-wrap;overflow-wrap:anywhere;background:#f6f8fa;color:#1f2937;padding:10px 12px;border-radius:8px;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:0.74rem;margin:7px 0 0;border:1px solid #eceef2;line-height:1.55">${escapeHtml(rawSummary.trim())}</pre></details>`
+        : "";
+    return `<div style="padding:12px 14px;border:1px solid #e3e8ef;border-radius:10px;background:#fbfcfe"><div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:6px"><strong style="color:#17365d;font-size:0.88rem">${escapeHtml(title)}</strong><span style="display:inline-block;padding:2px 9px;border-radius:999px;font-weight:700;font-size:0.72rem;color:${colors.fg};background:${colors.bg}">${label}</span></div><div style="color:#667085;font-size:0.78rem">Findings：${summary.findings ?? "不可用"}</div><div style="color:#475467;font-size:0.8rem;margin-top:2px">${escapeHtml(summary.firstFinding)}</div>${details}</div>`;
+}
+/**
+ * Dump JaCoCo execution data over TCP from a JaCoCo tcpserver agent, convert
+ * .exec → jacoco.xml via jacococli.jar, then parse into a code-coverage-v1
+ * contract. Designed for Java services started with
+ * `-javaagent:jacocoagent.jar=output=tcpserver,port=6300,append=false`.
+ *
+ * Failure-safe: any transport/conversion/parse error returns null so the L-5
+ * dashboard degrades coverage to unavailable instead of blocking the run.
+ */
+export async function collectJacocoCoverage(input) {
+    const [host, portStr] = input.endpoint.split(":");
+    const port = Number(portStr);
+    if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) {
+        return null;
+    }
+    const execPath = path.join(input.workDir, "jacoco.exec");
+    const xmlPath = path.join(input.workDir, "jacoco.xml");
+    // Step 1: TCP dump of JaCoCo execution data. The protocol is JaCoCo's
+    // binary "dump" command: a magic header + command byte. We send the dump
+    // request and stream the response into jacoco.exec.
+    try {
+        await dumpJacocoExec(host, port, execPath, input.connectTimeoutMs);
+    }
+    catch {
+        return null;
+    }
+    // Step 2: jacococli.jar report .exec → jacoco.xml
+    try {
+        await execFileAsync("java", [
+            "-jar", input.cliJarPath,
+            "report", execPath,
+            "--xml", xmlPath,
+            "--includes", input.includes,
+        ], { timeout: 60000, windowsHide: true });
+    }
+    catch {
+        return null;
+    }
+    // Step 3: parse jacoco.xml into a code-coverage-v1 contract.
+    try {
+        const xml = await readFile(xmlPath, "utf8");
+        const artifactSha256 = createHash("sha256").update(xml).digest("hex");
+        return parseJacocoXml(xml, {
+            sourceScope: input.sourceScope,
+            commitSha: input.commitSha,
+            artifactPath: "reports/jacoco.xml",
+            artifactSha256,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Send a JaCoCo TCP dump command and stream the response into destPath.
+ * JaCoCo tcpserver protocol: connect, send dump command header, read until close.
+ */
+function dumpJacocoExec(host, port, destPath, connectTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const socket = connect({ host, port });
+        const writeStream = createWriteStream(destPath);
+        const timer = setTimeout(() => {
+            socket.destroy();
+            reject(new Error("jacoco-tcp-connect-timeout"));
+        }, connectTimeoutMs);
+        socket.on("connect", () => {
+            // JaCoCo TCP "dump" command: magic 0xC0FFEE + cmd=0x40 (dump)
+            // Format: <magic 3 bytes><cmd id 1 byte>
+            // The server responds with the exec data and closes.
+            const magic = Buffer.from([0xC0, 0xFF, 0xEE]);
+            const dumpCmd = Buffer.from([0x40]);
+            socket.end(Buffer.concat([magic, dumpCmd]));
+        });
+        socket.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        socket.on("close", () => {
+            clearTimeout(timer);
+            writeStream.end(() => {
+                // Verify we got non-empty exec data.
+                readFile(destPath).then((buf) => {
+                    if (buf.length === 0)
+                        reject(new Error("jacoco-dump-empty"));
+                    else
+                        resolve();
+                }).catch(reject);
+            });
+        });
+        socket.pipe(writeStream);
+    });
+}
+/**
+ * Deterministically derive a Backend Test Case Manifest v1 from final
+ * Markdown cases (testcase/md/**) and generated pytest scripts
+ * (testcase/test_*.py). No model involvement: AC IDs come from the case
+ * 验收标准/Acceptance Criteria section, automation status comes from whether
+ * a pytest test function references the Case ID. The output feeds
+ * computeCaseManifestCoverageSummary so the L-5 dashboard shows real
+ * AC/automation coverage instead of unavailable.
+ */
+export async function deriveBackendTestCaseManifest(input) {
+    const files = await markdownFiles(input.workspaceRoot);
+    const manifestCases = [];
+    for (const file of files) {
+        if (path.basename(file).toLowerCase() === "readme.md")
+            continue;
+        const content = await readFile(file, "utf8");
+        for (const testCase of splitCases(content)) {
+            const acIds = unique(testCase.body.match(AC_ID) ?? []);
+            if (acIds.length === 0)
+                continue; // skip cases without AC binding
+            const mappedScripts = extractMappedPytestScripts(testCase.body);
+            const category = inferCaseCategory(testCase.body);
+            let generated = false;
+            let symbol;
+            let scriptFile;
+            for (const script of mappedScripts) {
+                if (!isSafeBackendPytestScript(script, input.workspaceRoot))
+                    continue;
+                const absolute = path.resolve(input.workspaceRoot, script);
+                if (!(await exists(absolute)))
+                    continue;
+                const source = await readFile(absolute, "utf8");
+                const match = findCaseIdInPytest(source, testCase.id);
+                if (match) {
+                    generated = true;
+                    symbol = match;
+                    scriptFile = script;
+                    break;
+                }
+            }
+            manifestCases.push({
+                caseId: testCase.id,
+                acIds,
+                title: inferCaseTitle(testCase.body, testCase.id),
+                category,
+                automationStatus: generated ? "generated" : "planned",
+                ...(scriptFile ? { file: scriptFile } : {}),
+                ...(symbol ? { symbol } : {}),
+                ...(generated ? {} : { gapReason: "pytest symbol not yet generated or not associated" }),
+            });
+        }
+    }
+    const manifest = backendTestCaseManifestSchema.parse({
+        schemaVersion: 1,
+        sourceBinding: {
+            taskId: input.sourceBinding.taskId,
+            requirementPath: input.sourceBinding.requirementPath,
+            requirementSha256: input.sourceBinding.requirementSha256,
+            referencePaths: input.sourceBinding.referencePaths,
+            requirementIds: input.sourceBinding.requirementIds,
+        },
+        cases: manifestCases,
+        evidenceGaps: [],
+        coverageSummary: computeCaseManifestCoverageSummary({
+            cases: manifestCases,
+            evidenceGaps: [],
+            sourceBinding: input.sourceBinding,
+        }),
+    });
+    return manifest;
+}
+function inferCaseCategory(body) {
+    const text = body.toLowerCase();
+    if (/非法|无效|错误|不存在|越权|negative|invalid|unauthorized|forbidden|40[0-9]/.test(text))
+        return "negative";
+    if (/边界|boundary|edge|limit|max|min/.test(text))
+        return "boundary";
+    if (/鉴权|权限|登录|token|auth|permission|role/.test(text))
+        return "auth";
+    if (/状态|流转|state|transition|workflow/.test(text))
+        return "state-transition";
+    if (/超时|timeout/.test(text))
+        return "timeout";
+    if (/并发|concurren/.test(text))
+        return "concurrency";
+    return "positive";
+}
+function inferCaseTitle(body, caseId) {
+    // ## BE-XXX-001｜中文标题 → extract title after the delimiter
+    const heading = body.split(/\r?\n/, 1)[0] ?? "";
+    const delimiterMatch = heading.match(/[｜|]\s*(.+)$/);
+    if (delimiterMatch)
+        return delimiterMatch[1].trim();
+    return caseId;
+}
+function findCaseIdInPytest(source, caseId) {
+    for (const match of source.matchAll(/^(\s*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]+)\s*\([^)]*\)\s*(?:->\s*[^:\r\n]+)?\s*:/gm)) {
+        const symbol = match[2];
+        const region = testFunctionRegion({
+            source,
+            functionIndex: match.index,
+            functionHeaderEnd: match.index + match[0].length,
+        });
+        const ids = new Set(caseIdsInText(region));
+        const fromSymbol = symbolCaseId(symbol);
+        if (fromSymbol)
+            ids.add(fromSymbol);
+        if (ids.has(caseId))
+            return symbol;
+    }
+    return undefined;
+}
+function inferModuleScript(classname) {
+    // classname like "test_process_definition_list.py::TestX::test_a" → take the file stem.
+    const first = classname.split("::")[0] ?? classname;
+    return first.endsWith(".py") ? first : `${first}.py`;
+}
+function collectModuleStats(parsed) {
+    const map = new Map();
+    for (const c of parsed.cases) {
+        const script = inferModuleScript(c.classname || c.name);
+        const stat = map.get(script) ?? { script, total: 0, passed: 0, failed: 0, errors: 0 };
+        stat.total += 1;
+        if (c.status === "passed")
+            stat.passed += 1;
+        else if (c.status === "failure")
+            stat.failed += 1;
+        else if (c.status === "error")
+            stat.errors += 1;
+        map.set(script, stat);
+    }
+    return [...map.values()].sort((a, b) => a.script.localeCompare(b.script));
+}
+function l5StatusBadge(status) {
+    if (status === "pass")
+        return { label: "达标", fg: "#15815c", bg: "#e7f7f0" };
+    if (status === "fail")
+        return { label: "未达标", fg: "#d34661", bg: "#fff0f3" };
+    return { label: "不可用", fg: "#718097", bg: "#eef2f7" };
+}
+function l5GateRow(name, metric, valueLabel, footLabel, evidence) {
+    const badge = l5StatusBadge(metric.status);
+    const pct = metric.ratio !== null ? Math.round(metric.ratio * 100) : null;
+    const meterWidth = metric.status === "unavailable" ? 0 : pct ?? 0;
+    const meterClass = metric.status === "pass" ? "#15815c" : metric.status === "fail" ? "#d34661" : "#e9a040";
+    const meter = `<div style="height:6px;margin:10px 0 7px;background:#e7edf5;border-radius:99px;overflow:hidden"><i style="display:block;height:100%;width:${meterWidth}%;border-radius:inherit;background:${meterClass}"></i></div>`;
+    const evidenceBlock = evidence
+        ? `<details style="margin-top:10px;padding-top:9px;border-top:1px solid #e5ebf3"><summary style="color:#4775ef;font-size:12px;font-weight:750;cursor:pointer;list-style:none;display:flex;align-items:center;gap:6px">查看依据</summary><div style="margin-top:7px;color:#718097;font-size:12px">${evidence}</div></details>`
+        : "";
+    return `<div style="padding:14px 15px;border:1px solid #e5ebf3;border-radius:11px;background:#fcfdff;margin-top:8px"><div style="display:flex;align-items:center;gap:10px"><span style="flex:1;color:#263c5e;font-size:13px;font-weight:750">${escapeHtml(name)}</span><strong style="font-size:15px;font-weight:800;color:${badge.fg}">${escapeHtml(valueLabel)}</strong><span style="display:inline-flex;align-items:center;padding:3px 9px;border-radius:999px;font-size:11px;font-weight:800;color:${badge.fg};background:${badge.bg}">${badge.label}</span></div>${meter}<div style="display:flex;justify-content:space-between;color:#718097;font-size:12px"><span>${escapeHtml(footLabel)}</span></div>${evidenceBlock}</div>`;
+}
+export function renderBackendTestL5Dashboard(input) {
+    const m = input.metrics.metrics;
+    const decision = input.metrics.status === "ready" ? { text: "READY", color: "#15815c", bg: "rgba(21,129,92,.12)", border: "rgba(120,200,170,.4)", small: "所有 L-5 门禁达标" }
+        : { text: "NOT READY", color: "#d34661", bg: "rgba(211,70,97,.12)", border: "rgba(255,177,192,.4)", small: `${input.metrics.blockingItems.length} 个阻断项需要处理` };
+    const passRatePct = m.passRate.ratio !== null ? (m.passRate.ratio * 100).toFixed(2) : "—";
+    const acPct = m.acCoverage.ratio !== null ? (m.acCoverage.ratio * 100).toFixed(2) : null;
+    const autoPct = m.automationCoverage.ratio !== null ? (m.automationCoverage.ratio * 100).toFixed(2) : null;
+    // Donut SVG: pass arc + fail arc on a r=46 circle (circumference ≈ 289.03).
+    const circ = 2 * Math.PI * 46;
+    const executed = input.parsed.passed + input.parsed.failed + input.parsed.errors;
+    const passLen = executed > 0 ? (input.parsed.passed / executed) * circ : 0;
+    const failLen = executed > 0 ? ((input.parsed.failed + input.parsed.errors) / executed) * circ : 0;
+    const signal = (label, strong, width, markerLeft, trackClass, small) => `<div style="margin-top:14px"><div style="display:flex;justify-content:space-between;align-items:baseline;color:#2b405f;font-size:12px"><span>${escapeHtml(label)}</span><strong style="color:#17365d;font-size:14px">${escapeHtml(strong)}</strong></div><div style="position:relative;height:8px;margin:7px 0 4px;background:#edf1f6;border-radius:99px"><i style="display:block;height:100%;width:${width}%;border-radius:inherit;background:${trackClass}"></i><b style="position:absolute;top:-3px;left:${markerLeft}%;width:2px;height:14px;background:#273b59;border-radius:2px"></b></div><small style="color:#718097;font-size:10px">${escapeHtml(small)}</small></div>`;
+    const acStrong = acPct !== null ? `${acPct}%` : "—";
+    const acWidth = acPct !== null ? Number(acPct) : 0;
+    const autoStrong = autoPct !== null ? `${autoPct}%` : "—";
+    const autoWidth = autoPct !== null ? Number(autoPct) : 0;
+    const moduleBars = collectModuleStats(input.parsed).map((stat) => {
+        const passPct = stat.total > 0 ? Math.round((stat.passed / stat.total) * 100) : 0;
+        const failPct = stat.total > 0 ? 100 - passPct : 0;
+        const badge = stat.failed + stat.errors === 0 ? { fg: "#15815c", bg: "#e7f7f0", t: `${stat.passed}/${stat.total}` } : { fg: "#d34661", bg: "#fff0f3", t: `${stat.passed}/${stat.total}` };
+        return `<div style="padding:13px 14px;border:1px solid #e4e9f1;border-radius:11px;background:#fbfcfe"><div style="display:flex;justify-content:space-between;align-items:center;gap:8px"><span style="color:#2a3c5a;font-size:12px;font-weight:700;font-family:ui-monospace,SFMono-Regular,Menlo,monospace">${escapeHtml(stat.script)}</span><span style="display:inline-flex;padding:2px 8px;border-radius:999px;font-size:11px;font-weight:800;color:${badge.fg};background:${badge.bg}">${badge.t}</span></div><div style="height:6px;margin:9px 0 6px;background:#edf1f6;border-radius:99px;overflow:hidden;display:flex"><i style="display:block;height:100%;width:${passPct}%;background:#15815c"></i><i style="display:block;height:100%;width:${failPct}%;background:#d34661"></i></div></div>`;
+    }).join("");
+    const caseValidation = parseAdvisorySummary(input.caseValidationSummary);
+    const caseCoverage = parseAdvisorySummary(input.caseCoverageSummary);
+    const traceability = parseAdvisorySummary(input.traceabilitySummary);
+    const correspondence = parseAdvisorySummary(input.correspondenceSummary);
+    const qRow = (name, status, extra = "") => {
+        const c = status === "PASS" ? { fg: "#15815c", bg: "#e7f7f0" } : status === "FAIL" ? { fg: "#d34661", bg: "#fff0f3" } : { fg: "#718097", bg: "#eef2f7" };
+        return `<div style="display:flex;align-items:center;justify-content:space-between;padding:11px 13px;border:1px solid #e4e9f1;border-radius:10px;background:#fbfcfe"><span style="color:#2a3c5a;font-size:13px;font-weight:650">${escapeHtml(name)}</span><span style="font-size:11px;font-weight:800;color:${c.fg};background:${c.bg};padding:2px 8px;border-radius:999px">${status === "Unavailable" ? "UNAVAILABLE" : status}${extra}</span></div>`;
+    };
+    const failures = input.failures && input.failures.length > 0
+        ? input.failures.map((f) => `<details style="border:1px solid #ecd4d9;border-radius:13px;background:linear-gradient(135deg,#fffdfd,#fff8f9);overflow:hidden;margin-top:10px" open><summary style="display:flex;align-items:center;gap:10px;padding:15px;cursor:pointer;list-style:none"><span style="color:#c43b58;font:700 12px ui-monospace,SFMono-Regular,Menlo,monospace">${escapeHtml(f.caseId)}</span><span style="flex:1;color:#17365d;font-size:14px;font-weight:750">${escapeHtml(f.title)}</span><span style="display:inline-flex;align-items:center;padding:3px 9px;border-radius:999px;font-size:11px;font-weight:800;color:#d34661;background:#fff0f3">未修复</span></summary><div style="padding:0 15px 15px;border-top:1px solid #f3dce1"><div style="display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:9px;margin-top:14px">${f.script ? `<div style="padding:9px 10px;border-radius:8px;background:#fff"><label style="display:block;color:#718097;font-size:11px">自动化脚本</label><span style="display:block;margin-top:2px;color:#172033;font-size:12px;font-weight:650;font-family:ui-monospace,SFMono-Regular,Menlo,monospace">${escapeHtml(f.script)}</span></div>` : ""}<div style="padding:9px 10px;border-radius:8px;background:#fff"><label style="display:block;color:#718097;font-size:11px">失败原因</label><span style="display:block;margin-top:2px;color:#172033;font-size:12px;font-weight:650">${escapeHtml(f.message)}</span></div></div>${f.request ? `<div style="margin-top:10px"><div style="color:#667085;font-size:11px;font-weight:600;margin-bottom:3px">请求参数</div><pre style="margin:0;white-space:pre-wrap;color:#344054;font:12px/1.6 ui-monospace,SFMono-Regular,Menlo,monospace;background:#f6f8fa;padding:10px 12px;border-radius:8px;border:1px solid #eceef2">${escapeHtml(f.request)}</pre></div>` : ""}${f.response ? `<div style="margin-top:10px"><div style="color:#667085;font-size:11px;font-weight:600;margin-bottom:3px">响应结果</div><pre style="margin:0;white-space:pre-wrap;color:#344054;font:12px/1.6 ui-monospace,SFMono-Regular,Menlo,monospace;background:#f6f8fa;padding:10px 12px;border-radius:8px;border:1px solid #eceef2">${escapeHtml(f.response)}</pre></div>` : ""}</div></details>`).join("")
+        : "";
+    return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>${escapeHtml(input.title)} · L-5</title></head><body style="margin:0;background:radial-gradient(circle at 8% 0,#edf4ff 0,transparent 36rem),#f5f7fb;color:#17243b;font:15px/1.6 Inter,system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI','Microsoft YaHei',sans-serif"><div style="max-width:1180px;margin:0 auto;padding:42px 28px 72px">
+    <header style="position:relative;overflow:hidden;padding:34px 38px;border:1px solid #294b78;border-radius:26px;background:linear-gradient(125deg,#102849 0%,#173d6d 57%,#245b91 100%);box-shadow:0 18px 40px rgba(16,40,73,.18);display:flex;align-items:flex-start;justify-content:space-between;gap:28px"><div style="position:relative;z-index:1"><div style="color:#9fc6ee;font-size:11px;font-weight:800;letter-spacing:.2em">BACKEND TEST · L-5 QUALITY VIEW</div><h1 style="margin:12px 0 10px;color:#f7fbff;font-size:clamp(30px,3.8vw,46px);font-weight:800;letter-spacing:-.055em;line-height:1.1">${escapeHtml(input.title)}</h1><p style="color:#bdd2e9;font-size:13px;margin:0">${escapeHtml(input.objective ?? "后端自动化测试成熟度报告")}</p></div><div style="position:relative;z-index:1;min-width:220px;padding:16px 18px;border:1px solid ${decision.border};border-radius:18px;background:${decision.bg};box-shadow:0 8px 24px rgba(0,0,0,.08)"><div style="display:flex;align-items:center;gap:9px;color:${decision.color};font-size:17px;font-weight:800"><i style="width:11px;height:11px;border-radius:50%;background:${decision.color};box-shadow:0 0 0 5px ${decision.color}1a;display:inline-block"></i>L-5 ${escapeHtml(decision.text)}</div><small style="display:block;margin:7px 0 0 20px;color:${decision.color};opacity:.85;font-size:12px">${escapeHtml(decision.small)}</small></div></header>
+    <section style="display:grid;grid-template-columns:repeat(4,1fr);gap:14px;margin-top:18px">
+      <div style="position:relative;min-height:132px;padding:21px 22px;overflow:hidden;background:#fff;border:1px solid #e1e8f2;border-radius:15px;box-shadow:0 6px 18px rgba(25,53,92,.045)"><i style="position:absolute;top:0;left:0;right:0;height:3px;background:#4775ef;display:block"></i><div style="color:#748198;font-size:13px;font-weight:650">测试通过率</div><div style="margin-top:19px;color:#13213a;font-size:35px;font-weight:800;letter-spacing:-.06em;line-height:1">${passRatePct}%</div><div style="margin-top:9px;color:${m.passRate.status === "pass" ? "#15815c" : "#c87918"};font-size:12px">${input.parsed.passed} / ${executed} · 目标 100%${m.passRate.status === "pass" ? "（达标）" : "（未达标）"}</div></div>
+      <div style="position:relative;min-height:132px;padding:21px 22px;overflow:hidden;background:#fff;border:1px solid #e1e8f2;border-radius:15px;box-shadow:0 6px 18px rgba(25,53,92,.045)"><i style="position:absolute;top:0;left:0;right:0;height:3px;background:#c87918;display:block"></i><div style="color:#748198;font-size:13px;font-weight:650">AC 验收覆盖</div><div style="margin-top:19px;color:#13213a;font-size:35px;font-weight:800;letter-spacing:-.06em;line-height:1">${acStrong}</div><div style="margin-top:9px;color:${m.acCoverage.status === "pass" ? "#15815c" : m.acCoverage.status === "unavailable" ? "#718097" : "#d34661"};font-size:12px">${m.acCoverage.numerator ?? "—"} / ${m.acCoverage.denominator ?? "—"} · 目标 100%</div></div>
+      <div style="position:relative;min-height:132px;padding:21px 22px;overflow:hidden;background:#fff;border:1px solid #e1e8f2;border-radius:15px;box-shadow:0 6px 18px rgba(25,53,92,.045)"><i style="position:absolute;top:0;left:0;right:0;height:3px;background:#7589d9;display:block"></i><div style="color:#748198;font-size:13px;font-weight:650">自动化覆盖率</div><div style="margin-top:19px;color:#13213a;font-size:35px;font-weight:800;letter-spacing:-.06em;line-height:1">${autoStrong}</div><div style="margin-top:9px;color:${m.automationCoverage.status === "pass" ? "#15815c" : "#c87918"};font-size:12px">${m.automationCoverage.numerator ?? "—"} / ${m.automationCoverage.denominator ?? "—"} · 目标 ≥90%</div></div>
+      <div style="position:relative;min-height:132px;padding:21px 22px;overflow:hidden;background:#fff;border:1px solid #e1e8f2;border-radius:15px;box-shadow:0 6px 18px rgba(25,53,92,.045)"><i style="position:absolute;top:0;left:0;right:0;height:3px;background:${m.criticalRisks.status === "pass" ? "#15815c" : "#d34661"};display:block"></i><div style="color:#748198;font-size:13px;font-weight:650">Critical 风险</div><div style="margin-top:19px;color:#13213a;font-size:35px;font-weight:800;letter-spacing:-.06em;line-height:1">${m.criticalRisks.numerator ?? 0}</div><div style="margin-top:9px;color:${m.criticalRisks.status === "pass" ? "#15815c" : "#d34661"};font-size:12px">${m.criticalRisks.status === "pass" ? "无阻断项" : "阻断级风险"}</div></div>
+    </section>
+    <section style="display:grid;grid-template-columns:1fr 1.35fr;gap:12px;margin-top:18px">
+      <div style="padding:20px 22px;border:1px solid #dfe7f1;border-radius:15px;background:rgba(255,255,255,.82);box-shadow:0 7px 20px rgba(25,53,92,.04)">
+        <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:16px"><div><span style="color:#8796aa;font-size:10px;font-weight:800;letter-spacing:.16em">RUN OUTCOME</span><h2 style="margin:3px 0 0;color:#17365d;font-size:17px">本轮执行结果</h2></div><span style="color:#718097;font-size:11px;white-space:nowrap">${executed} 个用例 · ${formatDuration(input.parsed.durationMs)}</span></div>
+        <div style="position:relative;display:flex;align-items:center;gap:20px;margin-top:15px">
+          <svg viewBox="0 0 120 120" style="width:116px;height:116px;flex:0 0 116px;transform:rotate(-90deg)" role="img" aria-label="${input.parsed.passed} 通过，${input.parsed.failed} 失败"><circle cx="60" cy="60" r="46" fill="none" stroke="#edf1f6" stroke-width="12"></circle><circle cx="60" cy="60" r="46" fill="none" stroke="#15815c" stroke-width="12" stroke-dasharray="${passLen.toFixed(2)} ${circ.toFixed(2)}" stroke-linecap="round"></circle><circle cx="60" cy="60" r="46" fill="none" stroke="#d34661" stroke-width="12" stroke-dasharray="${failLen.toFixed(2)} ${circ.toFixed(2)}" stroke-dashoffset="${(-passLen).toFixed(2)}"></circle></svg>
+          <div style="position:absolute;display:flex;width:116px;height:116px;flex-direction:column;align-items:center;justify-content:center;pointer-events:none"><strong style="color:#17365d;font-size:20px;letter-spacing:-.05em">${passRatePct}%</strong><span style="color:#718097;font-size:10px">通过率</span></div>
+          <div style="display:grid;gap:6px;flex:1"><div style="display:grid;grid-template-columns:10px 1fr auto;align-items:center;gap:7px;color:#718097;font-size:12px"><i style="width:8px;height:8px;border-radius:50%;background:#15815c;display:block"></i><span>通过</span><strong style="color:#17243b;font-size:14px">${input.parsed.passed}</strong></div><div style="display:grid;grid-template-columns:10px 1fr auto;align-items:center;gap:7px;color:#718097;font-size:12px"><i style="width:8px;height:8px;border-radius:50%;background:#d34661;display:block"></i><span>失败</span><strong style="color:#17243b;font-size:14px">${input.parsed.failed}</strong></div><div style="display:grid;grid-template-columns:10px 1fr auto;align-items:center;gap:7px;color:#718097;font-size:12px"><i style="width:8px;height:8px;border-radius:50%;background:#aab5c4;display:block"></i><span>错误 / 跳过</span><strong style="color:#17243b;font-size:14px">${input.parsed.errors + input.parsed.skipped}</strong></div></div>
+        </div>
+      </div>
+      <div style="padding:20px 22px;border:1px solid #dfe7f1;border-radius:15px;background:rgba(255,255,255,.82);box-shadow:0 7px 20px rgba(25,53,92,.04);display:flex;flex-direction:column">
+        <div style="display:flex;align-items:flex-start;justify-content:space-between;gap:16px"><div><span style="color:#8796aa;font-size:10px;font-weight:800;letter-spacing:.16em">QUALITY SIGNALS</span><h2 style="margin:3px 0 0;color:#17365d;font-size:17px">质量信号</h2></div><span style="color:#718097;font-size:11px;white-space:nowrap">按 L-5 门槛判定</span></div>
+        ${signal("需求 / AC 覆盖", acStrong, acWidth, 100, acPct !== null && Number(acPct) >= 100 ? "linear-gradient(90deg,#52b88b,#15815c)" : "linear-gradient(90deg,#e9a040,#f0b85a)", `${m.acCoverage.numerator ?? 0} / ${m.acCoverage.denominator ?? 0} · 目标 100%`)}
+        ${signal("自动化覆盖率", autoStrong, autoWidth, 90, autoPct !== null && Number(autoPct) >= 90 ? "linear-gradient(90deg,#52b88b,#15815c)" : "linear-gradient(90deg,#7d9bf5,#4775ef)", `${m.automationCoverage.numerator ?? 0} / ${m.automationCoverage.denominator ?? 0} · 目标 ≥90%`)}
+        ${signal("用例跳过数", String(input.parsed.skipped), input.parsed.skipped === 0 ? 100 : 0, 100, "linear-gradient(90deg,#52b88b,#15815c)", `${input.parsed.skipped} / ${executed} · 目标 0`)}
+        ${signal("Line 代码覆盖", m.lineCoverage.ratio !== null ? `${(m.lineCoverage.ratio * 100).toFixed(1)}%` : "—", m.lineCoverage.ratio !== null ? Math.round(m.lineCoverage.ratio * 100) : 0, 80, m.lineCoverage.status === "pass" ? "linear-gradient(90deg,#52b88b,#15815c)" : "linear-gradient(90deg,#7d9bf5,#4775ef)", m.lineCoverage.status === "unavailable" ? (m.lineCoverage.reason ?? "unavailable") : `${m.lineCoverage.numerator} / ${m.lineCoverage.denominator} · 目标 ≥80%`)}
+      </div>
+    </section>
+    <section style="display:grid;grid-template-columns:1.28fr .86fr;gap:20px;margin-top:20px">
+      <div style="background:#fff;border:1px solid #e0e7f0;border-radius:15px;box-shadow:0 7px 20px rgba(25,53,92,.04);padding:22px">
+        <div style="display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:18px"><h2 style="margin:0;color:#17365d;font-size:19px">L-5 门禁摘要</h2><span style="color:#718097;font-size:13px">阻断项与执行门槛</span></div>
+        ${l5GateRow("测试通过率", m.passRate, passRatePct + "%", `${input.parsed.passed} / ${executed} 个用例 · 目标 100%`, `失败 ${input.parsed.failed}，错误 ${input.parsed.errors}。<code style="color:#17365d;font:11px ui-monospace,SFMono-Regular,Menlo,monospace">reports/backend-test-facts.md · pytest-exit=${input.parsed.failed + input.parsed.errors > 0 ? 1 : 0}</code>`)}
+        ${l5GateRow("AC 验收覆盖", m.acCoverage, acStrong, `${m.acCoverage.numerator ?? 0} / ${m.acCoverage.denominator ?? 0} · 目标 100%`, m.acCoverage.status === "unavailable" ? "case-manifest coverage 缺失" : "来自 backend-test-case-manifest coverageSummary")}
+        ${l5GateRow("自动化覆盖率", m.automationCoverage, autoStrong, `${m.automationCoverage.numerator ?? 0} / ${m.automationCoverage.denominator ?? 0} · 目标 ≥90%`, m.automationCoverage.status === "unavailable" ? "case-manifest coverage 缺失" : "来自 backend-test-case-manifest coverageSummary")}
+        ${l5GateRow("Critical 风险", m.criticalRisks, String(m.criticalRisks.numerator ?? 0), m.criticalRisks.status === "pass" ? "无阻断项 · 目标 0" : `${m.criticalRisks.numerator ?? 0} 个阻断项 · 目标 0`, m.criticalRisks.status === "pass" ? "无阻断级风险" : "存在阻断级接口契约偏差")}
+        ${l5GateRow("Line 代码覆盖", m.lineCoverage, m.lineCoverage.ratio !== null ? `${(m.lineCoverage.ratio * 100).toFixed(1)}%` : "unavailable", m.lineCoverage.status === "unavailable" ? "未产出 coverage artifact · 目标 ≥80%" : `${m.lineCoverage.numerator} / ${m.lineCoverage.denominator} · 目标 ≥80%`, m.lineCoverage.status === "unavailable" ? (m.lineCoverage.reason ?? "coverage missing") : "来自 validated coverage artifact")}
+      </div>
+      <div style="background:#fff;border:1px solid #e0e7f0;border-radius:15px;box-shadow:0 7px 20px rgba(25,53,92,.04);padding:22px">
+        <div style="display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:18px"><h2 style="margin:0;color:#17365d;font-size:19px">模块通过情况</h2><span style="color:#718097;font-size:13px">${collectModuleStats(input.parsed).length} 个脚本</span></div>
+        <div style="display:grid;grid-template-columns:repeat(2,1fr);gap:10px">${moduleBars || '<div style="color:#718097;font-size:13px">无模块数据</div>'}</div>
+      </div>
+    </section>
+    <section style="background:#fff;border:1px solid #e0e7f0;border-radius:15px;box-shadow:0 7px 20px rgba(25,53,92,.04);padding:22px;margin-top:20px">
+      <div style="display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:12px"><h2 style="margin:0;color:#17365d;font-size:19px">质量校验矩阵</h2><span style="color:#718097;font-size:13px">来自节点 4 / 6</span></div>
+      <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px">
+        ${qRow("环境硬门（Shell）", "PASS")}
+        ${qRow("Markdown 用例校验（节点4）", caseValidation.status, caseValidation.findings !== undefined ? ` · ${caseValidation.findings}` : "")}
+        ${qRow("用例场景覆盖分析（节点4）", caseCoverage.status, caseCoverage.findings !== undefined ? ` · ${caseCoverage.findings}` : "")}
+        ${qRow("Markdown → pytest 追溯（节点6）", traceability.status, traceability.findings !== undefined ? ` · ${traceability.findings}` : "")}
+        ${qRow("Markdown → pytest 一一对应（节点6）", correspondence.status, correspondence.findings !== undefined ? ` · ${correspondence.findings}` : "")}
+        ${qRow("HTTP 请求/响应日志（节点6 advisory）", traceability.status)}
+        ${qRow("Markdown 敏感信息", "PASS")}
+        ${qRow("代码覆盖率", m.lineCoverage.status === "unavailable" && m.lineCoverage.reason !== null ? "Unavailable" : "PASS")}
+      </div>
+    </section>
+    ${failures ? `<section style="background:#fff;border:1px solid #e0e7f0;border-radius:15px;box-shadow:0 7px 20px rgba(25,53,92,.04);padding:22px;margin-top:20px"><div style="display:flex;align-items:center;justify-content:space-between;gap:14px;margin-bottom:12px"><h2 style="margin:0;color:#17365d;font-size:19px">缺陷记录</h2><span style="color:#718097;font-size:13px">${input.failures?.length ?? 0} 条 · 已关联用例与证据</span></div>${failures}</section>` : ""}
+    <section style="background:#fff;border:1px solid #e0e7f0;border-radius:15px;box-shadow:0 7px 20px rgba(25,53,92,.04);padding:22px;margin-top:20px">
+      <p style="margin:0;color:#718097;font-size:12px">报告由 backend-test DAG 节点 8（execute-backend-pytest-and-html-report-shell）基于本轮真实执行产物确定性渲染。L-5 指标由 <code style="color:#17365d;font:11px ui-monospace,SFMono-Regular,Menlo,monospace">computeL5ReportMetrics</code> 机器计算。判定依据：pass=100%、AC=100%、automation≥90%、line≥80%、branch≥70%、skipped=0、无阻断级 Critical 风险。</p>
+    </section>
+  </div></body></html>`;
+}
+export function renderBackendTestFacts(input) {
+    const passRate = input.parsed.tests > 0 ? input.parsed.passed / input.parsed.tests : 0;
+    const caseValidation = parseAdvisorySummary(input.caseValidationSummary);
+    const caseCoverage = parseAdvisorySummary(input.caseCoverageSummary);
+    const traceability = parseAdvisorySummary(input.traceabilitySummary);
+    const correspondence = parseAdvisorySummary(input.correspondenceSummary);
+    const correspondenceNumber = (label) => {
+        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const match = new RegExp(`^- ${escaped}: (\\d+)$`, "mi").exec(input.correspondenceSummary ?? "");
+        return match ? Number.parseInt(match[1], 10) : undefined;
+    };
+    const markdownCaseCount = correspondenceNumber("Markdown Cases");
+    const primarySymbolCount = correspondenceNumber("Primary pytest symbols");
+    const variantTestPointCount = correspondenceNumber("Variant Test Points");
+    const assertionTestPointCount = correspondenceNumber("Assertion Test Points");
+    const crossCuttingTestPointCount = correspondenceNumber("Cross-Cutting Test Points");
+    const executionAmplification = markdownCaseCount && markdownCaseCount > 0 ? input.parsed.tests / markdownCaseCount : undefined;
+    const catalog = new Map((input.cases ?? []).map((entry) => [entry.id, entry]));
+    return ([
+        "# 后端自动化测试执行报告",
+        "",
+        `> ${input.pytestExitCode === 0 ? `本轮 ${input.parsed.passed}/${input.parsed.tests} 条用例通过。` : `本轮有 ${input.parsed.failed + input.parsed.errors} 条失败或错误，请查看失败概览。`}`,
+        "",
+        "## 测试概览",
+        "",
+        "| 状态 | 总数 | 通过 | 失败 | 错误 | 跳过 | 通过率 | 总耗时 |",
+        "|---|---:|---:|---:|---:|---:|---:|---:|",
+        `| ${input.pytestExitCode === 0 ? "通过" : "未通过"} | ${input.parsed.tests} | ${input.parsed.passed} | ${input.parsed.failed} | ${input.parsed.errors} | ${input.parsed.skipped} | ${(passRate * 100).toFixed(2)}% | ${formatDuration(input.parsed.durationMs)} |`,
+        "",
+        `- Pytest exit code: ${input.pytestExitCode}`,
+        `- Markdown Cases: ${markdownCaseCount ?? "unavailable"}`,
+        `- Primary pytest symbols: ${primarySymbolCount ?? "unavailable"}`,
+        `- Collected pytest items: ${input.parsed.tests}`,
+        `- Test Point bindings: variant=${variantTestPointCount ?? "unavailable"}, assertion=${assertionTestPointCount ?? "unavailable"}, cross-cutting=${crossCuttingTestPointCount ?? "unavailable"}`,
+        `- Execution amplification (items/case): ${executionAmplification === undefined ? "unavailable" : executionAmplification.toFixed(2)}`,
+        "- Pytest item count is an execution-unit count, not a business-scenario count.",
+        "- Pytest-html report: valid",
+        "- HTML valid: yes",
+        "",
+        "## 质量校验",
+        "",
+        "| 校验项 | 状态 | Findings | 首要发现 |",
+        "|---|---|---:|---|",
+        `| Markdown 用例校验 | ${caseValidation.status} | ${caseValidation.findings ?? "不可用"} | ${caseValidation.firstFinding.replaceAll("|", "\\|")} |`,
+        `| 用例场景覆盖分析 | ${caseCoverage.status} | ${caseCoverage.findings ?? "不可用"} | ${caseCoverage.firstFinding.replaceAll("|", "\\|")} |`,
+        `| Markdown → pytest 追溯 | ${traceability.status} | ${traceability.findings ?? "不可用"} | ${traceability.firstFinding.replaceAll("|", "\\|")} |`,
+        `| Markdown → pytest 一一对应 | ${correspondence.status} | ${correspondence.findings ?? "不可用"} | ${correspondence.firstFinding.replaceAll("|", "\\|")} |`,
+        "",
+        "## 失败概览",
+        "",
+        ...(input.parsed.failures.length > 0
+            ? input.parsed.failures.map((failure) => `- **${failure.name}** · ${failure.kind}: ${failure.message}`)
+            : ["- 无失败或错误用例。"]),
+        "",
+        "## 用例执行明细",
+        "",
+        "| 用例编号 | 用例名称 | 自动化脚本 | 测试函数 | 结果 | 耗时 | 失败原因 |",
+        "|---|---|---|---|---|---:|---|",
+        ...input.parsed.cases.map((result) => {
+            const caseId = resolveReportCaseId(result, catalog);
+            const item = caseId === "未关联" ? undefined : catalog.get(caseId);
+            const script = resolveReportScriptPath(result, item);
+            return `| ${caseId} | ${item?.title ?? result.name} | \`${script}\` | \`${result.name}\` | ${humanStatus(result.status)} | ${formatDuration(result.durationMs)} | ${(result.message ?? "—").replaceAll("|", "\\|")} |`;
+        }),
+        "",
+        "## 证据与完整校验原文",
+        "",
+        `- HTML: ${input.htmlRelativePath}`,
+        `- HTML SHA-256: ${createHash("sha256").update(input.htmlContent).digest("hex")}`,
+        "",
+        "<details>",
+        "<summary>Markdown 用例校验原文</summary>",
+        "",
+        input.caseValidationSummary?.trim() ?? "Unavailable",
+        "",
+        "</details>",
+        "",
+        "<details>",
+        "<summary>用例场景覆盖分析原文</summary>",
+        "",
+        input.caseCoverageSummary?.trim() ?? "Unavailable",
+        "",
+        "</details>",
+        "",
+        "<details>",
+        "<summary>Markdown → pytest 追溯原文</summary>",
+        "",
+        input.traceabilitySummary?.trim() ?? "Unavailable",
+        "",
+        "</details>",
+        "",
+        "<details>",
+        "<summary>Markdown → pytest 一一对应原文</summary>",
+        "",
+        input.correspondenceSummary?.trim() ?? "Unavailable",
+        "",
+        "</details>",
+        "",
+        "## 覆盖率证据",
+        "",
+        "- Code coverage: unavailable unless a separate validated coverage artifact exists.",
+        "- Coverage is reported only when a separate validated coverage artifact exists; this single execution does not produce a coverage result.",
+    ].join("\n") + "\n");
+}
+export async function writeRunReport(runDir, fileName, content) {
+    const reportsDir = path.join(runDir, "reports");
+    await mkdir(reportsDir, { recursive: true });
+    const absolute = path.join(reportsDir, fileName);
+    await writeFile(absolute, content, "utf8");
+    return absolute;
+}