@tea-agent/loop-agent 0.28.13 → 0.29.1

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -0,0 +1,418 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { expectedBackendTestPytestScriptForMarkdownModule, normalizeBackendTestModuleStem, } from "./backend-test-markdown-workflow.js";
+export const BACKEND_TEST_WRITER_PROGRESS_SCHEMA_ID = "backend-test-writer-progress-v1";
+export const BACKEND_TEST_OUTPUT_LIMIT_RECOVERY_REPORT = "backend-test-output-limit-recovery.md";
+const progressSchema = z
+    .object({
+    schemaId: z.literal(BACKEND_TEST_WRITER_PROGRESS_SCHEMA_ID),
+    role: z.enum(["md-generate", "pytest-generate", "report"]),
+    status: z.enum(["PASS", "RECOVERABLE", "NON_RECOVERABLE"]),
+    expectedPaths: z.array(z.string()),
+    actualPaths: z.array(z.string()),
+    missingPaths: z.array(z.string()),
+    brokenPaths: z.array(z.string()),
+    targetPaths: z.array(z.string()),
+    issues: z.array(z
+        .object({
+        code: z.enum(["T3", "T4", "T5", "T6"]),
+        path: z.string().optional(),
+        detail: z.string(),
+        recoverable: z.boolean(),
+    })
+        .strict()),
+})
+    .strict();
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function orderedUnique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function hasMarkdownTable(section, headerNeedle) {
+    const lines = section
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n");
+    const headerIndex = lines.findIndex((line) => line.toLowerCase().includes(headerNeedle.toLowerCase()));
+    if (headerIndex < 0)
+        return false;
+    const header = lines[headerIndex] ?? "";
+    const separator = lines[headerIndex + 1] ?? "";
+    return (header.includes("|") &&
+        /-{3,}/.test(separator) &&
+        separator.includes("|"));
+}
+function extractModuleStemsFromReadme(readme) {
+    const stems = [];
+    for (const match of readme.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
+        const stem = match[1];
+        if (stem && stem.toLowerCase() !== "readme")
+            stems.push(stem);
+    }
+    for (const match of readme.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
+        if (match[1])
+            stems.push(match[1]);
+    }
+    for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
+        if (match[1] && match[1].toLowerCase() !== "readme")
+            stems.push(match[1]);
+    }
+    return orderedUnique(stems.map((stem) => normalizeBackendTestModuleStem(stem)));
+}
+async function listMarkdownModules(workspaceRoot) {
+    const root = path.join(workspaceRoot, "testcase", "md");
+    if (!(await exists(root)))
+        return [];
+    const entries = await readdir(root, { withFileTypes: true });
+    return orderedUnique(entries
+        .filter((entry) => entry.isFile() &&
+        entry.name.toLowerCase().endsWith(".md") &&
+        entry.name.toLowerCase() !== "readme.md")
+        .map((entry) => path.posix.join("testcase/md", entry.name.replaceAll("\\", "/"))));
+}
+function moduleStructurallyComplete(markdown) {
+    if (!markdown.trim())
+        return false;
+    if (!/^##\s+BE-[A-Z0-9_-]+-\d{2,3}\b/m.test(markdown))
+        return false;
+    const required = [
+        "\u8986\u76d6\u89c4\u5219",
+        "\u6d4b\u8bd5\u70b9",
+        "\u573a\u666f\u7c7b\u578b",
+        "\u524d\u7f6e\u6761\u4ef6",
+        "\u64cd\u4f5c\u6b65\u9aa4",
+        "\u9884\u671f\u7ed3\u679c",
+        "\u81ea\u52a8\u5316\u6620\u5c04"
+    ];
+    return required.every((heading) => markdown.includes(`### ${heading}`));
+}
+function pythonParseable(source) {
+    const text = source.replace(/\r\n/g, "\n");
+    if (!text.trim())
+        return false;
+    if (/^\s*(?:def|class|import|from)\b/m.test(text) === false)
+        return false;
+    const openParens = (text.match(/\(/g) ?? []).length;
+    const closeParens = (text.match(/\)/g) ?? []).length;
+    const openBrackets = (text.match(/\[/g) ?? []).length;
+    const closeBrackets = (text.match(/\]/g) ?? []).length;
+    const openBraces = (text.match(/\{/g) ?? []).length;
+    const closeBraces = (text.match(/\}/g) ?? []).length;
+    if (openParens !== closeParens)
+        return false;
+    if (openBrackets !== closeBrackets)
+        return false;
+    if (openBraces !== closeBraces)
+        return false;
+    if (/("""|''')[\s\S]*$/.test(text)) {
+        const triples = text.match(/("""|''')/g) ?? [];
+        if (triples.length % 2 !== 0)
+            return false;
+    }
+    if (/\bdef\s+\w+\s*\([^)]*$/m.test(text))
+        return false;
+    if (/\bpytest\.param\s*\([^)]*$/m.test(text))
+        return false;
+    return true;
+}
+export function buildOutputLimitRecoveryPrompt(input) {
+    const paths = input.targetPaths.length > 0
+        ? input.targetPaths.map((item) => `  - ${item}`).join("\n")
+        : "  - (none)";
+    return [
+        "<retry_instruction>",
+        `OUTPUT_LIMIT_RECOVERY attempt=${input.attempt}/${input.maxAttempts}`,
+        `reason=${input.reason}`,
+        "target_paths_only:",
+        paths,
+        "Rules:",
+        "- Continue or repair ONLY listed paths; do not delete or shrink in-scope cases/rules/TPs.",
+        "- One file per write/edit; no chat dump of full bodies.",
+        "- Prefer edit/append for truncated files; rewrite a file only if unparseable or empty.",
+        "- After targets are complete, short IMPLEMENTATION_OUTCOME only.",
+        "- Do not mark already-satisfied if any target_path still missing or structurally broken.",
+        "- Preserve quality invariants: no scope shrink, no skip/xfail, no secret-shaped samples.",
+        "</retry_instruction>",
+    ].join("\n");
+}
+export async function assessBackendTestMdWriterCompleteness(workspaceRoot) {
+    const issues = [];
+    const expectedPaths = ["testcase/md/README.md"];
+    const actualPaths = [];
+    const missingPaths = [];
+    const brokenPaths = [];
+    const readmePath = path.join(workspaceRoot, "testcase", "md", "README.md");
+    let readme = "";
+    if (!(await exists(readmePath))) {
+        missingPaths.push("testcase/md/README.md");
+        issues.push({
+            code: "T3",
+            path: "testcase/md/README.md",
+            detail: "README.md is missing",
+            recoverable: true,
+        });
+    }
+    else {
+        actualPaths.push("testcase/md/README.md");
+        readme = await readFile(readmePath, "utf8");
+        if (!readme.includes("## Coverage Scope")) {
+            brokenPaths.push("testcase/md/README.md");
+            issues.push({
+                code: "T5",
+                path: "testcase/md/README.md",
+                detail: "README.md is missing ## Coverage Scope",
+                recoverable: true,
+            });
+        }
+        if (!readme.includes("## Coverage Matrix") ||
+            !hasMarkdownTable(readme, "Rule Key")) {
+            if (!brokenPaths.includes("testcase/md/README.md")) {
+                brokenPaths.push("testcase/md/README.md");
+            }
+            issues.push({
+                code: "T5",
+                path: "testcase/md/README.md",
+                detail: "README.md Coverage Matrix table is missing or broken",
+                recoverable: true,
+            });
+        }
+    }
+    const indexedStems = extractModuleStemsFromReadme(readme);
+    const existingModules = await listMarkdownModules(workspaceRoot);
+    const existingByStem = new Map(existingModules.map((rel) => [
+        normalizeBackendTestModuleStem(path.posix.basename(rel)),
+        rel,
+    ]));
+    for (const stem of indexedStems) {
+        const rel = `testcase/md/${stem}.md`;
+        expectedPaths.push(rel);
+        const existing = existingByStem.get(stem);
+        if (!existing) {
+            missingPaths.push(rel);
+            issues.push({
+                code: "T3",
+                path: rel,
+                detail: `module file missing for README index stem ${stem}`,
+                recoverable: true,
+            });
+            continue;
+        }
+        actualPaths.push(existing);
+        const body = await readFile(path.join(workspaceRoot, existing), "utf8");
+        if (!moduleStructurallyComplete(body)) {
+            brokenPaths.push(existing);
+            issues.push({
+                code: "T5",
+                path: existing,
+                detail: "module file is empty or missing required case sections",
+                recoverable: true,
+            });
+        }
+    }
+    for (const rel of existingModules) {
+        if (!actualPaths.includes(rel))
+            actualPaths.push(rel);
+        const body = await readFile(path.join(workspaceRoot, rel), "utf8");
+        if (!moduleStructurallyComplete(body) && !brokenPaths.includes(rel)) {
+            brokenPaths.push(rel);
+            issues.push({
+                code: "T5",
+                path: rel,
+                detail: "module file is empty or missing required case sections",
+                recoverable: true,
+            });
+        }
+    }
+    if (existingModules.length === 0 &&
+        indexedStems.length === 0 &&
+        (await exists(readmePath))) {
+        issues.push({
+            code: "T3",
+            detail: "no module Markdown files were produced",
+            recoverable: true,
+        });
+    }
+    const targetPaths = orderedUnique([...missingPaths, ...brokenPaths]);
+    const nonRecoverable = issues.some((issue) => !issue.recoverable);
+    const status = nonRecoverable
+        ? "NON_RECOVERABLE"
+        : targetPaths.length > 0 || issues.length > 0
+            ? "RECOVERABLE"
+            : "PASS";
+    return {
+        schemaId: BACKEND_TEST_WRITER_PROGRESS_SCHEMA_ID,
+        role: "md-generate",
+        status,
+        expectedPaths: orderedUnique(expectedPaths),
+        actualPaths: orderedUnique(actualPaths),
+        missingPaths: orderedUnique(missingPaths),
+        brokenPaths: orderedUnique(brokenPaths),
+        targetPaths,
+        issues,
+    };
+}
+export async function assessBackendTestPytestWriterCompleteness(workspaceRoot) {
+    const issues = [];
+    const expectedPaths = [];
+    const actualPaths = [];
+    const missingPaths = [];
+    const brokenPaths = [];
+    const modules = await listMarkdownModules(workspaceRoot);
+    for (const moduleRel of modules) {
+        const expected = expectedBackendTestPytestScriptForMarkdownModule(path.posix.basename(moduleRel));
+        expectedPaths.push(expected);
+        const absolute = path.join(workspaceRoot, expected);
+        if (!(await exists(absolute))) {
+            missingPaths.push(expected);
+            issues.push({
+                code: "T3",
+                path: expected,
+                detail: `mapped pytest script missing for ${moduleRel}`,
+                recoverable: true,
+            });
+            continue;
+        }
+        actualPaths.push(expected);
+        const source = await readFile(absolute, "utf8");
+        if (!pythonParseable(source)) {
+            brokenPaths.push(expected);
+            issues.push({
+                code: "T5",
+                path: expected,
+                detail: "pytest script appears truncated or unparseable",
+                recoverable: true,
+            });
+            continue;
+        }
+        const markdown = await readFile(path.join(workspaceRoot, moduleRel), "utf8");
+        const caseIds = orderedUnique([...markdown.matchAll(/\bBE-[A-Z0-9_-]+-\d{2,3}\b/g)].map((item) => item[0]));
+        const primaryHints = orderedUnique([
+            ...markdown.matchAll(/primary\s*symbol\s*[:：]\s*`?([A-Za-z0-9_]+)`?/gi),
+        ].map((item) => item[1]));
+        for (const symbol of primaryHints) {
+            if (!source.includes(symbol)) {
+                brokenPaths.push(expected);
+                issues.push({
+                    code: "T5",
+                    path: expected,
+                    detail: `primary symbol ${symbol} not found in mapped script`,
+                    recoverable: true,
+                });
+                break;
+            }
+        }
+        if (caseIds.length > 0 &&
+            !caseIds.some((caseId) => source.includes(caseId) || source.includes(caseId.replaceAll("-", "_")))) {
+            brokenPaths.push(expected);
+            issues.push({
+                code: "T5",
+                path: expected,
+                detail: "no Markdown Case ID found in mapped pytest script",
+                recoverable: true,
+            });
+        }
+    }
+    const targetPaths = orderedUnique([...missingPaths, ...brokenPaths]);
+    const status = targetPaths.length > 0 || issues.length > 0 ? "RECOVERABLE" : "PASS";
+    return {
+        schemaId: BACKEND_TEST_WRITER_PROGRESS_SCHEMA_ID,
+        role: "pytest-generate",
+        status,
+        expectedPaths: orderedUnique(expectedPaths),
+        actualPaths: orderedUnique(actualPaths),
+        missingPaths: orderedUnique(missingPaths),
+        brokenPaths: orderedUnique(brokenPaths),
+        targetPaths,
+        issues,
+    };
+}
+export function classifyBackendTestWriterCompletenessFailure(progress) {
+    if (progress.status === "PASS") {
+        return {
+            failureCategory: "invalid-output",
+            reason: "T4",
+            recoverable: false,
+        };
+    }
+    if (progress.status === "NON_RECOVERABLE") {
+        return {
+            failureCategory: "invalid-output",
+            reason: "T6",
+            recoverable: false,
+        };
+    }
+    const preferred = progress.issues.find((issue) => issue.code === "T5")?.code ??
+        progress.issues.find((issue) => issue.code === "T3")?.code ??
+        progress.issues.find((issue) => issue.code === "T4")?.code ??
+        "T3";
+    return {
+        failureCategory: "incomplete-write-set",
+        reason: preferred,
+        recoverable: true,
+    };
+}
+export async function writeBackendTestWriterProgressArtifacts(input) {
+    const contractsDir = path.join(input.runDir, "contracts");
+    await mkdir(contractsDir, { recursive: true });
+    const factsPath = path.join(contractsDir, `backend-test-writer-progress-${input.progress.role}.json`);
+    const parsed = progressSchema.parse(input.progress);
+    await writeFile(factsPath, JSON.stringify(parsed, null, 2), "utf8");
+    if (input.progress.status === "PASS") {
+        return { factsPath };
+    }
+    const reportsDir = path.join(input.runDir, "reports");
+    await mkdir(reportsDir, { recursive: true });
+    const reportPath = path.join(reportsDir, BACKEND_TEST_OUTPUT_LIMIT_RECOVERY_REPORT);
+    const attempt = input.attempt ?? 1;
+    const maxAttempts = input.maxAttempts ?? 3;
+    const classification = classifyBackendTestWriterCompletenessFailure(input.progress);
+    const body = [
+        "# Backend-test Output Limit Recovery",
+        "",
+        `- Role: ${input.progress.role}`,
+        `- Status: ${input.progress.status}`,
+        `- Attempt: ${attempt}/${maxAttempts}`,
+        `- Reason: ${classification.reason}`,
+        `- Recoverable: ${classification.recoverable}`,
+        "",
+        "## Target paths",
+        "",
+        ...(input.progress.targetPaths.length
+            ? input.progress.targetPaths.map((item) => `- ${item}`)
+            : ["- (none)"]),
+        "",
+        "## Issues",
+        "",
+        ...(input.progress.issues.length
+            ? input.progress.issues.map((issue) => `- [${issue.code}] ${issue.path ?? "(workspace)"}: ${issue.detail}`)
+            : ["- None"]),
+        "",
+        `<!-- sha256:${createHash("sha256").update(JSON.stringify(parsed)).digest("hex")} -->`,
+        "",
+    ].join("\n");
+    await writeFile(reportPath, body, "utf8");
+    return { factsPath, reportPath };
+}
+export function isBackendTestCompletenessRetryCandidate(task) {
+    if (task.executor !== "pi" || task.role !== "implementer")
+        return false;
+    if (task.toolProfile !== "write" || task.writePolicy !== "exclusive") {
+        return false;
+    }
+    if ((task.writeSet?.length ?? 0) === 0)
+        return false;
+    if (task.writerOutcomePolicy?.type !== "implementation-outcome-v1") {
+        return false;
+    }
+    return (task.id === "generate-backend-md-cases-pi" ||
+        task.id === "generate-backend-pytest-pi");
+}

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(/[)\]},.\"'`]+$/, ""));