@tea-agent/loop-agent 0.39.0-next.24 → 0.39.0-next.26

package/dist/workflows/dag/backend-test-scenario-partitions.js

@@ -35,6 +35,8 @@ export const scenarioPartitionRowSchema = z.object({
 const PARTITION_HEADING = /^##\s+Scenario Partitions\s*$/;
 const PARTITION_TABLE_HEADER = /^\|\s*Partition ID\s*\|\s*Operation\s*\|\s*Axis\s*\|\s*Domain\s*\|\s*Required Slots\s*\|\s*Expected by Slot\s*\|\s*Bind Rule\s*\|\s*$/;
 const TABLE_ROW = /^\|(.+)\|$/;
+const FINITE_DOMAIN_MEMBER = /^[A-Za-z0-9]+(?:[._\- ][A-Za-z0-9]+)*$/;
+const RESERVED_SLOT_TOKENS = new Set(["OMITTED", "NOT-IN-SET"]);
 function splitCells(raw) {
     return raw
         .split("|")
@@ -100,6 +102,11 @@ export function parseScenarioPartitions(readmeMarkdown) {
             continue;
         }
         seen.add(partitionId);
+        const domainIssue = describeInvalidPartitionDomain(domain);
+        if (domainIssue) {
+            issues.push(`INVALID_PARTITION_DOMAIN: partition ${partitionId} ${domainIssue}`);
+            continue;
+        }
         partitions.push({
             partitionId,
             operation,
@@ -119,6 +126,40 @@ function slotToken(value) {
         .replace(/[^A-Z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
+function describeInvalidPartitionDomain(domain) {
+    const tokens = [];
+    const seenTokens = new Set();
+    for (const value of domain) {
+        if (!FINITE_DOMAIN_MEMBER.test(value)) {
+            return `value is not a finite identifier member: ${value}`;
+        }
+        const token = slotToken(value);
+        if (!token) {
+            return `value cannot produce a stable non-empty slot token: ${value}`;
+        }
+        if (RESERVED_SLOT_TOKENS.has(token)) {
+            return `value maps to reserved slot token ${token}: ${value}`;
+        }
+        if (seenTokens.has(token)) {
+            return `values collapse to duplicate slot token ${token}`;
+        }
+        seenTokens.add(token);
+        tokens.push(token);
+    }
+    return tokens.length === 0 ? "domain produced no slot tokens" : undefined;
+}
+function normalizePartitionAxisName(value) {
+    return value.trim().replace(/^(?:query|path)\s*:\s*/i, "").toLowerCase();
+}
+function normalizePartitionOperation(value) {
+    return value.trim().replace(/\s+/g, " ").toUpperCase();
+}
+function sameFiniteSet(left, right) {
+    if (left.length !== right.length)
+        return false;
+    const expected = new Set(left);
+    return right.every((value) => expected.has(value));
+}
 const STABLE_PARTITION_ID = /^SP-[A-Z0-9][A-Z0-9._-]*$/i;
 /**
  * Slot IDs are `TP-<Partition ID>-<VALUE|OMITTED|NOT-IN-SET>`.
@@ -138,13 +179,16 @@ function partitionToken(row) {
 export function expandScenarioPartitions(partitions) {
     const slots = [];
     for (const row of partitions) {
+        if (describeInvalidPartitionDomain(row.domain))
+            continue;
         const prefix = partitionToken(row);
         for (const value of row.domain) {
+            const token = slotToken(value);
             slots.push({
                 partitionId: row.partitionId,
                 operation: row.operation,
                 axis: row.axis,
-                slotId: `${prefix}-${slotToken(value)}`,
+                slotId: `${prefix}-${token}`,
                 kind: "each-value",
                 value,
                 intent: "nominal-filter",
@@ -176,6 +220,34 @@ export function expandScenarioPartitions(partitions) {
     }
     return slots;
 }
+/**
+ * Bind parsed partitions to GET query/path OpenAPI axes.
+ * Unconfirmed axes keep identifier-valid Domain rows (requirement finite sets).
+ */
+export function applyOpenApiPartitionDomainPolicy(partitions, axes) {
+    const issues = [];
+    const valid = [];
+    for (const row of partitions) {
+        const operation = normalizePartitionOperation(row.operation);
+        const axisName = normalizePartitionAxisName(row.axis);
+        const matched = axes.find((axis) => normalizePartitionOperation(axis.operation) === operation &&
+            normalizePartitionAxisName(axis.name) === axisName);
+        if (!matched) {
+            valid.push(row);
+            continue;
+        }
+        if (matched.enumValues === null) {
+            issues.push(`NO_FINITE_DOMAIN: partition ${row.partitionId} axis ${row.axis} exists on ${row.operation} without a documented enum`);
+            continue;
+        }
+        if (!sameFiniteSet(matched.enumValues, row.domain)) {
+            issues.push(`PARTITION_SOURCE_MISMATCH: partition ${row.partitionId} domain does not match OpenAPI enum for ${row.operation} ${row.axis}`);
+            continue;
+        }
+        valid.push(row);
+    }
+    return { partitions: valid, issues };
+}
 /** Facts projection consumed by N6 and plan D gap-fill. */
 export const scenarioPartitionFactsSchema = z.object({
     partitions: z.array(z.object({

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

@@ -1,25 +1,17 @@
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { markdownSection } from "./frontend-test-markdown.js";
 const CASE_ID = /^FE-[A-Za-z0-9]+-\d{3}-(?:core|boundary|flow|backend)$/i;
 const AC_ID = /^AC(?:-[A-Z0-9]+)+$/i;
 const PLACEHOLDER = /\b(?:TODO|TBD|FIXME)\b|结果正确|页面正常|按实际情况处理|验证成功/i;
 const SECTION_ALIASES = {
     purpose: ["Test Purpose", "测试目的", "测试场景"],
     source: ["Source References", "需求依据"],
-    preconditions: ["Preconditions", "前置条件"],
-    steps: ["Steps", "操作步骤"],
+    preconditions: ["Preconditions", "前置条件", "前置条件与重置"],
+    steps: ["Test Steps", "测试步骤", "Steps", "操作步骤"],
     expected: ["Expected Results", "预期结果"],
     automation: ["Automation Notes", "自动化映射", "自动化说明"],
 };
-function section(body, names) {
-    const marker = new RegExp(`^###\\s+(?:${names.map((v) => v.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")).join("|")})\\s*$`, "mi");
-    const hit = marker.exec(body);
-    if (!hit)
-        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();
-}
 function hasList(value) { return /^\s*(?:\d+[.)]|[-*+])\s+\S+/m.test(value); }
 function hasAssertion(value) { return /(?:status|状态|包含|显示|等于|为|可见|不可见|跳转|错误|成功|失败|should|expect|assert|must)/i.test(value); }
 export async function validateFrontendCaseContent(input) {
@@ -69,9 +61,9 @@ export async function validateFrontendCaseContent(input) {
         if (PLACEHOLDER.test(body))
             findings.push({ ruleId: "placeholder-wording", caseId: id, detail: "case contains placeholder or non-assertable wording" });
         for (const [key, names] of Object.entries(SECTION_ALIASES))
-            if (!section(body, names))
+            if (!markdownSection(body, names))
                 findings.push({ ruleId: `missing-${key}`, caseId: id, detail: `missing section: ${names.join(" or ")}` });
-        const steps = section(body, SECTION_ALIASES.steps), expected = section(body, SECTION_ALIASES.expected);
+        const steps = markdownSection(body, SECTION_ALIASES.steps), expected = markdownSection(body, SECTION_ALIASES.expected);
         if (!hasList(steps))
             findings.push({ ruleId: "unstructured-steps", caseId: id, detail: "steps should contain numbered or bulleted executable actions" });
         if (!hasList(expected) || !hasAssertion(expected))

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,6 +5,7 @@ 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";
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
     !path.win32.isAbsolute(value) &&
@@ -220,34 +221,25 @@ async function loadCaseBrowserReceiptSummary(input) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
-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)
-        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();
-}
-function markdownList(value) {
-    const items = value.split(/\r?\n/).map((line) => line.replace(/^\s*(?:\d+[.)]|[-*+])\s+/, "").trim()).filter(Boolean);
-    return items;
-}
 /**
  * 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", "预期结果"])),
         },

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

package/dist/workflows/dag/init-hybrid.js

@@ -4389,7 +4389,7 @@ async function buildBackendTestHybridDag(sources) {
             "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
             "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
             "Mandatory module index: include a `## Module Index` table in README that lists every planned module as a canonical relative link of the exact form `[label](./<stem>.md)` plus a `testcase/md/<stem>.md` path cell, so a downstream deterministic manifest can parse the module list. Group by stable business resource/domain, not by CRUD operation: one resource's list/detail/create/update/delete cases belong in one module such as `resource_notes`; split only when a single module would exceed the per-child 16K output protocol, keep the total module count at the smallest safe value, and never exceed 8 modules. Name each module file with a stable lowercase business stem such as `health` or `resource_notes`. Pure hexadecimal/hash-like opaque stems such as `a401606` or `deadbeef` are forbidden. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix and never defines module files. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. The relative link target MUST equal the on-disk filename stem the sharded writer will create. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
-            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess); Required Slots writes `each-value` plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
+            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess); Required Slots writes `each-value` plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
             "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
             intake.boundedSourceContext,
@@ -4499,7 +4499,7 @@ async function buildBackendTestHybridDag(sources) {
             "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "This is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.",
             "For affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.",
-            "Scenario Partitions synchronization: when README declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Directly add missing slot rows/Cases; never delete a declared partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
+            "Scenario Partitions synchronization: when README declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Directly add missing slot rows/Cases. You may delete an illegal Partition row that has no source-backed finite domain, together with its derived `TP-SP-*` slots/Cases. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
             "Before returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in README or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.",
             "Read only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
@@ -4978,15 +4978,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
-            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package.",
+            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage. Copy docs/templates or harness.json governanceRoot templates (including ai_workspace/loop-agent/templates) when present; otherwise write the minimal STD-FE-SMOKE-ENTRY fallback.",
+            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package from docs/templates, governanceRoot/templates, or the init-projected ai_workspace/loop-agent/templates path.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify("const fs=require('fs'),path=require('path');const dest='testcase/frontend/rag/standard-scenarios.v1.json';const candidates=[path.join('docs','templates','frontend-test-standard-scenarios.v1.json')];let src=null;for(const c of candidates){if(fs.existsSync(c)){src=c;break;}}fs.mkdirSync(path.dirname(dest),{recursive:true});if(src){fs.copyFileSync(src,dest);process.stdout.write(JSON.stringify({status:'copied',from:src,to:dest}));}else{const minimal={schemaVersion:1,id:'frontend-test-standard-scenarios-v1',scenarios:[{id:'STD-FE-SMOKE-ENTRY',title:'入口可打开',category:'smoke',priority:'must',testPoints:['open'],minCases:1}]};fs.writeFileSync(dest,JSON.stringify(minimal,null,2)+'\n');process.stdout.write(JSON.stringify({status:'fallback',to:dest}));}"),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestStandardScenarios: {},
                 cwd: ".",
                 timeoutMs: 60_000,
             },
@@ -5022,15 +5018,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
-            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
+            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable with errorClass (connection-refused / dns-unresolved / connect-timeout / http-N / curl-exit-N). Node ERROR so generate/map do not run. Does not start the app.",
+            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. Connection refused (curl 7) records errorClass=connection-refused and tells the operator to start the local app (scripts/serve.sh or npm start) then rerun from this node. 4xx/5xx/DNS/timeout/TLS => blockedReason frontend-base-url-unreachable with a distinct errorClass. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify(`const fs=require('fs');const {spawnSync}=require('child_process');const p='testcase/frontend/rag/context.md';const probePath='testcase/frontend/rag/environment-probe.json';function writeProbe(obj){try{fs.mkdirSync('testcase/frontend/rag',{recursive:true});fs.writeFileSync(probePath,JSON.stringify(obj,null,2)+'\\n');let ctx=fs.existsSync(p)?fs.readFileSync(p,'utf8'):'';const line='environmentProbe: '+obj.status+(obj.blockedReason?(' ('+obj.blockedReason+')'):'');if(/environmentProbe\\s*[:=]/i.test(ctx)){ctx=ctx.replace(/environmentProbe\\s*[:=]\\s*.*/i,line);}else{ctx=ctx.trimEnd()+'\\n\\n'+line+'\\n';}fs.writeFileSync(p,ctx);}catch(e){console.error('probe-write-failed',e&&e.message||e);}}function redactUrl(u){try{const x=new URL(u);x.username='';x.password='';if(x.search){x.search='';}return x.toString();}catch(_){return String(u).replace(/\\/\\/[^@\\s]+@/g,'//');}}function failBlocked(reason,extra){const payload=Object.assign({status:'unreachable',blockedReason:reason,baseUrlRedacted:extra&&extra.baseUrlRedacted||null,httpStatus:extra&&extra.httpStatus||null,method:extra&&extra.method||null,curlExit:extra&&extra.curlExit||null,errorClass:extra&&extra.errorClass||null},extra||{});writeProbe(payload);console.error('frontend-test preflight blocked: '+JSON.stringify({blockedReason:reason,baseUrl:payload.baseUrlRedacted,httpStatus:payload.httpStatus,errorClass:payload.errorClass}));throw new Error('frontend-test preflight blocked: '+reason);}if(!fs.existsSync(p))throw new Error('missing '+p);const s=fs.readFileSync(p,'utf8');const patterns=[/baseUrl\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/base[-_ ]url\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/playwright-cli open --browser=chrome\\s+((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/(https?:\\/\\/(?:localhost|127\\.0\\.0\\.1)[^\\s)\\}\\],"']*)/i];let baseUrl=null;for(const re of patterns){const m=s.match(re);if(m){baseUrl=m[1];break;}}if(!baseUrl)throw new Error('frontend-test preflight missing absolute baseUrl from context.md');baseUrl=baseUrl.replace(/[)\\}\\],."'\\x60]+$/,'');const sourceMatch=s.match(/baseUrlSource\\s*[:=]\\s*([^\\r\\n]+)/i);const baseUrlSource=sourceMatch?sourceMatch[1].trim():'context.md';let parsed;try{parsed=new URL(baseUrl);}catch(_){throw new Error('baseUrl must be absolute http(s): '+baseUrl);}if((parsed.protocol!=='http:'&&parsed.protocol!=='https:')||parsed.username||parsed.password||parsed.search||parsed.hash)throw new Error('unsafe baseUrl from context.md: '+redactUrl(baseUrl));if(/(?:^|\\.)(?:www\\.)?[^.]*(?:prod|production)/i.test(parsed.hostname))throw new Error('production URL forbidden: '+redactUrl(baseUrl));baseUrl=parsed.toString();const safe=redactUrl(baseUrl);const curlCheck=spawnSync('curl',['--version'],{encoding:'utf8'});if(curlCheck.error||curlCheck.status!==0){failBlocked('curl-unavailable',{baseUrlRedacted:safe,errorClass:'curl-missing'});}function probe(method){const args=['-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];const r=spawnSync('curl',args,{encoding:'utf8'});return r;}let used='HEAD';let r=probe('HEAD');let code=String(r.stdout||'').trim();let statusNum=parseInt(code,10);const headRejected=r.status!==0||!statusNum||statusNum===405||statusNum===501;if(headRejected){used='GET';r=probe('GET');code=String(r.stdout||'').trim();statusNum=parseInt(code,10);}const ok=statusNum>=200&&statusNum<400;if(!ok){const errClass=r.error?'spawn-error':(r.status!==0?'curl-exit-'+r.status:('http-'+statusNum));failBlocked('frontend-base-url-unreachable',{baseUrlRedacted:safe,httpStatus:statusNum||null,method:used,curlExit:r.status,errorClass:errClass});}writeProbe({status:'reachable',blockedReason:null,baseUrl:safe,baseUrlRedacted:safe,baseUrlSource,httpStatus:statusNum,method:used,curlExit:r.status});console.log('frontend-test-execution-v1 validated contextBaseUrl='+safe+' source='+baseUrlSource+' probe=reachable method='+used+' httpStatus='+statusNum);`),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestEnvironmentProbe: {},
                 cwd: ".",
                 timeoutMs: 60000,
             },