@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.31

package/dist/workflows/dag/frontend-test-environment-probe.js

@@ -0,0 +1,227 @@
+import { spawnSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const FRONTEND_TEST_CONTEXT_REL = "testcase/frontend/rag/context.md";
+export const FRONTEND_TEST_PROBE_REL = "testcase/frontend/rag/environment-probe.json";
+const CONNECTION_REFUSED_HINT = "被测服务未在 baseUrl 监听（connection refused）。请先启动本地前端（例如 scripts/serve.sh 或项目约定的 npm start），确认可访问后再从 materialize-frontend-test-execution-shell 续跑。";
+export function classifyFrontendBaseUrlProbeFailure(input) {
+    if (input.spawnError)
+        return { errorClass: "spawn-error" };
+    const exit = input.curlExit ?? 0;
+    if (exit === 7) {
+        return { errorClass: "connection-refused", hint: CONNECTION_REFUSED_HINT };
+    }
+    if (exit === 6) {
+        return {
+            errorClass: "dns-unresolved",
+            hint: "无法解析 baseUrl 主机名。确认 context.md 中的地址可在本机解析，或改用 127.0.0.1。",
+        };
+    }
+    if (exit === 28) {
+        return {
+            errorClass: "connect-timeout",
+            hint: "连接 baseUrl 超时。确认被测服务已启动且端口可访问。",
+        };
+    }
+    if (exit !== 0)
+        return { errorClass: `curl-exit-${exit}` };
+    if (input.httpStatus && Number.isFinite(input.httpStatus)) {
+        return { errorClass: `http-${input.httpStatus}` };
+    }
+    return { errorClass: "unreachable" };
+}
+function defaultCurlRunner(args) {
+    const result = spawnSync("curl", [...args], { encoding: "utf8" });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        error: result.error,
+    };
+}
+function redactUrl(value) {
+    try {
+        const parsed = new URL(value);
+        parsed.username = "";
+        parsed.password = "";
+        parsed.search = "";
+        return parsed.toString();
+    }
+    catch {
+        return value.replace(/\/\/[^@\s]+@/g, "//");
+    }
+}
+function resolveBaseUrl(context) {
+    const patterns = [
+        /baseUrl\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /base[-_ ]url\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i,
+        /playwright-cli open --browser=chrome\s+((?:https?):\/\/[^\s"'`<>]+)/i,
+        /(https?:\/\/(?:localhost|127\.0\.0\.1)[^\s)}\],"']*)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = context.match(pattern);
+        if (match?.[1])
+            return match[1].replace(/[)}\],"'.`]+$/g, "");
+    }
+    return null;
+}
+async function writeProbe(workspaceRoot, probe) {
+    const probePath = path.join(workspaceRoot, FRONTEND_TEST_PROBE_REL);
+    const contextPath = path.join(workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+    await mkdir(path.dirname(probePath), { recursive: true });
+    await writeFile(probePath, `${JSON.stringify(probe, null, 2)}\n`, "utf8");
+    let context = "";
+    try {
+        context = await readFile(contextPath, "utf8");
+    }
+    catch {
+        context = "";
+    }
+    const line = `environmentProbe: ${probe.status}${probe.blockedReason ? ` (${probe.blockedReason})` : ""}`;
+    const next = /environmentProbe\s*[:=]/i.test(context)
+        ? context.replace(/environmentProbe\s*[:=]\s*.*/i, line)
+        : `${context.trimEnd()}\n\n${line}\n`;
+    await writeFile(contextPath, next, "utf8");
+}
+export async function probeFrontendTestEnvironment(input) {
+    const curl = input.curl ?? defaultCurlRunner;
+    const contextPath = path.join(input.workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+    let context;
+    try {
+        context = await readFile(contextPath, "utf8");
+    }
+    catch {
+        return { ok: false, stderr: `missing ${FRONTEND_TEST_CONTEXT_REL}` };
+    }
+    const rawUrl = resolveBaseUrl(context);
+    if (!rawUrl) {
+        return {
+            ok: false,
+            stderr: "frontend-test preflight missing absolute baseUrl from context.md",
+        };
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return { ok: false, stderr: `baseUrl must be absolute http(s): ${rawUrl}` };
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash) {
+        return {
+            ok: false,
+            stderr: `unsafe baseUrl from context.md: ${redactUrl(rawUrl)}`,
+        };
+    }
+    if (/(?:^|\.)(?:www\.)?[^.]*?(?:prod|production)/i.test(parsed.hostname)) {
+        return {
+            ok: false,
+            stderr: `production URL forbidden: ${redactUrl(rawUrl)}`,
+        };
+    }
+    const baseUrl = parsed.toString();
+    const safe = redactUrl(baseUrl);
+    const sourceMatch = context.match(/baseUrlSource\s*[:=]\s*([^\r\n]+)/i);
+    const baseUrlSource = sourceMatch ? sourceMatch[1].trim() : "context.md";
+    const failBlocked = async (reason, extra) => {
+        const probe = {
+            status: "unreachable",
+            blockedReason: reason,
+            baseUrlRedacted: extra.baseUrlRedacted ?? safe,
+            httpStatus: extra.httpStatus ?? null,
+            method: extra.method ?? null,
+            curlExit: extra.curlExit ?? null,
+            errorClass: extra.errorClass ?? null,
+            ...(extra.hint ? { hint: extra.hint } : {}),
+            ...(extra.baseUrlSource ? { baseUrlSource: extra.baseUrlSource } : {}),
+        };
+        await writeProbe(input.workspaceRoot, probe);
+        const payload = {
+            blockedReason: reason,
+            baseUrl: probe.baseUrlRedacted,
+            httpStatus: probe.httpStatus,
+            errorClass: probe.errorClass,
+            ...(probe.hint ? { hint: probe.hint } : {}),
+        };
+        return {
+            ok: false,
+            stderr: `frontend-test preflight blocked: ${JSON.stringify(payload)}`,
+            probe,
+        };
+    };
+    const curlCheck = curl(["--version"]);
+    if (curlCheck.error || curlCheck.status !== 0) {
+        return failBlocked("curl-unavailable", {
+            baseUrlRedacted: safe,
+            errorClass: "curl-missing",
+        });
+    }
+    const probeMethod = (method) => curl([
+        "-sS",
+        "-o",
+        "/dev/null",
+        "-w",
+        "%{http_code}",
+        "--connect-timeout",
+        "3",
+        "--max-time",
+        "8",
+        "-X",
+        method,
+        "-L",
+        "--max-redirs",
+        "3",
+        "--http1.1",
+        "--proto-redir",
+        "=http,https",
+        safe,
+    ]);
+    let used = "HEAD";
+    let result = probeMethod("HEAD");
+    let code = String(result.stdout || "").trim();
+    let statusNum = Number.parseInt(code, 10);
+    const headRejected = result.status !== 0 || !statusNum || statusNum === 405 || statusNum === 501;
+    if (headRejected) {
+        used = "GET";
+        result = probeMethod("GET");
+        code = String(result.stdout || "").trim();
+        statusNum = Number.parseInt(code, 10);
+    }
+    const ok = statusNum >= 200 && statusNum < 400;
+    if (!ok) {
+        const classified = classifyFrontendBaseUrlProbeFailure({
+            spawnError: Boolean(result.error),
+            curlExit: result.status,
+            httpStatus: Number.isFinite(statusNum) ? statusNum : null,
+        });
+        return failBlocked("frontend-base-url-unreachable", {
+            baseUrlRedacted: safe,
+            httpStatus: Number.isFinite(statusNum) ? statusNum : null,
+            method: used,
+            curlExit: result.status,
+            errorClass: classified.errorClass,
+            hint: classified.hint,
+        });
+    }
+    const probe = {
+        status: "reachable",
+        blockedReason: null,
+        baseUrl: safe,
+        baseUrlRedacted: safe,
+        baseUrlSource,
+        httpStatus: statusNum,
+        method: used,
+        curlExit: result.status,
+        errorClass: null,
+    };
+    await writeProbe(input.workspaceRoot, probe);
+    return {
+        ok: true,
+        stdout: `frontend-test-execution-v1 validated contextBaseUrl=${safe} source=${baseUrlSource} probe=reachable method=${used} httpStatus=${statusNum}`,
+        probe,
+    };
+}

package/dist/workflows/dag/frontend-test-markdown.js

@@ -0,0 +1,61 @@
+/**
+ * Bounded ATX section/list parsing for frontend-test case Markdown.
+ * Generator cases use `##` headings; older fixtures use `###`.
+ */
+const ATX_HEADING = /^(#{1,3})\s+(\S.*)$/;
+function headingMatches(title, names) {
+    const normalized = title.trim();
+    return names.some((name) => {
+        if (normalized === name)
+            return true;
+        return (normalized.startsWith(name) &&
+            (normalized.length === name.length ||
+                /[\s:：与(（-]/.test(normalized.charAt(name.length))));
+    });
+}
+export function markdownSection(body, names) {
+    const lines = body.replace(/\r\n/g, "\n").split("\n");
+    let start = -1;
+    let startLevel = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const match = ATX_HEADING.exec(lines[index]);
+        if (!match)
+            continue;
+        if (!headingMatches(match[2], names))
+            continue;
+        start = index;
+        startLevel = match[1].length;
+        break;
+    }
+    if (start < 0)
+        return "";
+    const collected = [];
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const match = ATX_HEADING.exec(lines[index]);
+        if (match && match[1].length <= startLevel)
+            break;
+        collected.push(lines[index]);
+    }
+    return collected.join("\n").trim();
+}
+export function markdownList(value) {
+    const items = [];
+    for (const raw of value.replace(/\r\n/g, "\n").split("\n")) {
+        const listed = raw.match(/^\s*(?:\d+[.)]|[-*+])\s+(.*)$/);
+        if (listed) {
+            const text = listed[1].trim();
+            if (text)
+                items.push(text);
+            continue;
+        }
+        const continuation = raw.match(/^\s{2,}(\S.*)$/);
+        if (continuation && items.length > 0) {
+            items[items.length - 1] = `${items[items.length - 1]} ${continuation[1].trim()}`;
+        }
+    }
+    return items;
+}
+export function markdownH1Title(body) {
+    const match = /^#\s+(\S.*)$/m.exec(body.replace(/\r\n/g, "\n"));
+    return match?.[1]?.trim() ?? "";
+}

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

@@ -5,7 +5,27 @@ import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { readPlaywrightCliReceipts, summarizePlaywrightCliReceipts, } from "../../executors/pi-playwright-cli-tool.js";
 import { validateFrontendCaseContent } from "./frontend-test-case-quality.js";
+import { markdownH1Title, markdownList, markdownSection, } from "./frontend-test-markdown.js";
 export const FRONTEND_TEST_RESULT_SCHEMA_ID = "frontend-test-result-v1";
+/**
+ * Truncated acceptance-id shapes observed in generator output: a bare
+ * numeric segment ("AC-002" dropped its AC-FE-<FEATURE> prefix) or an
+ * AC-FE-<FEATURE> literal without the trailing -NNN sequence number
+ * ("AC-FE-CHAT"). Generic short ids like "AC-1"/"AC-FE-001" stay valid;
+ * declared-source cross-checks (unknown-ac) remain the primary guard when a
+ * sourceBinding exists.
+ */
+export function isTruncatedFrontendAcId(acId) {
+    return /^AC-FE-[A-Z]+$/i.test(acId.trim());
+}
+/**
+ * Bare numeric ids ("AC-002") only indicate truncation when no declared AC
+ * list exists to adjudicate them: with a sourceBinding they are ordinary
+ * unknown-ac findings ("AC-999" may be a legitimately declared id style).
+ */
+export function isTruncatedWhenUndeclaredFrontendAcId(acId) {
+    return /^AC-\d{3}$/i.test(acId.trim()) || isTruncatedFrontendAcId(acId);
+}
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
     !path.win32.isAbsolute(value) &&
     !value.includes("\\") &&
@@ -56,6 +76,8 @@ export const frontendTestResultContractSchema = z.object({
         passed: z.number().int().min(0),
         failed: z.number().int().min(0),
         blocked: z.number().int().min(0),
+        /** Stability metric: passed on attempt 0 (no rerun/self-heal retry). */
+        firstTryPassed: z.number().int().min(0).optional(),
     }).strict(),
     acceptanceCoverage: z.object({
         covered: z.array(z.string().min(1)),
@@ -109,7 +131,13 @@ export async function validateFrontendCaseEvidence(input) {
     catch {
         throw new Error("missing testcase/frontend/cases/manifest.json");
     }
-    const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error("invalid frontend case manifest: malformed JSON");
+    }
     if (!Array.isArray(manifest.cases))
         throw new Error("invalid frontend case manifest");
     const statuses = new Set(["passed", "failed", "blocked"]);
@@ -194,11 +222,17 @@ export function evaluatePassedCaseBrowserReceipts(summary, caseId) {
     }
     return { ok: true };
 }
-async function loadCaseBrowserReceiptSummary(input) {
+async function loadCaseBrowserReceiptsWithSummary(input) {
     try {
         const entries = await readdir(input.runDir, { withFileTypes: true });
         // A passed chain must belong to exactly one browser child stream. Never
-        // stitch receipts across DAG nodes or accept ambiguous duplicate authority.
+        // stitch receipts across DAG nodes or accept ambiguous duplicate
+        // authority — with one exception: bounded rerun creates a second,
+        // later stream for the same case (the rerun overwrites the disk
+        // case-result, so the final attempt is the authoritative one). When
+        // multiple streams authorize, prefer the highest rerun round
+        // (rerun-frontend-case-rN-<idx> directories); ties within the same
+        // round remain ambiguous and fail closed.
         const authorizingStreams = [];
         for (const entry of entries) {
             if (!entry.isDirectory())
@@ -206,48 +240,121 @@ async function loadCaseBrowserReceiptSummary(input) {
             const nodeReceipts = (await readPlaywrightCliReceipts(input.runDir, entry.name))
                 .filter((item) => item.caseId === input.caseId);
             const summary = summarizePlaywrightCliReceipts(nodeReceipts);
-            if (summary.hasOrderedPassedReceiptChain)
-                authorizingStreams.push(summary);
+            if (summary.hasOrderedPassedReceiptChain) {
+                const roundMatch = /rerun-frontend-case-r(\d+)-/i.exec(entry.name);
+                authorizingStreams.push({
+                    receipts: nodeReceipts,
+                    summary,
+                    round: roundMatch ? Number(roundMatch[1]) : 0,
+                });
+            }
+        }
+        if (authorizingStreams.length === 0) {
+            return { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
         }
-        return authorizingStreams.length === 1
-            ? authorizingStreams[0]
-            : summarizePlaywrightCliReceipts([]);
+        const maxRound = Math.max(...authorizingStreams.map((s) => s.round));
+        const finalists = authorizingStreams.filter((s) => s.round === maxRound);
+        return finalists.length === 1
+            ? finalists[0]
+            : { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
     }
     catch {
-        return summarizePlaywrightCliReceipts([]);
+        return { receipts: [], summary: summarizePlaywrightCliReceipts([]) };
     }
 }
-function sha256(content) {
-    return createHash("sha256").update(content).digest("hex");
+/**
+ * Extract `find "literal" >=N` / `find "literal"` declarations from a case
+ * document. Only quoted literals are binding assertions — the count suffix
+ * (`>=N`, `==N`) is the expected minimum/exact match count from the ledger.
+ * Placeholder literals ("...", "…", "<字面>", "eX") appear in prose discussing
+ * the syntax itself; they are documentation, never declarations.
+ */
+export function extractDeclaredFindAssertions(caseMarkdown) {
+    const source = stripFencedCodeBlocks(caseMarkdown);
+    const out = [];
+    const seen = new Set();
+    const pattern = /find\s+"((?:[^"\\]|\\.)+)"\s*(>=|==)\s*(\d+)/g;
+    const isPlaceholder = (literal) => /^(?:\.{2,}|…+|<[^>]*>|e\d+)$/.test(literal.trim());
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        const literal = match[1].replace(/\\(.)/g, "$1");
+        if (isPlaceholder(literal))
+            continue;
+        const operator = match[2];
+        const expected = Number(match[3]);
+        const key = `${operator}:${literal}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ literal, expected, operator });
+    }
+    return out;
 }
-function markdownSection(body, names) {
-    const escaped = names.map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-    const marker = new RegExp(`^###\\s+(?:${escaped})\\s*$`, "mi");
-    const hit = marker.exec(body);
-    if (!hit)
+function stripFencedCodeBlocks(markdown) {
+    return markdown.replace(/```[\s\S]*?```/g, "");
+}
+async function readCaseMarkdownForAudit(workspaceRoot, casePath) {
+    try {
+        return await readFile(path.join(workspaceRoot, casePath), "utf8");
+    }
+    catch {
         return "";
-    const rest = body.slice(hit.index + hit[0].length);
-    const next = /^###\s+/m.exec(rest);
-    return rest.slice(0, next?.index ?? rest.length).trim();
+    }
+}
+/**
+ * Controller-side assertion audit: every find-family declaration in the case
+ * document must be backed by a successful find receipt whose parsed match
+ * count satisfies the declared operator. This moves pass authority from
+ * "the model says it asserted" to "receipts prove it asserted".
+ */
+export function auditDeclaredFindAssertions(declared, receipts) {
+    if (declared.length === 0)
+        return { ok: true };
+    const successfulFinds = receipts.filter((receipt) => (receipt.command === "find" || receipt.command === "find-unique") &&
+        receipt.exitCode === 0 &&
+        !receipt.timedOut);
+    const missing = [];
+    for (const decl of declared) {
+        const backing = successfulFinds.some((receipt) => receipt.argsRedacted.some((arg) => arg === decl.literal || arg === `"${decl.literal}"`) &&
+            typeof receipt.matchCount === "number" &&
+            (decl.operator === ">="
+                ? receipt.matchCount >= decl.expected
+                : receipt.matchCount === decl.expected));
+        if (!backing) {
+            missing.push(`${decl.operator}${decl.expected} "${decl.literal.slice(0, 40)}"`);
+        }
+    }
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            reason: "assertion-not-receipt-backed",
+            missing,
+        };
+    }
+    return { ok: true };
 }
-function markdownList(value) {
-    const items = value.split(/\r?\n/).map((line) => line.replace(/^\s*(?:\d+[.)]|[-*+])\s+/, "").trim()).filter(Boolean);
-    return items;
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
 }
 /**
  * Read planned case facts from the case Markdown. Recognizes both English and
- * Chinese headings, including `测试点` (test points) and `测试步骤` (planned
- * test steps), alongside the legacy `操作步骤`/`Steps` headings.
+ * Chinese headings at `##` or `###`, including `测试点` (test points) and
+ * `测试步骤` (planned test steps), alongside the legacy `操作步骤`/`Steps`
+ * headings. Numbered and bulleted lists are extracted; a missing 测试目的
+ * falls back to the case H1 title.
  */
 async function readFrontendCaseContent(workspaceRoot, casePath) {
     if (!safeRelativePathSchema.safeParse(casePath).success || !casePath.startsWith("testcase/frontend/cases/")) {
         throw new Error(`unsafe frontend case path: ${casePath}`);
     }
     const body = await readFile(path.resolve(workspaceRoot, casePath), "utf8");
+    const purpose = markdownSection(body, ["Test Purpose", "测试目的", "测试场景"]) ||
+        markdownH1Title(body).replace(/^FE-[^\s：:]+[：:]\s*/, "").trim() ||
+        "未提供测试目的";
     return {
         caseContent: {
-            purpose: markdownSection(body, ["Test Purpose", "测试目的", "测试场景"]) || "未提供测试目的",
-            preconditions: markdownList(markdownSection(body, ["Preconditions", "前置条件"])),
+            purpose,
+            preconditions: markdownList(markdownSection(body, ["Preconditions", "前置条件", "前置条件与重置"])),
             steps: markdownList(markdownSection(body, ["Test Steps", "测试步骤", "Steps", "操作步骤"])),
             expectedResults: markdownList(markdownSection(body, ["Expected Results", "预期结果"])),
         },
@@ -332,7 +439,13 @@ export async function materializeFrontendTestResult(input) {
     }
     const manifestPath = "testcase/frontend/cases/manifest.json";
     const manifestAbsolute = path.resolve(input.workspaceRoot, manifestPath);
-    const manifest = JSON.parse(await readFile(manifestAbsolute, "utf-8"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestAbsolute, "utf-8"));
+    }
+    catch {
+        throw new Error("invalid or empty frontend case manifest: malformed JSON");
+    }
     if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.cases) || manifest.cases.length === 0) {
         throw new Error("invalid or empty frontend case manifest");
     }
@@ -395,7 +508,7 @@ export async function materializeFrontendTestResult(input) {
             advisoryFindings.push({ ruleId: "passed-without-browser-evidence", caseId: item.caseId, detail: "passed case has no browser evidence" });
         let blockedReason = status === "blocked" && typeof resultRaw.blockedReason === "string" && resultRaw.blockedReason.trim() ? resultRaw.blockedReason.trim() : undefined;
         if (status === "passed") {
-            const receiptSummary = await loadCaseBrowserReceiptSummary({
+            const { receipts: caseReceipts, summary: receiptSummary } = await loadCaseBrowserReceiptsWithSummary({
                 runDir: input.runDir,
                 caseId: item.caseId,
             });
@@ -409,6 +522,24 @@ export async function materializeFrontendTestResult(input) {
                     detail: "passed case lacks controller-owned open + interaction/assertion + cleanup receipts",
                 });
             }
+            else {
+                // Controller-side assertion audit: every `find "literal" >=N` declared
+                // in the case document must be backed by a successful find receipt
+                // whose parsed matchCount satisfies the operator. Pass authority moves
+                // from model prose to receipt evidence.
+                const caseMarkdown = await readCaseMarkdownForAudit(input.workspaceRoot, item.casePath);
+                const declared = extractDeclaredFindAssertions(caseMarkdown);
+                const audit = auditDeclaredFindAssertions(declared, caseReceipts);
+                if (!audit.ok) {
+                    status = "blocked";
+                    blockedReason = audit.reason;
+                    advisoryFindings.push({
+                        ruleId: "assertion-not-receipt-backed",
+                        caseId: item.caseId,
+                        detail: `declared find assertions without receipt backing: ${audit.missing.join("; ")}`,
+                    });
+                }
+            }
         }
         const { caseContent, testPoints } = await readFrontendCaseContent(input.workspaceRoot, item.casePath);
         // Parse bounded fixed sections from execution.md. Missing optional
@@ -459,6 +590,7 @@ export async function materializeFrontendTestResult(input) {
         passed: cases.filter((item) => item.status === "passed").length,
         failed: cases.filter((item) => item.status === "failed").length,
         blocked: cases.filter((item) => item.status === "blocked").length,
+        firstTryPassed: cases.filter((item) => item.status === "passed" && !item.rerunAttempt).length,
     };
     const outcome = totals.failed > 0 ? "failed" : totals.blocked > 0 || missing.length > 0 ? "incomplete" : "passed";
     const result = frontendTestResultContractSchema.parse({

package/dist/workflows/dag/frontend-test-standard-scenarios.js

@@ -0,0 +1,68 @@
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+export const FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME = "frontend-test-standard-scenarios.v1.json";
+export const FRONTEND_TEST_STANDARD_SCENARIOS_DEST = "testcase/frontend/rag/standard-scenarios.v1.json";
+const MINIMAL_STANDARD_SCENARIOS = {
+    schemaVersion: 1,
+    id: "frontend-test-standard-scenarios-v1",
+    scenarios: [
+        {
+            id: "STD-FE-SMOKE-ENTRY",
+            title: "入口可打开",
+            category: "smoke",
+            priority: "must",
+            testPoints: ["open"],
+            minCases: 1,
+        },
+    ],
+};
+function isSafeRelativeDir(value) {
+    if (!value || path.isAbsolute(value) || path.win32.isAbsolute(value)) {
+        return false;
+    }
+    return value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+export function listFrontendTestStandardScenarioCandidates(input) {
+    const seen = new Set();
+    const add = (relative) => {
+        const normalized = relative.replaceAll("\\", "/");
+        if (!seen.has(normalized))
+            seen.add(normalized);
+    };
+    add(`docs/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    const governanceRoot = input.governanceRoot?.trim().replaceAll("\\", "/").replace(/\/+$/, "");
+    if (governanceRoot && isSafeRelativeDir(governanceRoot)) {
+        add(`${governanceRoot}/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    }
+    add(`ai_workspace/loop-agent/templates/${FRONTEND_TEST_STANDARD_SCENARIOS_FILENAME}`);
+    return [...seen];
+}
+async function readGovernanceRoot(workspaceRoot) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(workspaceRoot, "harness.json"), "utf8"));
+        return typeof raw.governanceRoot === "string" ? raw.governanceRoot : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function copyFrontendTestStandardScenarios(input) {
+    const destRel = FRONTEND_TEST_STANDARD_SCENARIOS_DEST;
+    const destAbs = path.join(input.workspaceRoot, destRel);
+    const candidates = listFrontendTestStandardScenarioCandidates({
+        governanceRoot: await readGovernanceRoot(input.workspaceRoot),
+    });
+    await mkdir(path.dirname(destAbs), { recursive: true });
+    for (const relative of candidates) {
+        const sourceAbs = path.join(input.workspaceRoot, relative);
+        try {
+            await copyFile(sourceAbs, destAbs);
+            return { status: "copied", from: relative, to: destRel };
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    await writeFile(destAbs, `${JSON.stringify(MINIMAL_STANDARD_SCENARIOS, null, 2)}\n`, "utf8");
+    return { status: "fallback", to: destRel };
+}