@tea-agent/loop-agent 0.25.4 → 0.25.6

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-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 };
+}