@tea-agent/loop-agent 0.29.0 → 0.29.1

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [0.29.1] - 2026-08-07
+
+### 重点更新
+
+- 前端测试默认执行流程大幅精简，收敛至约 11 个静态节点，合并了多项检查与报告步骤
+- 前端测试浏览器默认改为无头（headless）模式，减少环境干扰
+- 优化证据缺失处理逻辑，非路径逃逸的异常不再强制阻断报告生成
+- 修复文档说明被误判为可执行命令的问题，提升执行稳定性
+
+### 新增
+
+- 新增前端测试标准场景物化节点，支持执行后针对阻塞或缺失证据进行最多两轮有界重跑
+- 新增前端测试标准场景规范模板（frontend-test-standard-scenarios.v1.json）
+- 前端测试独占节点支持 tools-only 写保护策略，在保留工具级写沙箱的同时跳过 Git 基线的硬失败限制
+
+### 改进
+
+- 前端测试默认 DAG 结构精简至约 11 个静态节点：合并双重重跑、检查清单与清单文件、证据与结果、L5 与 HTML 报告
+- 前端测试主 HTML 报告不再依赖回顾（retrospect）节点，回顾功能改为可选开启
+- 权威清单文件（manifest.json）仅记录规范化后的测试用例，并在未配置重试时省略相关静态节点
+- 强化运营 HTML 报告的状态过滤功能，并优化失败与阻塞原因的展示
+
+### 修复
+
+- 修复前端测试检查清单将不可用或阻塞状态的说明文字误判为非法可执行命令的问题
+- 修复前端测试收尾阶段因证据缺失或格式错误导致强制失败的问题，现仅对路径逃逸强制报错，其余降级为建议性提示
+- 修复前端测试合并后清单文件物化异常的问题，确保仅写入规范化用例并恢复负向测试用例
+- 回退误改的全局默认 Pi 模型（DEFAULT_PI_MODEL），将其恢复为 glm-5.2，模型路由统一交由 harness 复杂度矩阵处理
+
 ## [0.29.0] - 2026-08-07
 
 ### 重点更新

package/dist/commands/init.js

@@ -2217,7 +2217,7 @@ function buildTargetFeatureWorkflow(input) {
         '- `taskKind: "backend-test"` selects the dedicated backend test DAG. Its Pi nodes analyze requirements, generate and review backend cases, generate pytest, and retrospect on results; shell gate/execution nodes enforce the review verdict and run the target project\'s pytest. The backend test templates (`backend-test-dag.json` and the `backend-test-dag.*.prompt.md` files) ship inside the loop-agent package as static references and are projected to target projects under the governance `templates/` directory.',
         '- `taskKind: "knowledge-sync"` selects the Feature-scoped test-knowledge write-back DAG (collect → draft → validate → apply → pointer). Bind `featureId` in `task.json` (or hardConstraints / requirement text). It writes only under `features/<featureId>/…` after final verification evidence exists.',
         '- `taskKind: "knowledge-graph-bootstrap"` selects the business knowledge-graph bootstrap DAG (preflight → inventory → propose → validate → review → gate → promote → materialize). AI writes only `knowledge/bootstrap/staging/**`; promote is merge-new-only.',
-        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headed <base-url>`; the generic playwright-cli skill is unchanged.',
+        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headless <base-url>`; the generic playwright-cli skill is unchanged.',
         "- Only eligible read-only Pi nodes (planner, scout, reviewer, verifier, closeout with no write-capable tool profile) receive the conservative automatic retry policy. Supervisor, implementer, writer, docs-only, dynamic, shell, static, and decision-gate nodes are not retried automatically. Eligible nodes cannot write repository files; the controller only records immutable attempt evidence under `.harness/dag-runs/<state>/<run-id>/<node-id>/attempt-<n>.json`.",
         "",
         "Use the package-backed public knowledge CLI for graph operations. Do not require target projects to run package-only kb runtime scripts:",

package/dist/executors/dag-pi-executor.js

@@ -340,7 +340,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     }
     let beforeStatus;
     let beforePathFingerprints;
-    if (isWriteTask) {
+    /** tools-only: keep SDK path sandbox; skip git baseline + post-diff write-guard hard fail. */
+    const skipGitWriteGuard = isWriteTask && input.task.writeGuardPolicy === "tools-only";
+    if (isWriteTask && !skipGitWriteGuard) {
         try {
             beforeStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-before" });
             const beforeSnapshot = snapshotGitStatusPorcelain(beforeStatus);

package/dist/executors/pi-playwright-cli-tool.js

@@ -197,15 +197,21 @@ function validateOpenArgs(args, baseUrl) {
     for (const arg of args) {
         assertNoControlMeta(arg);
         assertNoSessionFlag(arg);
-        if (arg === "--browser=chrome" || arg === "--headed") {
+        if (arg === "--browser=chrome" || arg === "--headless") {
             flags.add(arg);
             normalized.push(arg);
             continue;
         }
+        // Accept legacy --headed but normalize to headless for frontend-test CI/dogfood.
+        if (arg === "--headed") {
+            flags.add("--headless");
+            if (!normalized.includes("--headless"))
+                normalized.push("--headless");
+            continue;
+        }
         if (arg.startsWith("--browser=") ||
-            arg === "--browser" ||
-            arg === "--headless") {
-            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headed only");
+            arg === "--browser") {
+            throw new PlaywrightCliPolicyError("open-browser-flags", "open must use --browser=chrome --headless only");
         }
         if (/^[a-z][a-z0-9+.-]*:/i.test(arg) || arg.startsWith("http")) {
             url = arg;
@@ -213,12 +219,12 @@ function validateOpenArgs(args, baseUrl) {
         }
         throw new PlaywrightCliPolicyError("open-args", `unsupported open argument: ${arg}`);
     }
-    if (!flags.has("--browser=chrome") || !flags.has("--headed")) {
+    if (!flags.has("--browser=chrome") || !flags.has("--headless")) {
         // controller injects required flags when missing from model args
         if (!flags.has("--browser=chrome"))
             normalized.unshift("--browser=chrome");
-        if (!flags.has("--headed"))
-            normalized.push("--headed");
+        if (!flags.has("--headless"))
+            normalized.push("--headless");
     }
     if (!url) {
         throw new PlaywrightCliPolicyError("open-url-required", "open requires an absolute http(s) URL");
@@ -509,7 +515,7 @@ export function preparePlaywrightCliArgv(input, ctx) {
             catch {
                 throw new PlaywrightCliPolicyError("goto-url-invalid", "goto requires a URL relative to the controller baseUrl");
             }
-            const openLike = validateOpenArgs(["--browser=chrome", "--headed", target], ctx.baseUrl);
+            const openLike = validateOpenArgs(["--browser=chrome", "--headless", target], ctx.baseUrl);
             return openLike[openLike.length - 1];
         });
         if (args.length !== 1) {

package/dist/executors/shell-executor.js

@@ -18,6 +18,7 @@ import { materializeFrontendImplementationContract } from "../workflows/dag/fron
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { renderFrontendTestL5Report } from "../workflows/dag/frontend-test-l5-report.js";
 import { validateFrontendCaseChecklist } from "../workflows/dag/frontend-test-case-checklist.js";
+import { materializeFrontendTestCaseManifest } from "../workflows/dag/frontend-test-case-manifest.js";
 import { renderFrontendTestHtmlReport } from "../workflows/dag/frontend-test-html-report.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
@@ -1826,6 +1827,149 @@ async function executeFrontendTestEvidenceValidation(input) {
         };
     }
 }
+async function executeFrontendTestCaseManifest(input, meta) {
+    const started = Date.now();
+    try {
+        const gate = input.task.shell?.frontendTestCaseManifest ?? {};
+        const declaredAcIds = gate.declaredAcIds ??
+            (meta.spec.sourceBinding?.requirementIds ?? []).filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
+        const checklist = await validateFrontendCaseChecklist({
+            workspaceRoot: input.cwd,
+            declaredAcIds,
+        });
+        if (checklist.issues.length) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `frontend-test checklist blocked: ${JSON.stringify(checklist.issues)}`,
+                failureCategory: "invalid-output",
+                durationMs: Date.now() - started,
+            };
+        }
+        const materialized = await materializeFrontendTestCaseManifest({
+            workspaceRoot: input.cwd,
+            maxCases: gate.maxCases,
+            declaredAcIds,
+        });
+        return {
+            ok: true,
+            stdout: `${JSON.stringify({ cases: materialized.cases })}
+`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+/** Path-escape / cross-case evidence errors must hard-fail finalize (same class as validate.hardFail). */
+function isFrontendTestEvidencePathHardError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /unsafe evidence|escapes (?:evidence root|its allowed root)|evidence realpath|cross-case/i.test(message);
+}
+/**
+ * Lean finalize: evidence validate + result materialize in one shell.
+ * - Case-level missing/malformed evidence is advisory (issues / advisoryFindings);
+ *   the node still succeeds so reports can render incomplete/failed outcomes.
+ * - Path escape / unsafe evidence roots hard-fail the node.
+ * - Controller/contract errors (missing sourceBinding, empty manifest) still fail closed.
+ */
+async function executeFrontendTestResultFinalize(input, meta) {
+    const started = Date.now();
+    let advisoryStdout = "";
+    try {
+        const evidence = await validateFrontendCaseEvidence({
+            workspaceRoot: input.cwd,
+        });
+        advisoryStdout = `frontend case evidence validation cases=${evidence.cases} findings=${evidence.issues.length}${evidence.issues.length ? ` issues=${JSON.stringify(evidence.issues)}` : ""}`;
+        // Advisory findings must not block materialize; only hardFail (path escape) does.
+        if (evidence.hardFail) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${JSON.stringify(evidence.issues)}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        const artifact = await materializeFrontendTestResult({
+            runDir: meta.runDir,
+            workspaceRoot: input.cwd,
+            artifactName: "frontend-test-result.json",
+            outputDir: "contracts",
+            sourceBinding: meta.spec.sourceBinding,
+        });
+        return {
+            ok: true,
+            stdout: `${advisoryStdout}\nStructured artifact: ${artifact.path}\nSchema: ${artifact.schemaId}\nSHA-256: ${artifact.sha256}`,
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (isFrontendTestEvidencePathHardError(error)) {
+            return {
+                ok: false,
+                stdout: advisoryStdout,
+                stderr: `frontend-test evidence hard-fail: ${detail}`,
+                failureCategory: "nonzero-exit",
+                durationMs: Date.now() - started,
+            };
+        }
+        return {
+            ok: false,
+            stdout: advisoryStdout,
+            stderr: detail,
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
+async function executeFrontendTestReports(input, meta) {
+    const started = Date.now();
+    try {
+        const writeL5 = input.task.shell?.frontendTestReports?.l5 !== false;
+        const lines = [];
+        if (writeL5) {
+            const l5 = await renderFrontendTestL5Report({
+                workspaceRoot: input.cwd,
+                runDir: meta.runDir,
+            });
+            lines.push(`Frontend L-5 report: ${l5.htmlPath}\nMarkdown: ${l5.markdownPath}\nStatus: ${l5.metrics.status}`);
+        }
+        const report = await renderFrontendTestHtmlReport({
+            workspaceRoot: input.cwd,
+            runDir: meta.runDir,
+        });
+        lines.push(`Frontend test report: ${report.htmlPath}\nMarkdown: ${report.markdownPath}\nOutcome: ${report.outcome}\nCases: ${report.caseCount}`);
+        return {
+            ok: true,
+            stdout: lines.join("\n"),
+            stderr: "",
+            failureCategory: "success",
+            durationMs: Date.now() - started,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            failureCategory: "invalid-output",
+            durationMs: Date.now() - started,
+        };
+    }
+}
 async function executeFrontendLintBaseline(input, meta) {
     const started = Date.now();
     const shell = input.task.shell;
@@ -2062,15 +2206,24 @@ export async function executeDagShellNode(input, meta) {
     if (shell?.frontendTestCaseChecklist) {
         return executeFrontendTestCaseChecklist(input, meta);
     }
+    if (shell?.frontendTestCaseManifest) {
+        return executeFrontendTestCaseManifest(input, meta);
+    }
     if (shell?.frontendTestEvidenceValidation) {
         return executeFrontendTestEvidenceValidation(input);
     }
+    if (shell?.frontendTestResultFinalize) {
+        return executeFrontendTestResultFinalize(input, meta);
+    }
     if (shell?.frontendTestL5Report) {
         return executeFrontendTestL5Report(input, meta);
     }
     if (shell?.frontendTestHtmlReport) {
         return executeFrontendTestHtmlReport(input, meta);
     }
+    if (shell?.frontendTestReports) {
+        return executeFrontendTestReports(input, meta);
+    }
     if (shell?.backendTestPipeline) {
         return executeBackendTestPipelineWithWriteGuard(input, meta);
     }

package/dist/task/config-types.js

@@ -83,6 +83,27 @@ export const frontendTestConfigSchema = z.object({
      * Default false: pipeline success is result materialize + retrospect report, not full green.
      */
     strictOutcomeGate: z.boolean().optional(),
+    /**
+     * Maximum rerun attempts for blocked or missing-result frontend cases.
+     * Defaults to 2; the static graph always carries a single rerun select+map
+     * pair and bounds candidates within that pair via this value.
+     */
+    maxRerunAttempts: z.number().int().min(0).max(4).optional(),
+    /**
+     * Report chain toggles for the lean frontend-test DAG.
+     * - retrospect: opt-in Pi retrospective node (default off). Pipeline success
+     *   is frontend-test-result-v1 + main HTML/MD report, not the retrospect.
+     * - l5: write the deterministic L-5 dashboard from the merged reports node
+     *   (default true; the merged reports node always renders the main
+     *   HTML/MD report regardless of this flag).
+     */
+    reports: z
+        .object({
+        retrospect: z.boolean().optional(),
+        l5: z.boolean().optional(),
+    })
+        .strict()
+        .optional(),
 });
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),

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

@@ -6,6 +6,9 @@ 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_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]+)`[.!?]?$/;
 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;
@@ -31,7 +34,53 @@ function isExecutableFence(language) {
     return COMMAND_FENCE_LANGUAGE.test(language.trim());
 }
 function isBlockedReason(value) {
-    return BLOCKED_REASON_PREFIX.test(value.trim());
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    if (BLOCKED_REASON_PREFIX.test(trimmed))
+        return true;
+    // Bare reason enum / metadata line (BugPilot blocked sections).
+    if (BLOCKED_REASON_TOKEN.test(trimmed.replace(/^`+|`+$/g, "")))
+        return true;
+    if (/^blockedReason\s*[:=]/i.test(trimmed))
+        return true;
+    return false;
+}
+/**
+ * Non-executable prose that mentions playwright-cli / reason tokens for blocked
+ * paths (e.g. "playwright-cli 不可用时… blockedReason: …"). Must not enter the
+ * command allowlist gate.
+ */
+function isNonExecutableBlockedProse(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return false;
+    if (isBlockedReason(trimmed))
+        return true;
+    const normalized = normalizeCommand(trimmed);
+    const bare = normalized.replace(/^`+|`+$/g, "").trim();
+    if (BLOCKED_REASON_TOKEN.test(bare))
+        return true;
+    // "playwright-cli 不可用…" / "playwright-cli unavailable…" documentation.
+    if (/^playwright-cli\b/i.test(normalized) &&
+        BLOCKED_PROSE_HINT.test(normalized) &&
+        !/^playwright-cli\s+[a-z][a-z0-9-]*\b/i.test(normalized)) {
+        return true;
+    }
+    const pw = normalized.match(/^playwright-cli\s+(\S+)([\s\S]*)$/i);
+    if (pw) {
+        const first = pw[1].replace(/^[`'"]+|[`'":,，。→]+$/g, "");
+        if (!isPlaywrightCliCommand(first.toLowerCase())) {
+            // Non-verb after playwright-cli in prose (e.g. 不可用 / unavailable).
+            return /[\u4e00-\u9fff]/.test(first) || BLOCKED_PROSE_HINT.test(normalized) || !/^[a-z][a-z0-9-]*$/i.test(first);
+        }
+    }
+    // Reason token embedded without looking like a real CLI invocation.
+    if (BLOCKED_PROSE_HINT.test(trimmed) &&
+        !/^playwright-cli\s+[a-z][a-z0-9-]*(\s+--|\s+https?:|\s*$)/i.test(normalized)) {
+        return true;
+    }
+    return false;
 }
 function stripLeadingCommandWrappers(command) {
     let remaining = command.trim();
@@ -64,17 +113,30 @@ function isCommandLikeExecutable(command) {
 }
 function executableListStep(value) {
     const trimmed = value.trim();
+    if (isNonExecutableBlockedProse(trimmed))
+        return null;
     const explicit = trimmed.match(EXPLICIT_COMMAND);
-    if (explicit)
-        return isBlockedReason(explicit[1]) ? null : normalizeCommand(explicit[1]);
+    if (explicit) {
+        if (isBlockedReason(explicit[1]) || isNonExecutableBlockedProse(explicit[1]))
+            return null;
+        return normalizeCommand(explicit[1]);
+    }
     const imperative = trimmed.match(IMPERATIVE_COMMAND);
-    if (imperative)
+    if (imperative) {
+        if (isNonExecutableBlockedProse(imperative[1]))
+            return null;
         return normalizeCommand(imperative[1]);
+    }
     const inlineCode = trimmed.match(INLINE_CODE_STEP);
-    if (inlineCode)
+    if (inlineCode) {
+        if (isNonExecutableBlockedProse(inlineCode[1]))
+            return null;
         return normalizeCommand(inlineCode[1]);
+    }
     const prompted = /^[$>]\s*\S/.test(trimmed);
     const normalized = normalizeCommand(trimmed);
+    if (isNonExecutableBlockedProse(normalized))
+        return null;
     if (prompted || isCommandLikeExecutable(normalized))
         return normalized;
     return null;
@@ -127,12 +189,15 @@ function extractExecutableInstructions(markdown) {
         if (fenceLanguage !== null) {
             if (!isExecutableFence(fenceLanguage) || /^(?:#|\/\/)/.test(trimmed))
                 continue;
-            instructions.push({ command: normalizeCommand(trimmed), lineNumber });
+            // Fenced blocks are strict: only skip pure reason-token / blockedReason lines.
+            if (isBlockedReason(trimmed) || BLOCKED_REASON_TOKEN.test(normalizeCommand(trimmed).replace(/^`+|`+$/g, "")))
+                continue;
+            instructions.push({ command: normalizeCommand(trimmed), lineNumber, fromFence: true });
             continue;
         }
         const listed = line.match(LIST_ITEM);
         if (listed) {
-            if (isBlockedReason(listed[1]))
+            if (isBlockedReason(listed[1]) || isNonExecutableBlockedProse(listed[1]))
                 continue;
             const command = executableListStep(listed[1]);
             if (command !== null)
@@ -141,17 +206,20 @@ function extractExecutableInstructions(markdown) {
         }
         const indented = line.match(INDENTED_CODE);
         if (indented) {
-            if (isBlockedReason(indented[1]))
+            if (isBlockedReason(indented[1]) || isNonExecutableBlockedProse(indented[1]))
                 continue;
             const explicitIndented = indented[1].match(EXPLICIT_COMMAND);
-            if (explicitIndented && isBlockedReason(explicitIndented[1]))
+            if (explicitIndented && (isBlockedReason(explicitIndented[1]) || isNonExecutableBlockedProse(explicitIndented[1])))
+                continue;
+            const fromStep = executableListStep(indented[1]);
+            if (fromStep === null)
                 continue;
-            instructions.push({ command: executableListStep(indented[1]) ?? normalizeCommand(indented[1]), lineNumber });
+            instructions.push({ command: fromStep, lineNumber });
             continue;
         }
         const explicit = trimmed.match(EXPLICIT_COMMAND);
         if (explicit) {
-            if (isBlockedReason(explicit[1]))
+            if (isBlockedReason(explicit[1]) || isNonExecutableBlockedProse(explicit[1]))
                 continue;
             instructions.push({ command: normalizeCommand(explicit[1]), lineNumber });
             continue;
@@ -163,9 +231,16 @@ function extractExecutableInstructions(markdown) {
     return instructions;
 }
 function commandGateIssue(input) {
+    // Outside fences, blocked/unavailable prose must never become a gate failure.
+    if (!input.instruction.fromFence && isNonExecutableBlockedProse(input.instruction.command)) {
+        return null;
+    }
+    if (input.instruction.fromFence && isBlockedReason(input.instruction.command)) {
+        return null;
+    }
     const commandMatch = input.instruction.command.match(/^playwright-cli\s+([^\s`]+)/i);
     if (commandMatch) {
-        const command = commandMatch[1].toLowerCase();
+        const command = commandMatch[1].toLowerCase().replace(/^[`'"]+|[`'":,，。→]+$/g, "");
         if (isPlaywrightCliCommand(command) && !hasShellControl(input.instruction.command))
             return null;
         if (isPlaywrightCliCommand(command)) {
@@ -178,6 +253,10 @@ function commandGateIssue(input) {
                 detail: "shell control or additional executable fragments are not allowed after playwright-cli commands",
             };
         }
+        // Fenced bad verbs stay rejected; unfenced non-verbs already filtered as prose.
+        if (!input.instruction.fromFence && isNonExecutableBlockedProse(input.instruction.command)) {
+            return null;
+        }
         return {
             ruleId: "playwright-cli-command-not-allowed",
             caseId: input.caseId,
@@ -210,7 +289,7 @@ export async function validateFrontendCaseChecklist(input) {
     const issues = [];
     const caseIdRe = /^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;
     const acIdRe = /^AC(?:-[A-Z0-9]+)+$/i;
-    const openRe = /playwright-cli\s+open\s+--browser=chrome\s+--headed\s+https?:\/\/\S+/i;
+    const openRe = /playwright-cli\s+open\s+--browser=chrome\s+--headless\s+https?:\/\/\S+/i;
     const productionHostRe = /(^|[.-])(prod|production)([.-]|$)/i;
     for (const raw of manifest.cases) {
         const item = raw;
@@ -231,8 +310,8 @@ export async function validateFrontendCaseChecklist(input) {
             issues.push({ ruleId: "case-path-mismatch", caseId: id, casePath, detail: `${casePath} must equal ${expectedPath}` });
         const body = await readFile(absolute, "utf8");
         if (!openRe.test(body))
-            issues.push({ ruleId: "open-prefix", caseId: id, casePath, detail: "missing playwright-cli open --browser=chrome --headed <absolute-url>" });
-        const match = body.match(/playwright-cli\s+open\s+--browser=chrome\s+--headed\s+(https?:\/\/\S+)/i);
+            issues.push({ ruleId: "open-prefix", caseId: id, casePath, detail: "missing playwright-cli open --browser=chrome --headless <absolute-url>" });
+        const match = body.match(/playwright-cli\s+open\s+--browser=chrome\s+--headless\s+(https?:\/\/\S+)/i);
         if (match) {
             try {
                 const url = new URL(match[1].replace(/[)\]},.\"'`]+$/, ""));

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

@@ -0,0 +1,104 @@
+import { readFile, rename, unlink, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+const DIMENSIONS = new Set(["core", "boundary", "flow", "backend"]);
+function fail(ruleId, detail) {
+    const msg = JSON.stringify({ ruleId, detail: String(detail ?? "") });
+    console.error(`frontend-test manifest blocked: ${msg}`);
+    throw new Error(`frontend-test manifest blocked: ${ruleId}${detail ? `: ${detail}` : ""}`);
+}
+/**
+ * Validate manifest.draft.json and atomically materialize
+ * testcase/frontend/cases/manifest.json via temp+rename, then delete the draft.
+ *
+ * Writes only a normalized { schemaVersion: 1, cases } payload — never the raw
+ * draft object — so generator typos in casePath/evidenceDir/extra fields cannot
+ * leak into the authoritative manifest.
+ *
+ * unknown-ac is enforced only when declaredAcIds is non-empty (sourceBinding
+ * 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 tmp = `${file}.tmp`;
+    const maxCases = input.maxCases ?? 32;
+    const declaredAc = new Set(input.declaredAcIds ?? []);
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(draft, "utf8"));
+    }
+    catch {
+        fail("draft-missing", `missing ${draft}`);
+    }
+    if (manifest.schemaVersion !== 1)
+        fail("draft-schema", "schemaVersion must be 1");
+    if (!Array.isArray(manifest.cases) || manifest.cases.length === 0)
+        fail("draft-empty-cases", "cases must be a non-empty array");
+    if (manifest.cases.length > maxCases)
+        fail("map-capacity-exceeded", `cases=${manifest.cases.length} exceeds maxCasesPerBatch/maxExpandedNodes=${maxCases}; raise frontendTest.maxCasesPerBatch or shrink the suite`);
+    const seen = new Set();
+    const seenCasePath = new Set();
+    const seenEvidenceDir = new Set();
+    const acIdRe = /^AC(?:-[A-Z0-9]+)+$/i;
+    const cases = [];
+    for (const raw of manifest.cases) {
+        const c = raw;
+        if (!c ||
+            typeof c.caseId !== "string" ||
+            !/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/.test(c.caseId))
+            fail("case-id-shape", `caseId must be FE-*, never AC-FE-*: ${String(c?.caseId)}`);
+        if (/^AC-/i.test(c.caseId))
+            fail("case-id-is-ac", `caseId must not be an acceptance id: ${c.caseId}`);
+        if (seen.has(c.caseId))
+            fail("duplicate-case-id", c.caseId);
+        seen.add(c.caseId);
+        if (typeof c.dimension !== "string" || !DIMENSIONS.has(c.dimension))
+            fail("invalid-dimension", String(c.dimension));
+        if (!Array.isArray(c.acIds) ||
+            c.acIds.length === 0 ||
+            c.acIds.some((a) => typeof a !== "string" || !a.trim()))
+            fail("ac-mapping", `invalid acIds for ${c.caseId}`);
+        const acIds = [];
+        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 && !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}/`;
+        for (const [k, v] of [
+            ["casePath", casePath],
+            ["evidenceDir", evidenceDir],
+        ]) {
+            if (path.isAbsolute(v) || v.includes(".."))
+                fail("unsafe-path", `${k}: ${v}`);
+        }
+        const casePathAbs = path.join(input.workspaceRoot, casePath);
+        const body = await readFile(casePathAbs).catch(() => null);
+        if (body === null)
+            fail("case-file-missing", `missing case file ${casePath} (filename must equal caseId.md)`);
+        if (seenCasePath.has(casePath))
+            fail("duplicate-case-path", casePath);
+        seenCasePath.add(casePath);
+        if (seenEvidenceDir.has(evidenceDir))
+            fail("duplicate-evidence-dir", evidenceDir);
+        seenEvidenceDir.add(evidenceDir);
+        cases.push({
+            caseId: c.caseId,
+            casePath,
+            evidenceDir,
+            dimension: c.dimension,
+            acIds,
+        });
+    }
+    const payload = `${JSON.stringify({ schemaVersion: 1, cases }, null, 2)}\n`;
+    await mkdir(path.dirname(tmp), { recursive: true });
+    await writeFile(tmp, payload, "utf8");
+    await rename(tmp, file);
+    await unlink(draft).catch(() => {
+        /* draft already absent */
+    });
+    return { cases, manifestPath: file };
+}