@tea-agent/loop-agent 0.25.3 → 0.25.5

package/dist/workflows/dag/backend-test-result-contract.js

@@ -359,12 +359,36 @@ const HTML_ENTITY_MAP = {
     "&lt;": "<",
     "&gt;": ">",
     "&quot;": '"',
-    "&#34;": '"',
-    "&#39;": "'",
     "&apos;": "'",
 };
+/** Decode one HTML entity layer. Safe for the outer data-jsonblob attribute. */
 function decodeHtmlEntities(value) {
-    return value.replace(/&(?:amp|lt|gt|quot|#34|#39|apos);/g, (entity) => HTML_ENTITY_MAP[entity] ?? entity);
+    return value.replace(/&(?:amp|lt|gt|quot|apos|#\d+|#x[0-9a-f]+);/gi, (entity) => {
+        const named = HTML_ENTITY_MAP[entity.toLowerCase()];
+        if (named !== undefined)
+            return named;
+        const hex = entity.match(/^&#x([0-9a-f]+);$/i)?.[1];
+        const decimal = entity.match(/^&#(\d+);$/)?.[1];
+        const codePoint = hex
+            ? Number.parseInt(hex, 16)
+            : decimal
+                ? Number.parseInt(decimal, 10)
+                : Number.NaN;
+        return Number.isFinite(codePoint)
+            ? String.fromCodePoint(codePoint)
+            : entity;
+    });
+}
+/** Decode nested entities only after JSON parsing; bounded to avoid overwork. */
+function decodeHtmlEntitiesDeep(value) {
+    let current = value;
+    for (let index = 0; index < 3; index += 1) {
+        const decoded = decodeHtmlEntities(current);
+        if (decoded === current)
+            break;
+        current = decoded;
+    }
+    return current;
 }
 function parseDurationLabelMs(raw) {
     if (!raw)
@@ -432,6 +456,7 @@ export function parsePytestHtmlReport(html) {
         const filePathFields = filePath ? { filePath } : {};
         const durationMs = parseDurationLabelMs(record.duration);
         const capturedLog = record.log ?? "";
+        const decodedCapturedLog = decodeHtmlEntitiesDeep(capturedLog);
         // pytest-html collapses captured stdout/stderr into a single `log` field
         // annotated with section markers. Preserve the whole log as stdout so the
         // HTTP_REQUEST/HTTP_RESPONSE lines stay reachable for the per-case card.
@@ -462,7 +487,7 @@ export function parsePytestHtmlReport(html) {
                 durationMs,
                 status: "failure",
                 message: summary,
-                details: capturedLog || summary,
+                details: decodedCapturedLog || summary,
                 ...(stdout ? { stdout } : {}),
                 ...(stderr ? { stderr } : {}),
             });
@@ -479,7 +504,7 @@ export function parsePytestHtmlReport(html) {
                 durationMs,
                 status: "error",
                 message: summary,
-                details: capturedLog || summary,
+                details: decodedCapturedLog || summary,
                 ...(stdout ? { stdout } : {}),
                 ...(stderr ? { stderr } : {}),
             });
@@ -509,7 +534,7 @@ export function parsePytestHtmlReport(html) {
                 durationMs,
                 status: "error",
                 message: summary,
-                details: capturedLog || summary,
+                details: decodedCapturedLog || summary,
                 ...(stdout ? { stdout } : {}),
                 ...(stderr ? { stderr } : {}),
             });
@@ -572,7 +597,7 @@ function splitPytestHtmlLogSections(log) {
     // pytest-html HTML-entity-escapes the captured log content (e.g. `&quot;`
     // for `"`). Decode entities first so downstream HTTP log parsers see the
     // real JSON/kv payload rather than escaped markup.
-    const decoded = decodeHtmlEntities(log);
+    const decoded = decodeHtmlEntitiesDeep(log);
     // pytest-html interleaves captured stdout/stderr with section markers like
     // "----------------------------- Captured stdout call -----------------------------".
     // String.split includes capture-group matches in the result array, so the
@@ -601,16 +626,17 @@ function splitPytestHtmlLogSections(log) {
 function extractPytestHtmlFailureMessage(log) {
     if (!log)
         return "";
+    const decoded = decodeHtmlEntitiesDeep(log);
     // pytest-html failure logs contain assertion lines prefixed with "E   " and a
     // trailing location line like "test_x.py:N: AssertionError". Prefer the
     // explicit AssertionError/Error line; fall back to the last "E   " line.
-    const assertionLine = log
+    const assertionLine = decoded
         .split(/\r?\n/)
         .map((line) => line.trim())
         .find((line) => /:\s*AssertionError/.test(line));
     if (assertionLine)
         return assertionLine.replace(/^.*?:\s*/, "");
-    const eLines = log
+    const eLines = decoded
         .split(/\r?\n/)
         .filter((line) => /^E\s+/.test(line))
         .map((line) => line.replace(/^E\s+/, "").trim());

package/dist/workflows/dag/convergence/controller.js

@@ -8,6 +8,16 @@ const DEFAULT_CONVERGENCE_CHAIN_NODE_IDS = [
     "repair-pi",
     "hard-verify-shell",
 ];
+/**
+ * Review chain node ids that the supervised convergence loop may also observe.
+ * When these are part of the active convergence chain (via
+ * `spec.convergence.chainNodeIds`), a legitimate review `request-revision`
+ * re-enters the same bounded repair-reverify-review loop instead of only
+ * blocking closeout. Review protocol-invalid failures keep using their own
+ * protocol recovery; only a safe `request-revision` drives code repair here.
+ */
+const REVIEW_GATE_NODE_ID = "review-gate-shell";
+const REVIEW_VERDICT_NODE_ID = "review-verdict-recovery-pi";
 const CONVERGENCE_NON_RETRY_FAILURES = new Set([
     "timeout",
     "spawn-error",
@@ -17,6 +27,11 @@ const CONVERGENCE_NON_RETRY_FAILURES = new Set([
     "human-rejected",
     "decision-gate-requires-human",
 ]);
+const REVIEW_SOURCE_NON_RETRY_FAILURES = new Set([
+    ...CONVERGENCE_NON_RETRY_FAILURES,
+    "protocol-invalid",
+    "invalid-output",
+]);
 export function shouldEnableDagConvergence(spec) {
     return (process.env.HARNESS_DAG_CONVERGENCE !== "off" &&
         spec.convergence?.enabled === true);
@@ -33,10 +48,22 @@ export async function runConvergencePassController(input) {
         convergence.terminalReason = "unsupported-dag-shape";
         return { retry: false };
     }
+    const chain = getConvergenceChain(input.spec);
+    const observesReview = chain.includes(REVIEW_GATE_NODE_ID);
     const hardVerify = input.state.nodes["hard-verify-shell"];
     if (!hardVerify)
         return { retry: false };
-    if (hardVerify.status === "FINISHED") {
+    if (hardVerify.status === "ERROR") {
+        return handleHardVerifyFailure(input, hardVerify);
+    }
+    if (hardVerify.status !== "FINISHED")
+        return { retry: false };
+    // Hard verification passed. When the chain observes a review gate, success
+    // is gated on the review verdict: a legitimate `request-revision` re-enters
+    // the same bounded repair-reverify-review loop (AC3/AC4). Non-supervised
+    // DAGs without a review gate in the chain keep the original hard-verify-pass
+    // terminal behavior.
+    if (!observesReview) {
         convergence.terminalReason = "hard-verify-pass";
         await appendConvergenceKnowledgePattern({
             cwd: input.cwd,
@@ -44,8 +71,29 @@ export async function runConvergencePassController(input) {
         });
         return { retry: false };
     }
-    if (hardVerify.status !== "ERROR")
+    const reviewGate = input.state.nodes[REVIEW_GATE_NODE_ID];
+    if (!reviewGate)
         return { retry: false };
+    if (reviewGate.status === "FINISHED") {
+        convergence.terminalReason = "review-pass";
+        await appendConvergenceKnowledgePattern({
+            cwd: input.cwd,
+            state: input.state,
+        });
+        return { retry: false };
+    }
+    if (reviewGate.status === "ERROR") {
+        return handleReviewRequestRevision(input, reviewGate);
+    }
+    // Review gate still PENDING/SKIPPED mid-rank: wait for the next loop.
+    return { retry: false };
+}
+/**
+ * Hard verification failed. Apply the existing non-retry / regression /
+ * max-passes guards, then reset the convergence chain for another pass.
+ */
+async function handleHardVerifyFailure(input, hardVerify) {
+    const convergence = input.state.convergence;
     const currentPass = convergence.currentPass || 1;
     const hardFailure = hardVerify.failureCategory ?? "unknown";
     const passRecord = await buildConvergencePassRecord({
@@ -97,6 +145,69 @@ export async function runConvergencePassController(input) {
     await input.persistState();
     return { retry: true };
 }
+/**
+ * Hard verification passed but the review gate blocked closeout with a
+ * legitimate `request-revision` (review-gate-shell ERRORs when the verdict is
+ * not `pass`). Re-enter the same bounded recovery chain so repair can address
+ * the review findings, then re-verify and re-review. Review protocol-invalid
+ * and invalid-output sources, plus safety failures such as auth/write-guard,
+ * stay fail-closed and never enter code repair.
+ */
+async function handleReviewRequestRevision(input, reviewGate) {
+    const convergence = input.state.convergence;
+    const currentPass = convergence.currentPass || 1;
+    const reviewNode = input.state.nodes["review-pi"];
+    const reviewVerdictNode = input.state.nodes[REVIEW_VERDICT_NODE_ID];
+    // The gate commonly reports only nonzero-exit. Inspect the complete review
+    // chain so recovery output cannot launder provider/safety/protocol failures
+    // into automatic code repair.
+    const reviewFailure = [reviewGate, reviewVerdictNode, reviewNode]
+        .map((node) => node?.failureCategory)
+        .find((category) => category && REVIEW_SOURCE_NON_RETRY_FAILURES.has(category));
+    const legitimateRequestRevision = reviewNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewNode) === "request-revision" &&
+        reviewVerdictNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewVerdictNode) === "request-revision";
+    if (reviewFailure || !legitimateRequestRevision) {
+        const passRecord = await buildConvergencePassRecord({
+            pass: currentPass,
+            status: "terminal",
+            reason: "non-retry-failure",
+            state: input.state,
+            runDir: input.runDir,
+            spec: input.spec,
+        });
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "non-retry-failure";
+        await input.persistState();
+        return { retry: false };
+    }
+    const passRecord = await buildConvergencePassRecord({
+        pass: currentPass,
+        status: "retrying",
+        reason: "review-request-revision",
+        state: input.state,
+        runDir: input.runDir,
+        spec: input.spec,
+    });
+    if (currentPass >= convergence.maxPasses) {
+        passRecord.status = "terminal";
+        passRecord.reason = "max-passes";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "max-passes";
+        await input.persistState();
+        return { retry: false };
+    }
+    convergence.passHistory.push(passRecord);
+    convergence.currentPass = currentPass + 1;
+    await resetConvergenceNodesForNextPass({
+        spec: input.spec,
+        state: input.state,
+        tasksById: input.tasksById,
+    });
+    await input.persistState();
+    return { retry: true };
+}
 function getConvergenceChain(spec) {
     return spec.convergence?.chainNodeIds ?? DEFAULT_CONVERGENCE_CHAIN_NODE_IDS;
 }
@@ -107,6 +218,8 @@ function hasConvergenceChain(tasksById, spec) {
 async function buildConvergencePassRecord(input) {
     const hardVerify = input.state.nodes["hard-verify-shell"];
     const processSupervisor = input.state.nodes["process-supervisor-pi"];
+    const reviewVerdictNode = input.state.nodes[REVIEW_VERDICT_NODE_ID];
+    const reviewGate = input.state.nodes[REVIEW_GATE_NODE_ID];
     const verifyEvidence = hardVerify?.verifyEvidence;
     return {
         pass: input.pass,
@@ -123,6 +236,9 @@ async function buildConvergencePassRecord(input) {
         verifyCommandCount: verifyEvidence?.commandCount,
         verifyCommandLabels: verifyEvidence?.commandLabels,
         shellSuccessCount: countSuccessfulShellCommands(hardVerify?.stdout),
+        reviewVerdict: parseProcessVerdict(reviewVerdictNode),
+        reviewGateStatus: reviewGate?.status,
+        reviewFailureCategory: reviewGate?.failureCategory,
         artifactRefs: await preserveConvergencePassArtifacts({
             pass: input.pass,
             state: input.state,
@@ -241,10 +357,17 @@ function extractSupervisorStructuredBlock(node) {
     // Legacy compatibility only. New supervisor prompts must emit REPAIR_ARTIFACT_JSON.
     const text = `${node?.assistantText ?? ""}\n${node?.stdout ?? ""}`;
     const block = {};
-    for (const key of ["FAILURE_CLASS", "FIX_SCOPE", "INVARIANT"]) {
-        const match = text.match(new RegExp(`^${key}:\\s*(.+)$`, "im"));
-        if (match?.[1])
-            block[key] = match[1].trim();
+    const acceptedKeys = new Set(["FAILURE_CLASS", "FIX_SCOPE", "INVARIANT"]);
+    for (const line of text.split(/\r?\n/)) {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0)
+            continue;
+        const key = line.slice(0, separatorIndex).trim().toUpperCase();
+        if (!acceptedKeys.has(key))
+            continue;
+        const value = line.slice(separatorIndex + 1).trim();
+        if (value)
+            block[key] = value;
     }
     return block;
 }
@@ -252,9 +375,11 @@ async function resetConvergenceNodesForNextPass(input) {
     const chain = getConvergenceChain(input.spec);
     const resetIds = new Set(chain);
     for (const id of collectTransitiveDescendantTaskIds(input.spec, "hard-verify-shell")) {
-        const node = input.state.nodes[id];
-        if (node?.status === "SKIPPED")
-            resetIds.add(id);
+        // A new repair pass invalidates every downstream result, including nodes
+        // that already FINISHED (for example authority audit or failure-aware
+        // closeout). Reset the complete controlled descendant closure so the next
+        // pass cannot reuse stale governance or handoff evidence.
+        resetIds.add(id);
     }
     for (const id of resetIds) {
         const task = input.tasksById.get(id);

package/dist/workflows/dag/frontend-test-case-checklist.js

@@ -0,0 +1,71 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+async function exists(file) {
+    try {
+        return (await stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export async function validateFrontendCaseChecklist(input) {
+    const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
+    const draft = path.join(root, "manifest.draft.json");
+    const final = path.join(root, "manifest.json");
+    const manifestPath = await exists(draft) ? draft : await exists(final) ? final : "";
+    if (!manifestPath)
+        throw new Error("checklist: missing manifest.draft.json or manifest.json");
+    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (!Array.isArray(manifest.cases) || manifest.cases.length === 0)
+        throw new Error("checklist: empty cases");
+    const declaredAc = new Set(input.declaredAcIds ?? []);
+    const issues = [];
+    const caseIdRe = /^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;
+    const acIdRe = /^AC(?:-[A-Z0-9]+)+$/i;
+    const openRe = /playwright-cli\s+open\s+--browser=chrome\s+--headed\s+https?:\/\/\S+/i;
+    const productionHostRe = /(^|[.-])(prod|production)([.-]|$)/i;
+    for (const raw of manifest.cases) {
+        const item = raw;
+        const id = typeof item?.caseId === "string" ? item.caseId : "?";
+        if (typeof item?.caseId !== "string" || !caseIdRe.test(item.caseId))
+            issues.push({ ruleId: "case-id-shape", caseId: id, detail: "caseId must be FE-<FEATURE>-<NNN>-<dimension>, never AC-FE-*" });
+        if (typeof item?.caseId === "string" && /^AC-/i.test(item.caseId))
+            issues.push({ ruleId: "case-id-is-ac", caseId: id, detail: "caseId must not be an acceptance id" });
+        const casePath = typeof item?.casePath === "string" ? item.casePath : "";
+        const expectedPath = typeof item?.caseId === "string" ? `testcase/frontend/cases/${item.caseId}.md` : "";
+        const absolute = path.resolve(input.workspaceRoot, casePath);
+        const relative = path.relative(input.workspaceRoot, absolute);
+        if (!casePath || relative.startsWith("..") || path.isAbsolute(relative) || !(await exists(absolute))) {
+            issues.push({ ruleId: "case-file-missing", caseId: id, detail: casePath || "missing casePath" });
+            continue;
+        }
+        if (expectedPath && casePath.replaceAll("\\", "/") !== expectedPath)
+            issues.push({ ruleId: "case-path-mismatch", caseId: id, detail: `${casePath} must equal ${expectedPath}` });
+        const body = await readFile(absolute, "utf8");
+        if (!openRe.test(body))
+            issues.push({ ruleId: "open-prefix", caseId: id, detail: "missing playwright-cli open --browser=chrome --headed <absolute-url>" });
+        const match = body.match(/playwright-cli\s+open\s+--browser=chrome\s+--headed\s+(https?:\/\/\S+)/i);
+        if (match) {
+            try {
+                const url = new URL(match[1].replace(/[)\]},.\"'`]+$/, ""));
+                if (productionHostRe.test(url.hostname))
+                    issues.push({ ruleId: "production-url", caseId: id, detail: match[1] });
+            }
+            catch {
+                issues.push({ ruleId: "production-url", caseId: id, detail: match[1] });
+            }
+        }
+        if (!Array.isArray(item?.acIds) || item.acIds.length === 0) {
+            issues.push({ ruleId: "ac-mapping", caseId: id, detail: "acIds required" });
+        }
+        else {
+            for (const ac of item.acIds) {
+                if (typeof ac !== "string" || !acIdRe.test(ac))
+                    issues.push({ ruleId: "ac-id-shape", caseId: id, detail: String(ac) });
+                else if (declaredAc.size > 0 && !declaredAc.has(ac))
+                    issues.push({ ruleId: "unknown-ac", caseId: id, detail: `${ac} not in sourceBinding` });
+            }
+        }
+    }
+    return { caseCount: manifest.cases.length, manifestPath, issues };
+}

package/dist/workflows/dag/frontend-test-html-report.js

@@ -0,0 +1,77 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { frontendTestResultContractSchema } from "./frontend-test-result-contract.js";
+function escapeHtml(value) {
+    return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function statusLabel(status) {
+    return status === "passed" ? "通过" : status === "failed" ? "失败" : "阻塞";
+}
+function listMarkdown(items) {
+    return items.length ? items.map((item, index) => `${index + 1}. ${item}`).join("\n") : "- 无";
+}
+function listHtml(items) {
+    return items.length ? `<ol>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ol>` : "<p>无</p>";
+}
+async function writePairAtomic(markdownPath, markdown, htmlPath, html) {
+    await mkdir(path.dirname(markdownPath), { recursive: true });
+    const nonce = `${process.pid}-${Date.now()}`;
+    const markdownTemp = `${markdownPath}.${nonce}.tmp`;
+    const htmlTemp = `${htmlPath}.${nonce}.tmp`;
+    try {
+        await writeFile(markdownTemp, markdown, "utf8");
+        await writeFile(htmlTemp, html, "utf8");
+        await rename(markdownTemp, markdownPath);
+        await rename(htmlTemp, htmlPath);
+    }
+    finally {
+        await rm(markdownTemp, { force: true });
+        await rm(htmlTemp, { force: true });
+    }
+}
+export async function renderFrontendTestHtmlReport(input) {
+    const resultPath = path.join(input.runDir, "contracts", "frontend-test-result.json");
+    const result = frontendTestResultContractSchema.parse(JSON.parse(await readFile(resultPath, "utf8")));
+    const outputDir = path.join(input.workspaceRoot, "testcase", "frontend", "reports");
+    const markdownPath = path.join(outputDir, "frontend-test-report.md");
+    const htmlPath = path.join(outputDir, "frontend-test-report.html");
+    const outcomeLabel = result.outcome === "passed" ? "测试通过" : result.outcome === "failed" ? "测试失败" : "测试未完成";
+    const markdownCases = result.cases.map((item) => [
+        `## ${item.caseId}`,
+        "",
+        `- 执行结果：${statusLabel(item.status)}`,
+        "",
+        "### 测试目的",
+        "",
+        item.caseContent.purpose,
+        "",
+        "### 前置条件",
+        "",
+        listMarkdown(item.caseContent.preconditions),
+        "",
+        "### 操作步骤",
+        "",
+        listMarkdown(item.caseContent.steps),
+        "",
+        "### 预期结果",
+        "",
+        listMarkdown(item.caseContent.expectedResults),
+        ...(item.status === "passed" ? [] : ["", "### 错误分析", "", item.errorAnalysis ?? `用例因 ${item.blockedReason ?? "未知原因"} 未能完成。`]),
+    ].join("\n")).join("\n\n");
+    const markdown = [
+        "# 前端功能测试报告",
+        "",
+        `- 测试结论：${outcomeLabel}`,
+        `- 用例总数：${result.totals.cases}`,
+        `- 通过：${result.totals.passed}`,
+        `- 失败：${result.totals.failed}`,
+        `- 阻塞：${result.totals.blocked}`,
+        "",
+        markdownCases,
+        "",
+    ].join("\n");
+    const htmlCases = result.cases.map((item) => `<section class="case ${item.status}"><header><h2>${escapeHtml(item.caseId)}</h2><span class="status">${statusLabel(item.status)}</span></header><h3>测试目的</h3><p>${escapeHtml(item.caseContent.purpose)}</p><h3>前置条件</h3>${listHtml(item.caseContent.preconditions)}<h3>操作步骤</h3>${listHtml(item.caseContent.steps)}<h3>预期结果</h3>${listHtml(item.caseContent.expectedResults)}${item.status === "passed" ? "" : `<h3>错误分析</h3><p class="error">${escapeHtml(item.errorAnalysis ?? `用例因 ${item.blockedReason ?? "未知原因"} 未能完成。`)}</p>`}</section>`).join("");
+    const html = `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'"><title>前端功能测试报告</title><style>body{font:16px system-ui,"Microsoft YaHei",sans-serif;margin:0;background:#f5f7fb;color:#172033}main{max-width:1100px;margin:auto;padding:32px}.summary,.case{background:#fff;border-radius:14px;padding:22px;margin:16px 0;box-shadow:0 6px 24px rgba(16,24,40,.07)}.metrics{display:grid;grid-template-columns:repeat(4,1fr);gap:12px}.metric{background:#f8fafc;padding:14px;border-radius:10px}.case header{display:flex;justify-content:space-between;gap:16px}.status{font-weight:700}.passed .status{color:#067647}.failed .status,.error{color:#b42318}.blocked .status{color:#946200}li{margin:.45rem 0}@media(max-width:700px){.metrics{grid-template-columns:1fr 1fr}}</style></head><body><main><h1>前端功能测试报告</h1><section class="summary"><h2>${outcomeLabel}</h2><div class="metrics"><div class="metric">用例总数<br><strong>${result.totals.cases}</strong></div><div class="metric">通过<br><strong>${result.totals.passed}</strong></div><div class="metric">失败<br><strong>${result.totals.failed}</strong></div><div class="metric">阻塞<br><strong>${result.totals.blocked}</strong></div></div></section>${htmlCases}</main></body></html>`;
+    await writePairAtomic(markdownPath, markdown, htmlPath, html);
+    return { markdownPath, htmlPath, outcome: result.outcome, caseCount: result.cases.length };
+}

package/dist/workflows/dag/frontend-test-l5-report.js

@@ -0,0 +1,138 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { frontendTestResultContractSchema, } from "./frontend-test-result-contract.js";
+function ratioMetric(numerator, denominator, threshold, label) {
+    if (denominator === 0) {
+        return { numerator, denominator, ratio: null, threshold, status: "unavailable", reason: `${label}-denominator-is-zero` };
+    }
+    const ratio = numerator / denominator;
+    return {
+        numerator,
+        denominator,
+        ratio,
+        threshold,
+        status: ratio >= threshold ? "pass" : "fail",
+        reason: ratio >= threshold ? null : `${label}-below-threshold`,
+    };
+}
+function unavailable(reason, threshold) {
+    return { numerator: null, denominator: null, ratio: null, threshold, status: "unavailable", reason };
+}
+/** Compute the shared L-5 gates from the authoritative frontend result contract. */
+export function computeFrontendL5ReportMetrics(result) {
+    const executed = result.totals.passed + result.totals.failed;
+    const acTotal = result.acceptanceCoverage.covered.length + result.acceptanceCoverage.missing.length;
+    const automationExecuted = executed;
+    const criticalRiskCount = result.acceptanceCoverage.missing.length + result.advisoryFindings.filter((finding) => /critical|blocking|unsafe|missing-ac/i.test(finding.ruleId)).length;
+    const metrics = {
+        passRate: ratioMetric(result.totals.passed, executed, 1, "pass-rate"),
+        acCoverage: ratioMetric(result.acceptanceCoverage.covered.length, acTotal, 1, "ac-coverage"),
+        automationCoverage: ratioMetric(automationExecuted, result.totals.cases, 0.9, "automation-coverage"),
+        lineCoverage: unavailable("frontend-code-coverage-missing", 0.8),
+        branchCoverage: unavailable("frontend-code-coverage-missing", 0.7),
+        skipped: {
+            numerator: result.totals.blocked,
+            denominator: result.totals.blocked,
+            ratio: result.totals.blocked === 0 ? 1 : 0,
+            threshold: 1,
+            status: result.totals.blocked === 0 ? "pass" : "fail",
+            reason: result.totals.blocked === 0 ? null : "skipped-tests-present",
+        },
+        criticalRisks: {
+            numerator: criticalRiskCount,
+            denominator: criticalRiskCount,
+            ratio: criticalRiskCount === 0 ? 1 : 0,
+            threshold: 1,
+            status: criticalRiskCount === 0 ? "pass" : "fail",
+            reason: criticalRiskCount === 0 ? null : "critical-risk-present",
+        },
+    };
+    const blockingItems = Object.entries(metrics)
+        .filter(([, metric]) => metric.status !== "pass")
+        .map(([name, metric]) => `${name}:${metric.reason ?? metric.status}`);
+    return {
+        status: blockingItems.length === 0 ? "ready" : "not-ready",
+        metrics,
+        blockingItems,
+    };
+}
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function metricValue(metric) {
+    if (metric.ratio === null)
+        return "unavailable";
+    return `${(metric.ratio * 100).toFixed(1)}%`;
+}
+function metricRow(label, metric) {
+    return `| ${label} | ${metric.numerator ?? "-"} / ${metric.denominator ?? "-"} | ${metricValue(metric)} | ${metric.status.toUpperCase()} | ${metric.reason ?? "-"} |`;
+}
+function renderMarkdown(result, metrics) {
+    const m = metrics.metrics;
+    return [
+        "# 前端测试 L-5 报告",
+        "",
+        `- L-5 结论：**${metrics.status === "ready" ? "READY" : "NOT READY"}**`,
+        `- Result v1 outcome：${result.outcome}`,
+        "",
+        "| 指标 | 分子 / 分母 | 比例 | 状态 | 原因 |",
+        "| --- | ---: | ---: | --- | --- |",
+        metricRow("测试通过率", m.passRate),
+        metricRow("AC 验收覆盖", m.acCoverage),
+        metricRow("自动化覆盖率", m.automationCoverage),
+        metricRow("Line 代码覆盖", m.lineCoverage),
+        metricRow("Branch 代码覆盖", m.branchCoverage),
+        metricRow("阻塞/跳过用例", m.skipped),
+        metricRow("Critical 风险", m.criticalRisks),
+        "",
+        "## 判定规则",
+        "",
+        "测试通过率=100%、AC 覆盖=100%、自动化覆盖率≥90%、Line≥80%、Branch≥70%、阻塞/跳过=0 且无 Critical 风险时才为 READY。",
+        "前端 DAG 当前没有可信的 line/branch 代码覆盖产物，因此这两项保持 unavailable，不得推断。",
+        "",
+        "## 阻塞项",
+        "",
+        ...(metrics.blockingItems.length ? metrics.blockingItems.map((item) => `- ${item}`) : ["- 无"]),
+        "",
+    ].join("\n");
+}
+function renderHtml(result, metrics) {
+    const rows = Object.entries(metrics.metrics)
+        .map(([name, metric]) => `<tr><td>${escapeHtml(name)}</td><td>${metric.numerator ?? "-"} / ${metric.denominator ?? "-"}</td><td>${escapeHtml(metricValue(metric))}</td><td class="${metric.status}">${escapeHtml(metric.status.toUpperCase())}</td><td>${escapeHtml(metric.reason ?? "-")}</td></tr>`)
+        .join("");
+    const blocking = metrics.blockingItems.length
+        ? metrics.blockingItems.map((item) => `<li>${escapeHtml(item)}</li>`).join("")
+        : "<li>无</li>";
+    return `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta http-equiv="Content-Security-Policy" content="default-src 'none';style-src 'unsafe-inline'"><title>前端测试 L-5 报告</title><style>body{font:15px system-ui,"Microsoft YaHei",sans-serif;background:#f5f7fb;color:#172033;margin:0}main{max-width:1100px;margin:auto;padding:32px}.card{background:#fff;border-radius:14px;padding:24px;margin:16px 0;box-shadow:0 6px 24px #10182812}.decision{font-size:28px;font-weight:800;color:${metrics.status === "ready" ? "#067647" : "#b42318"}}table{width:100%;border-collapse:collapse}th,td{text-align:left;padding:12px;border-bottom:1px solid #e4e7ec}.pass{color:#067647}.fail{color:#b42318}.unavailable{color:#946200}code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace}</style></head><body><main><section class="card"><h1>前端测试 L-5 报告</h1><div class="decision">${metrics.status === "ready" ? "READY" : "NOT READY"}</div><p>Result v1 outcome：<code>${escapeHtml(result.outcome)}</code></p></section><section class="card"><h2>指标</h2><table><thead><tr><th>指标</th><th>分子 / 分母</th><th>比例</th><th>状态</th><th>原因</th></tr></thead><tbody>${rows}</tbody></table></section><section class="card"><h2>阻塞项</h2><ul>${blocking}</ul><p>前端 DAG 当前没有可信的 line/branch 代码覆盖产物，因此这两项为 unavailable，不得推断。</p></section></main></body></html>`;
+}
+async function writePairAtomic(markdownPath, markdown, htmlPath, html) {
+    await mkdir(path.dirname(markdownPath), { recursive: true });
+    const nonce = `${process.pid}-${Date.now()}`;
+    const markdownTemp = `${markdownPath}.${nonce}.tmp`;
+    const htmlTemp = `${htmlPath}.${nonce}.tmp`;
+    try {
+        await writeFile(markdownTemp, markdown, "utf8");
+        await writeFile(htmlTemp, html, "utf8");
+        await rename(markdownTemp, markdownPath);
+        await rename(htmlTemp, htmlPath);
+    }
+    finally {
+        await rm(markdownTemp, { force: true });
+        await rm(htmlTemp, { force: true });
+    }
+}
+export async function renderFrontendTestL5Report(input) {
+    const resultPath = path.join(input.runDir, "contracts", "frontend-test-result.json");
+    const result = frontendTestResultContractSchema.parse(JSON.parse(await readFile(resultPath, "utf8")));
+    const metrics = computeFrontendL5ReportMetrics(result);
+    const outputDir = path.join(input.workspaceRoot, "testcase", "frontend", "reports");
+    const markdownPath = path.join(outputDir, "frontend-test-l5-dashboard.md");
+    const htmlPath = path.join(outputDir, "frontend-test-l5-dashboard.html");
+    await writePairAtomic(markdownPath, renderMarkdown(result, metrics), htmlPath, renderHtml(result, metrics));
+    return { metrics, markdownPath, htmlPath };
+}