@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

package/dist/workflows/dag/frontend-risk.js

@@ -2,6 +2,12 @@
  * Deterministic frontend-implementation risk classifier (M4).
  * Pure function: no I/O, no model, no side effects.
  */
+/**
+ * Dependency-installation language in task text. Mentioning package.json or
+ * allowing its path is NOT dependency introduction by itself; the manifest
+ * path check in classifyFrontendRisk requires this language to escalate.
+ */
+const DEPENDENCY_INSTALL_LANGUAGE = /new\s+dependency|add\s+dependencies?|install\s+dependencies?|npm\s+(?:install|i)\b|yarn\s+(?:add|install)\b|pnpm\s+(?:add|install)\b|bun\s+(?:add|install)\b|新增依赖|添加依赖|安装依赖|引入依赖/i;
 const HIGH_RISK_PATTERNS = [
     {
         id: "new-route",
@@ -25,7 +31,7 @@ const HIGH_RISK_PATTERNS = [
     },
     {
         id: "new-dependency",
-        re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖|package\.json/i,
+        re: DEPENDENCY_INSTALL_LANGUAGE,
     },
     {
         id: "schema-api-change",
@@ -88,7 +94,14 @@ export function classifyFrontendRisk(input) {
     const paths = input.allowedPaths ?? [];
     const spread = pathSpreadScore(paths);
     if (paths.some((p) => /package\.json|pnpm-lock|yarn\.lock|package-lock/.test(p))) {
-        signals.push("new-dependency");
+        if (DEPENDENCY_INSTALL_LANGUAGE.test(blob)) {
+            signals.push("new-dependency");
+        }
+        else {
+            // Editing manifest scripts/config is not dependency introduction;
+            // record the rejected escalation instead of forcing full gates.
+            rejectedSignals.push("new-dependency:manifest-path-without-install-language");
+        }
     }
     // Explicit multi-domain language only — path count alone is not high-risk
     if (spread >= 3 &&

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

@@ -1,16 +1,20 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { isPlaywrightCliCommand } from "../../shared/playwright-cli-command-policy.js";
+import { isTruncatedFrontendAcId, isTruncatedWhenUndeclaredFrontendAcId, } from "./frontend-test-result-contract.js";
+import { defaultFrontendTestLayout, frontendTestCasePath, } from "./frontend-test-layout.js";
 const COMMAND_FENCE_LANGUAGE = /^(?:|bash|sh|shell|zsh|fish|console|terminal|command|cmd|powershell|pwsh|javascript|js|typescript|ts|python|py)$/i;
 const LIST_ITEM = /^\s*(?:[-+*]|\d+[.)])\s+(.+)$/;
 const INDENTED_CODE = /^(?: {4,}|\t+)(\S.*)$/;
 const EXPLICIT_COMMAND = /^(?:(?:shell|terminal)(?:\s+command)?|command|run command|execute command)\s*:\s*(.+)$/i;
 const BLOCKED_REASON_PREFIX = /^(?:(?:blocked|forbidden|reject(?:ed)?|disallow(?:ed)?|prohibited)(?:\s+reason)?\s*(?::|\bbecause\b)|(?:do not|must not|never)\s+(?:run|execute|use)\b)/i;
 /** Standalone blockedReason / environment tokens (not executable commands). */
-const BLOCKED_REASON_TOKEN = /^(?:playwright-cli-unavailable|frontend-base-url-unreachable|curl-unavailable|browser-command-capability-unavailable|browser-command-evidence-missing|token-budget-exhausted|current-user-data-unavailable|data-ownership-unverifiable|safe-test-data-setup-unavailable|invalid-evidence-shape)(?:\s|$|[.,;:)`'"\]])/i;
+const BLOCKED_REASON_TOKEN = /^(?:playwright-cli-unavailable|frontend-base-url-unreachable|curl-unavailable|browser-command-capability-unavailable|browser-command-evidence-missing|token-budget-exhausted|current-user-data-unavailable|data-ownership-unverifiable|safe-test-data-setup-unavailable|unique-control-unavailable|invalid-evidence-shape)(?:\s|$|[.,;:)`'"\]])/i;
 const BLOCKED_PROSE_HINT = /(?:blockedReason|blocked\s*reason|environmentProbe|evidenceDir|\bunavailable\b|不可用|写\s*blocked|写入\s*blocked|伪命令|自然语言|元数据|fail-closed|探测失败)/i;
 const IMPERATIVE_COMMAND = /^(?:(?:run|execute|use)(?:\s+(?:the\s+)?(?:(?:shell|terminal)\s+)?command)?|in\s+(?:the\s+)?(?:shell|terminal|console)\s*,?\s*(?:run|execute|use))\s*:?\s+(.+)$/i;
 const INLINE_CODE_STEP = /^`([^`\r\n]+)`[.!?]?$/;
+/** Assertion-count annotations appended to a playwright-cli literal (e.g. `find "锚点">=1`, `>=N`, `≥N`, `（≥1）`) document an expected match count; they are documentation, not shell arguments. */
+const ASSERTION_COUNT_SUFFIX = /\s*[（(]?\s*(?:>=|≥|>|超过|至少)\s*\d+\s*[）)]?\s*$/;
 const AUTOMATION_EXECUTABLE = /^(?:playwright-cli\b|playwright\b|@playwright\/test\b|npx\b|npm\b|pnpm\b|yarn\b|bunx?\b|node(?:js)?\b|python(?:3)?\b|bash\b|sh\b|zsh\b|fish\b|powershell\b|pwsh\b|cmd(?:\.exe)?\b|cypress\b|selenium\b|webdriverio\b|chromedriver\b|google-chrome\b|chrome\b|firefox\b|curl\b|wget\b)/i;
 const SHELL_WRAPPED_EXECUTABLE = /^(?:sudo\s+|env(?:\s+[A-Za-z_][A-Za-z0-9_]*=[^\s]+)*\s+|(?:\.{1,2}[\\/]|~[\\/]|[A-Za-z]:[\\/]|\/)[^\s]+)/i;
 const ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]*)/;
@@ -44,6 +48,11 @@ function isBlockedReason(value) {
         return true;
     if (/^blockedReason\s*[:=]/i.test(trimmed))
         return true;
+    // Expected-outcome field lines ("status=blocked" / "status: failed") document
+    // the intended terminal state of a designed-negative case; they are
+    // case-result metadata, never executable commands.
+    if (/^["'`]?status["'`]?\s*[:=]\s*["'`]?(passed|failed|blocked)["'`]?\s*[.。]?$/i.test(trimmed))
+        return true;
     return false;
 }
 /**
@@ -238,6 +247,12 @@ function commandGateIssue(input) {
     if (input.instruction.fromFence && isBlockedReason(input.instruction.command)) {
         return null;
     }
+    // An expected-match-count annotation (`find "锚点">=1`, with or without a
+    // playwright-cli prefix) documents the assertion; it is not part of the
+    // command and never executable input.
+    if (/^(?:playwright-cli\s+)?find\s+"[^"]*"/i.test(input.instruction.command) && ASSERTION_COUNT_SUFFIX.test(input.instruction.command)) {
+        return null;
+    }
     const commandMatch = input.instruction.command.match(/^playwright-cli\s+([^\s`]+)/i);
     if (commandMatch) {
         const command = commandMatch[1].toLowerCase().replace(/^[`'"]+|[`'":,，。→]+$/g, "");
@@ -276,13 +291,20 @@ function commandGateIssue(input) {
     };
 }
 export async function validateFrontendCaseChecklist(input) {
-    const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
+    const layout = input.layout ?? defaultFrontendTestLayout();
+    const root = path.join(input.workspaceRoot, layout.casesDir);
     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"));
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        throw new Error("checklist: manifest is malformed JSON");
+    }
     if (!Array.isArray(manifest.cases) || manifest.cases.length === 0)
         throw new Error("checklist: empty cases");
     const declaredAc = new Set(input.declaredAcIds ?? []);
@@ -299,7 +321,7 @@ export async function validateFrontendCaseChecklist(input) {
         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 expectedPath = typeof item?.caseId === "string" ? frontendTestCasePath(layout, item.caseId) : "";
         const absolute = path.resolve(input.workspaceRoot, casePath);
         const relative = path.relative(input.workspaceRoot, absolute);
         if (!casePath || relative.startsWith("..") || path.isAbsolute(relative) || !(await exists(absolute))) {
@@ -334,6 +356,10 @@ export async function validateFrontendCaseChecklist(input) {
             for (const ac of item.acIds) {
                 if (typeof ac !== "string" || !acIdRe.test(ac))
                     issues.push({ ruleId: "ac-id-shape", caseId: id, casePath, detail: String(ac) });
+                else if (declaredAc.size > 0 && isTruncatedFrontendAcId(ac))
+                    issues.push({ ruleId: "ac-id-truncated", caseId: id, casePath, detail: `${ac} is a truncated acceptance id (missing feature prefix or sequence number)` });
+                else if (declaredAc.size === 0 && isTruncatedWhenUndeclaredFrontendAcId(ac))
+                    issues.push({ ruleId: "ac-id-truncated", caseId: id, casePath, detail: `${ac} is a truncated acceptance id (missing feature prefix or sequence number)` });
                 else if (declaredAc.size > 0 && !declaredAc.has(ac))
                     issues.push({ ruleId: "unknown-ac", caseId: id, casePath, detail: `${ac} not in sourceBinding` });
             }

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

@@ -1,5 +1,7 @@
 import { readFile, rename, unlink, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { isTruncatedFrontendAcId, isTruncatedWhenUndeclaredFrontendAcId, } from "./frontend-test-result-contract.js";
+import { defaultFrontendTestLayout, frontendTestCasePath, frontendTestEvidenceDir, frontendTestManifestDraftPath, frontendTestManifestPath, } from "./frontend-test-layout.js";
 const DIMENSIONS = new Set(["core", "boundary", "flow", "backend"]);
 function fail(ruleId, detail) {
     const msg = JSON.stringify({ ruleId, detail: String(detail ?? "") });
@@ -18,8 +20,9 @@ function fail(ruleId, detail) {
  * present). When empty, ac-id-shape still applies.
  */
 export async function materializeFrontendTestCaseManifest(input) {
-    const draft = path.join(input.workspaceRoot, "testcase/frontend/cases/manifest.draft.json");
-    const file = path.join(input.workspaceRoot, "testcase/frontend/cases/manifest.json");
+    const layout = input.layout ?? defaultFrontendTestLayout();
+    const draft = path.join(input.workspaceRoot, frontendTestManifestDraftPath(layout));
+    const file = path.join(input.workspaceRoot, frontendTestManifestPath(layout));
     const tmp = `${file}.tmp`;
     const maxCases = input.maxCases ?? 32;
     const declaredAc = new Set(input.declaredAcIds ?? []);
@@ -62,12 +65,16 @@ export async function materializeFrontendTestCaseManifest(input) {
         for (const ac of c.acIds) {
             if (typeof ac !== "string" || !acIdRe.test(ac))
                 fail("ac-id-shape", `acIds entry must be AC-* acceptance id, not caseId: ${ac}`);
+            if ((declaredAc.size > 0
+                ? isTruncatedFrontendAcId(ac)
+                : isTruncatedWhenUndeclaredFrontendAcId(ac)))
+                fail("ac-id-truncated", `acIds entry is a truncated acceptance id (missing feature prefix or sequence number): ${ac}`);
             if (declaredAc.size > 0 && !declaredAc.has(ac))
                 fail("unknown-ac", `${ac} not in sourceBinding; repair generator input or AC list`);
             acIds.push(ac);
         }
-        const casePath = `testcase/frontend/cases/${c.caseId}.md`;
-        const evidenceDir = `testcase/frontend/evidence/${c.caseId}/`;
+        const casePath = frontendTestCasePath(layout, c.caseId);
+        const evidenceDir = frontendTestEvidenceDir(layout, c.caseId);
         for (const [k, v] of [
             ["casePath", casePath],
             ["evidenceDir", evidenceDir],

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

@@ -1,29 +1,23 @@
 import { readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
+import { markdownSection } from "./frontend-test-markdown.js";
+import { defaultFrontendTestLayout, frontendTestCasePath, } from "./frontend-test-layout.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) {
-    const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
+    const layout = input.layout ?? defaultFrontendTestLayout();
+    const root = path.join(input.workspaceRoot, layout.casesDir);
     const manifestPath = path.join(root, "manifest.json");
     const findings = [];
     let manifest;
@@ -57,7 +51,7 @@ export async function validateFrontendCaseContent(input) {
                     findings.push({ ruleId: "unknown-ac", caseId: id, detail: `${ac} is not declared by the task` });
             }
         }
-        const file = path.join(input.workspaceRoot, item?.casePath || `testcase/frontend/cases/${id}.md`);
+        const file = path.join(input.workspaceRoot, item?.casePath || frontendTestCasePath(layout, id));
         let body = "";
         try {
             body = await readFile(file, "utf8");
@@ -69,9 +63,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))
@@ -97,7 +91,8 @@ function render(findings) {
 }
 export async function writeFrontendCaseQualityReports(input) {
     const result = await validateFrontendCaseContent(input);
-    const dir = path.join(input.workspaceRoot, input.outputDir ?? "testcase/frontend/reports");
+    const layout = input.layout ?? defaultFrontendTestLayout();
+    const dir = path.join(input.workspaceRoot, input.outputDir ?? layout.reportsDir);
     await mkdir(dir, { recursive: true });
     await writeFile(path.join(dir, "frontend-test-case-quality-advisory.md"), result.markdown, "utf8");
     await writeFile(path.join(dir, "frontend-test-case-quality-advisory.html"), result.html, "utf8");

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

@@ -0,0 +1,230 @@
+import { spawnSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultFrontendTestLayout, frontendTestContextRel, frontendTestProbeRel, } from "./frontend-test-layout.js";
+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, layout) {
+    const probePath = path.join(workspaceRoot, frontendTestProbeRel(layout));
+    const contextPath = path.join(workspaceRoot, frontendTestContextRel(layout));
+    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 layout = input.layout ?? defaultFrontendTestLayout();
+    const curl = input.curl ?? defaultCurlRunner;
+    const contextRel = frontendTestContextRel(layout);
+    const contextPath = path.join(input.workspaceRoot, contextRel);
+    let context;
+    try {
+        context = await readFile(contextPath, "utf8");
+    }
+    catch {
+        return { ok: false, stderr: `missing ${contextRel}` };
+    }
+    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, layout);
+        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, layout);
+    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-html-report.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { frontendTestResultContractSchema } from "./frontend-test-result-contract.js";
+import { defaultFrontendTestLayout, } from "./frontend-test-layout.js";
 function escapeHtml(value) {
     return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
@@ -80,7 +81,8 @@ async function writePairAtomic(markdownPath, markdown, htmlPath, html) {
 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 layout = input.layout ?? defaultFrontendTestLayout();
+    const outputDir = path.join(input.workspaceRoot, layout.reportsDir);
     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" ? "测试失败" : "测试未完成";

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

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { frontendTestResultContractSchema, } from "./frontend-test-result-contract.js";
+import { defaultFrontendTestLayout, } from "./frontend-test-layout.js";
 function ratioMetric(numerator, denominator, threshold, label) {
     if (denominator === 0) {
         return { numerator, denominator, ratio: null, threshold, status: "unavailable", reason: `${label}-denominator-is-zero` };
@@ -169,7 +170,8 @@ 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 layout = input.layout ?? defaultFrontendTestLayout();
+    const outputDir = path.join(input.workspaceRoot, layout.reportsDir);
     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));

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

@@ -0,0 +1,159 @@
+import path from "node:path";
+/**
+ * Frontend-test artifact layout (configurable testRoot).
+ *
+ * Resolved once from `task.frontendTest.testRoot` at DAG compile time and
+ * frozen on the spec for the whole run. Writers, gates, Playwright fences
+ * and TaskSpec allowedPaths all derive from this single object.
+ *
+ * Default layout keeps the historical frozen contract:
+ *   testcase/frontend/rag/**
+ *   testcase/frontend/cases/**
+ *   testcase/frontend/evidence/**
+ *   testcase/frontend/reports/**
+ *   testcase/frontend/fixtures/**
+ */
+export const FRONTEND_TEST_DEFAULT_TEST_ROOT = "testcase/frontend";
+const FORBIDDEN_TEST_ROOT_PREFIXES = [
+    "src",
+    "app",
+    "lib",
+    "apps",
+    "packages",
+    ".harness",
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    "docs",
+    "website",
+    "scripts",
+    "test",
+    "smoke",
+    "knowledge",
+    "features",
+    "dogfood",
+    "examples",
+    "bin",
+];
+function normalizeRelPosix(value, label) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error(`frontendTest.${label} must not be empty`);
+    if (trimmed.includes("\\")) {
+        throw new Error(`frontendTest.${label} must use forward slashes: ${value}`);
+    }
+    if (path.isAbsolute(trimmed) || /^[A-Za-z]:/.test(trimmed)) {
+        throw new Error(`frontendTest.${label} must be a repository-relative path: ${value}`);
+    }
+    const segments = trimmed.split("/").filter((segment) => segment.length > 0);
+    if (segments.some((segment) => segment === ".." || segment === ".")) {
+        throw new Error(`frontendTest.${label} must not contain "." or ".." segments: ${value}`);
+    }
+    if (segments.some((segment) => segment.startsWith("."))) {
+        throw new Error(`frontendTest.${label} must not target hidden directories: ${value}`);
+    }
+    if (segments.some((segment) => !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(segment))) {
+        throw new Error(`frontendTest.${label} contains unsafe path segments: ${value}`);
+    }
+    return segments.join("/");
+}
+function assertTestRootAllowed(testRoot) {
+    const topSegment = testRoot.split("/")[0];
+    if (FORBIDDEN_TEST_ROOT_PREFIXES.some((forbidden) => topSegment === forbidden || topSegment.startsWith(`${forbidden}.`))) {
+        throw new Error(`frontendTest.testRoot must not target production/governance trees: ${testRoot}`);
+    }
+    if (topSegment.startsWith(".")) {
+        throw new Error(`frontendTest.testRoot must not target hidden directories: ${testRoot}`);
+    }
+}
+/**
+ * Resolve the frozen frontend-test artifact layout from task config.
+ * Throws on unsafe or ambiguous configuration (fail-closed).
+ */
+export function resolveFrontendTestLayout(config) {
+    const testRoot = config?.testRoot === undefined || config?.testRoot === null
+        ? FRONTEND_TEST_DEFAULT_TEST_ROOT
+        : normalizeRelPosix(config.testRoot, "testRoot");
+    assertTestRootAllowed(testRoot);
+    const isDefault = testRoot === FRONTEND_TEST_DEFAULT_TEST_ROOT;
+    return {
+        testRoot,
+        ragDir: `${testRoot}/rag`,
+        casesDir: `${testRoot}/cases`,
+        evidenceDir: `${testRoot}/evidence`,
+        reportsDir: `${testRoot}/reports`,
+        fixturesDir: `${testRoot}/fixtures`,
+        isDefault,
+    };
+}
+/** Historical default layout. Old DAGs without frontendTestLayout use this. */
+export function defaultFrontendTestLayout() {
+    return resolveFrontendTestLayout(undefined);
+}
+export function frontendTestLayoutFromSpec(spec) {
+    const frozen = spec?.frontendTestLayout;
+    if (!frozen)
+        return defaultFrontendTestLayout();
+    return resolveFrontendTestLayout({ testRoot: frozen.testRoot });
+}
+const DEFAULT_PREFIX = `${FRONTEND_TEST_DEFAULT_TEST_ROOT}/`;
+/**
+ * Longest-prefix rewrite of historical `testcase/frontend/` paths.
+ * No-op when layout.isDefault so default DAGs stay byte-identical.
+ * Never replaces the short token `testcase/` (would collide with backend-test).
+ */
+export function applyFrontendTestLayoutToText(text, layout) {
+    if (layout.isDefault)
+        return text;
+    const replacement = `${layout.testRoot}/`;
+    let output = "";
+    for (let i = 0; i < text.length;) {
+        if (text.startsWith(replacement, i)) {
+            output += replacement;
+            i += replacement.length;
+            continue;
+        }
+        if (text.startsWith(DEFAULT_PREFIX, i)) {
+            output += replacement;
+            i += DEFAULT_PREFIX.length;
+            continue;
+        }
+        output += text[i];
+        i += 1;
+    }
+    return output;
+}
+export function frontendTestCasePath(layout, caseId) {
+    return `${layout.casesDir}/${caseId}.md`;
+}
+export function frontendTestEvidenceDir(layout, caseId) {
+    return `${layout.evidenceDir}/${caseId}/`;
+}
+export function frontendTestEvidencePrefix(layout, caseId) {
+    return `${layout.evidenceDir}/${caseId}`;
+}
+export function frontendTestManifestPath(layout) {
+    return `${layout.casesDir}/manifest.json`;
+}
+export function frontendTestManifestDraftPath(layout) {
+    return `${layout.casesDir}/manifest.draft.json`;
+}
+export function frontendTestContextRel(layout) {
+    return `${layout.ragDir}/context.md`;
+}
+export function frontendTestCoverageMapRel(layout) {
+    return `${layout.ragDir}/coverage-map.md`;
+}
+export function frontendTestProbeRel(layout) {
+    return `${layout.ragDir}/environment-probe.json`;
+}
+export function frontendTestStandardScenariosRel(layout) {
+    return `${layout.ragDir}/standard-scenarios.v1.json`;
+}
+export function frontendTestUiAnchorsRel(layout) {
+    return `${layout.ragDir}/ui-anchors.md`;
+}
+export function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}