@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,161 @@
+/**
+ * Deterministic frontend-implementation risk classifier (M4).
+ * Pure function: no I/O, no model, no side effects.
+ */
+const HIGH_RISK_PATTERNS = [
+    {
+        id: "new-route",
+        re: /new\s+route|新增路由|createBrowserRouter|add\s+route|新建页面路由/i,
+    },
+    {
+        id: "shared-public-api",
+        re: /public\s+api|shared\s+component|公共组件|破坏性|breaking\s+change/i,
+    },
+    {
+        id: "auth-permission",
+        re: /\bauth\b|\bpermission\b|\brbac\b|登录|权限|\bjwt\b|\bsession\b/i,
+    },
+    {
+        id: "sensitive-action",
+        re: /\bpayment\b|delete\s+account|支付|删除用户|\bdestructive\b/i,
+    },
+    {
+        id: "ssr-boundary",
+        re: /\bssr\b|\brsc\b|server\s+component|use client|getServerSideProps|\bhydration\b|server-client/i,
+    },
+    {
+        id: "new-dependency",
+        re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖|package\.json/i,
+    },
+    {
+        id: "schema-api-change",
+        re: /\bopenapi\b|graphql\s+schema|api\s+contract|接口变更|schema\s+change/i,
+    },
+    {
+        id: "design-conflict",
+        re: /design\s+conflict|规范冲突|openspec\s+conflict/i,
+    },
+    {
+        id: "cross-domain-paths",
+        re: /多个领域|cross-module|multiple\s+packages/i,
+    },
+    {
+        id: "new-state-infra",
+        re: /\bredux\b|\bzustand\b|\bpinia\b|\bjotai\b|\brecoil\b|新状态库|state\s+management\s+introduc/i,
+    },
+];
+const SMALL_PATTERNS = [
+    {
+        id: "single-component",
+        re: /single\s+component|单一组件|局部样式|style\s+tweak|css\s+only|文案|copy\s+change/i,
+    },
+    {
+        id: "no-remote",
+        re: /no\s+api|无接口|本地状态|local\s+state\s+only|pure\s+ui/i,
+    },
+];
+function blobOf(input) {
+    return [
+        input.title ?? "",
+        input.requirementMarkdown ?? "",
+        input.constraintMarkdown ?? "",
+        (input.allowedPaths ?? []).join("\n"),
+        input.manifestEvidence ?? "",
+    ].join("\n");
+}
+function pathSpreadScore(paths) {
+    const tops = new Set(paths
+        .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter(Boolean));
+    return tops.size;
+}
+/**
+ * Classify frontend task risk. High-risk signals always win over small keywords.
+ * supervised / explicit high governance never selects small topology.
+ */
+export function classifyFrontendRisk(input) {
+    const blob = blobOf(input);
+    const signals = [];
+    const rejectedSignals = [];
+    const profile = (input.governanceProfile ?? "").toLowerCase();
+    const supervised = profile === "supervised" ||
+        profile.includes("supervised") ||
+        /\bsupervised\b/i.test(blob);
+    for (const pattern of HIGH_RISK_PATTERNS) {
+        if (pattern.re.test(blob))
+            signals.push(pattern.id);
+    }
+    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");
+    }
+    // Explicit multi-domain language only — path count alone is not high-risk
+    if (spread >= 3 &&
+        /\b(多个领域|cross-module|multiple\s+packages)\b/i.test(blob)) {
+        signals.push("cross-domain-paths");
+    }
+    const highRisk = signals.length > 0;
+    const smallHits = [];
+    for (const pattern of SMALL_PATTERNS) {
+        if (pattern.re.test(blob))
+            smallHits.push(pattern.id);
+    }
+    // small only if: no high-risk, paths concentrated, no remote API signals, not supervised
+    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
+        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+    const concentrated = pathSpreadScore(paths) <= 1 && paths.length <= 4;
+    if (supervised) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-supervised`));
+        return {
+            selectedRisk: highRisk ? "high-risk" : "standard",
+            signals: supervised ? [...signals, "supervised-profile"] : signals,
+            rejectedSignals,
+            reason: highRisk
+                ? `high-risk signals present under supervised: ${signals.join(", ")}`
+                : "supervised profile forces full gates (standard minimum)",
+            forceFullGates: true,
+        };
+    }
+    if (highRisk) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-high-risk`));
+        return {
+            selectedRisk: "high-risk",
+            signals,
+            rejectedSignals,
+            reason: `high-risk signals: ${[...new Set(signals)].join(", ")}`,
+            forceFullGates: true,
+        };
+    }
+    if (smallHits.length > 0 &&
+        concentrated &&
+        !hasApiSignal &&
+        (input.complexity === "small" || smallHits.length >= 1)) {
+        return {
+            selectedRisk: "small",
+            signals: smallHits,
+            rejectedSignals,
+            reason: `small signals without high-risk: ${smallHits.join(", ")}`,
+            forceFullGates: false,
+        };
+    }
+    if (smallHits.length > 0 && (hasApiSignal || !concentrated)) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-${hasApiSignal ? "api-signal" : "path-spread"}`));
+        return {
+            selectedRisk: "standard",
+            signals: smallHits,
+            rejectedSignals,
+            reason: hasApiSignal
+                ? "small keywords present but API/remote signals require standard topology"
+                : "small keywords present but path spread requires standard topology",
+            forceFullGates: false,
+        };
+    }
+    return {
+        selectedRisk: "standard",
+        signals: ["default-standard"],
+        rejectedSignals,
+        reason: "ambiguous or standard frontend work; default standard topology",
+        forceFullGates: false,
+    };
+}

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

@@ -0,0 +1,343 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { isPlaywrightCliCommand } from "../../shared/playwright-cli-command-policy.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_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;
+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]*)/;
+const ENV_WRAPPER = /^env(?:\s+(?:-[A-Za-z]+|--[A-Za-z][A-Za-z-]*))*\s+/i;
+const SHELL_BUILTIN_WRAPPER = /^(?:command|exec|sudo)\s+/i;
+const PLAYWRIGHT_API = /^(?:from\s+playwright(?:\.[A-Za-z_][A-Za-z0-9_]*)*\s+import\b|import\s+playwright(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\s+as\s+[A-Za-z_][A-Za-z0-9_]*)?\b|import\s+.+\s+from\s+["'](?:playwright|@playwright\/test)["']|(?:const|let|var)\s+.+\brequire\s*\(\s*["'](?:playwright|@playwright\/test)["']\s*\)|require\s*\(\s*["'](?:playwright|@playwright\/test)["']\s*\)|(?:sync_playwright|async_playwright|chromium|firefox|webkit)\.(?:launch|connect)\b)/i;
+async function exists(file) {
+    try {
+        return (await stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeCommand(value) {
+    const trimmed = value.trim().replace(/^[$>]\s*/, "");
+    const wrapped = trimmed.match(/^`([^`]+)`$/);
+    return (wrapped?.[1] ?? trimmed).trim();
+}
+function isExecutableFence(language) {
+    return COMMAND_FENCE_LANGUAGE.test(language.trim());
+}
+function isBlockedReason(value) {
+    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();
+    let consumed = true;
+    while (remaining && consumed) {
+        consumed = false;
+        const assignment = remaining.match(ENV_ASSIGNMENT);
+        if (assignment) {
+            remaining = remaining.slice(assignment[0].length).trimStart();
+            consumed = true;
+            continue;
+        }
+        const env = remaining.match(ENV_WRAPPER);
+        if (env) {
+            remaining = remaining.slice(env[0].length).trimStart();
+            consumed = true;
+            continue;
+        }
+        const wrapper = remaining.match(SHELL_BUILTIN_WRAPPER);
+        if (wrapper) {
+            remaining = remaining.slice(wrapper[0].length).trimStart();
+            consumed = true;
+        }
+    }
+    return remaining;
+}
+function isCommandLikeExecutable(command) {
+    const executable = stripLeadingCommandWrappers(command);
+    return AUTOMATION_EXECUTABLE.test(executable) || SHELL_WRAPPED_EXECUTABLE.test(executable) || PLAYWRIGHT_API.test(executable);
+}
+function executableListStep(value) {
+    const trimmed = value.trim();
+    if (isNonExecutableBlockedProse(trimmed))
+        return null;
+    const explicit = trimmed.match(EXPLICIT_COMMAND);
+    if (explicit) {
+        if (isBlockedReason(explicit[1]) || isNonExecutableBlockedProse(explicit[1]))
+            return null;
+        return normalizeCommand(explicit[1]);
+    }
+    const imperative = trimmed.match(IMPERATIVE_COMMAND);
+    if (imperative) {
+        if (isNonExecutableBlockedProse(imperative[1]))
+            return null;
+        return normalizeCommand(imperative[1]);
+    }
+    const inlineCode = trimmed.match(INLINE_CODE_STEP);
+    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;
+}
+function hasShellControl(command) {
+    let quote = null;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index];
+        if (character === "\\" && quote !== "'") {
+            index += 1;
+            continue;
+        }
+        if (quote !== null) {
+            if (character === quote)
+                quote = null;
+            else if (quote === '"' && (character === "`" || (character === "$" && command[index + 1] === "(")))
+                return true;
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+            continue;
+        }
+        if (character === "#" && (index === 0 || /\s/.test(command[index - 1])))
+            break;
+        if (character === "`" || character === ";" || character === "|" || character === "&" || character === "<" || character === ">")
+            return true;
+        if (character === "$" && command[index + 1] === "(")
+            return true;
+    }
+    return false;
+}
+/**
+ * Return only Markdown lines that are presented as commands. Prose can mention
+ * forbidden commands as a blocked reason without becoming an executable step.
+ */
+function extractExecutableInstructions(markdown) {
+    const instructions = [];
+    let fenceLanguage = null;
+    for (const [index, line] of markdown.split(/\r?\n/).entries()) {
+        const lineNumber = index + 1;
+        const fence = line.match(/^\s*```([^`]*)$/);
+        if (fence) {
+            fenceLanguage = fenceLanguage === null ? fence[1].trim() : null;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (fenceLanguage !== null) {
+            if (!isExecutableFence(fenceLanguage) || /^(?:#|\/\/)/.test(trimmed))
+                continue;
+            // 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]) || isNonExecutableBlockedProse(listed[1]))
+                continue;
+            const command = executableListStep(listed[1]);
+            if (command !== null)
+                instructions.push({ command, lineNumber });
+            continue;
+        }
+        const indented = line.match(INDENTED_CODE);
+        if (indented) {
+            if (isBlockedReason(indented[1]) || isNonExecutableBlockedProse(indented[1]))
+                continue;
+            const explicitIndented = indented[1].match(EXPLICIT_COMMAND);
+            if (explicitIndented && (isBlockedReason(explicitIndented[1]) || isNonExecutableBlockedProse(explicitIndented[1])))
+                continue;
+            const fromStep = executableListStep(indented[1]);
+            if (fromStep === null)
+                continue;
+            instructions.push({ command: fromStep, lineNumber });
+            continue;
+        }
+        const explicit = trimmed.match(EXPLICIT_COMMAND);
+        if (explicit) {
+            if (isBlockedReason(explicit[1]) || isNonExecutableBlockedProse(explicit[1]))
+                continue;
+            instructions.push({ command: normalizeCommand(explicit[1]), lineNumber });
+            continue;
+        }
+        const command = executableListStep(trimmed);
+        if (command !== null)
+            instructions.push({ command, lineNumber });
+    }
+    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().replace(/^[`'"]+|[`'":,，。→]+$/g, "");
+        if (isPlaywrightCliCommand(command) && !hasShellControl(input.instruction.command))
+            return null;
+        if (isPlaywrightCliCommand(command)) {
+            return {
+                ruleId: "alternative-executable-command",
+                caseId: input.caseId,
+                casePath: input.casePath,
+                lineNumber: input.instruction.lineNumber,
+                command: input.instruction.command,
+                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,
+            casePath: input.casePath,
+            lineNumber: input.instruction.lineNumber,
+            command: input.instruction.command,
+            detail: `playwright-cli command is not allowlisted: ${command}`,
+        };
+    }
+    return {
+        ruleId: "alternative-executable-command",
+        caseId: input.caseId,
+        casePath: input.casePath,
+        lineNumber: input.instruction.lineNumber,
+        command: input.instruction.command,
+        detail: "only allowlisted playwright-cli commands may appear in executable case instructions",
+    };
+}
+export async function validateFrontendCaseChecklist(input) {
+    const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
+    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"));
+    if (!Array.isArray(manifest.cases) || manifest.cases.length === 0)
+        throw new Error("checklist: empty cases");
+    const declaredAc = new Set(input.declaredAcIds ?? []);
+    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+https?:\/\/\S+/i;
+    const productionHostRe = /(^|[.-])(prod|production)([.-]|$)/i;
+    for (const raw of manifest.cases) {
+        const item = raw;
+        const id = typeof item?.caseId === "string" ? item.caseId : "?";
+        if (typeof item?.caseId !== "string" || !caseIdRe.test(item.caseId))
+            issues.push({ ruleId: "case-id-shape", caseId: id, detail: "caseId must be FE-<FEATURE>-<NNN>-<dimension>, never AC-FE-*" });
+        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 absolute = path.resolve(input.workspaceRoot, casePath);
+        const relative = path.relative(input.workspaceRoot, absolute);
+        if (!casePath || relative.startsWith("..") || path.isAbsolute(relative) || !(await exists(absolute))) {
+            issues.push({ ruleId: "case-file-missing", caseId: id, casePath: casePath || undefined, detail: casePath || "missing casePath" });
+            continue;
+        }
+        if (expectedPath && casePath.replaceAll("\\", "/") !== expectedPath)
+            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 <absolute-url>" });
+        const match = body.match(/playwright-cli\s+open\s+--browser=chrome\s+(https?:\/\/\S+)/i);
+        if (match) {
+            try {
+                const url = new URL(match[1].replace(/[)\]},.\"'`]+$/, ""));
+                if (productionHostRe.test(url.hostname))
+                    issues.push({ ruleId: "production-url", caseId: id, casePath, detail: match[1] });
+            }
+            catch {
+                issues.push({ ruleId: "production-url", caseId: id, casePath, detail: match[1] });
+            }
+        }
+        for (const instruction of extractExecutableInstructions(body)) {
+            const issue = commandGateIssue({ caseId: id, casePath, instruction });
+            if (issue)
+                issues.push(issue);
+        }
+        if (!Array.isArray(item?.acIds) || item.acIds.length === 0) {
+            issues.push({ ruleId: "ac-mapping", caseId: id, casePath, detail: "acIds required" });
+        }
+        else {
+            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 && !declaredAc.has(ac))
+                    issues.push({ ruleId: "unknown-ac", caseId: id, casePath, detail: `${ac} not in sourceBinding` });
+            }
+        }
+    }
+    return { caseCount: manifest.cases.length, manifestPath, issues };
+}

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 DIMENSION_SHAPE = /^[a-z][a-z0-9-]{0,31}$/;
+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 ?? 50;
+    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" || !DIMENSION_SHAPE.test(c.dimension))
+            fail("invalid-dimension", `dimension must be kebab-case [a-z][a-z0-9-]{0,31}, got: ${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 };
+}