@tea-agent/loop-agent 0.39.0-beta.5 → 0.39.0-beta.7

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -12,7 +12,7 @@ import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 // Cycle-safe value imports: the check functions are hoisted declarations used
 // only at call time, so the contract module and the policy module can depend
 // on each other without module-init ordering issues.
-import { checkDependencies, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
+import { checkDependencies, checkTargetPaths, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
 import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, persistRuntimeSkeleton, } from "./structured-output-repair.js";
 import { isConfigurationVerificationFile, verificationSymbolMatchesContent, } from "./frontend-verification-trace.js";
 export const frontendNormalizationActionSchema = z.enum([
@@ -142,6 +142,35 @@ async function deriveAllowedDependenciesFromRun(runDir) {
     }
     return [...deps];
 }
+/** Read the frozen implementation writeSet patterns from run.json so the plan
+ * validator can front-load checkTargetPaths (write-set-too-large) before the
+ * design-policy shell terminates the run. */
+async function deriveWriteSetFromRun(runDir) {
+    const specPath = path.join(runDir, "run.json");
+    let raw;
+    try {
+        raw = await readFile(specPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    let spec;
+    try {
+        spec = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const writeSet = new Set();
+    for (const task of spec.tasks ?? []) {
+        const patterns = task.shell?.frontendDesignPolicy?.implementationWriteSet;
+        if (patterns) {
+            for (const pattern of patterns)
+                writeSet.add(pattern);
+        }
+    }
+    return [...writeSet];
+}
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_PLAN_PATCH_SCHEMA_ID = "frontend-implementation-contract-plan-patch-v1";
 /**
@@ -278,7 +307,10 @@ const uiComponentChoiceSchema = z
     component: z.string().min(1),
     decision: z.enum(["specified", "reuse-existing", "new"]),
     specReference: uiComponentSpecReferenceSchema.nullable().optional(),
-    rationale: z.string().min(1),
+    // Optional: the decision enum already carries the semantic (specified →
+    // specReference, new → deviation, reuse-existing → no rationale needed).
+    // Omit for reuse-existing to keep plan output small.
+    rationale: z.string().min(1).optional(),
 })
     .strict();
 const uiComponentChoicesSchema = z.array(uiComponentChoiceSchema);
@@ -306,8 +338,50 @@ function stripNullValuesDeep(value) {
     }
     return value;
 }
+/**
+ * Normalize a model-emitted `uiComponentChoices` where a `new` choice carries a
+ * degenerate empty `specReference` object (`{ path: "", section: "", line:
+ * null }`) instead of the required `null`. The model intent is unambiguous
+ * (new components must not carry a specReference; the empty object is a format
+ * slip, not a real spec hit), so dropping the empty object before validation
+ * avoids a full plan retry on an otherwise-correct emission. A `specReference`
+ * with a non-empty `path` is preserved (it is a genuine `specified` hit).
+ */
+export function normalizeNewComponentSpecReference(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((item) => {
+        if (!item || typeof item !== "object")
+            return item;
+        const record = item;
+        if (record.decision !== "new")
+            return item;
+        const ref = record.specReference;
+        if (!ref || typeof ref !== "object")
+            return item;
+        const refRecord = ref;
+        const path = typeof refRecord.path === "string" ? refRecord.path.trim() : "";
+        if (path.length > 0)
+            return item;
+        // Empty/degenerate specReference on a new choice → absent (null intent).
+        const { specReference: _dropped, ...rest } = record;
+        return rest;
+    });
+}
 export const frontendImplementationContractSchema = z
-    .preprocess(stripNullValuesDeep, z
+    .preprocess((value) => {
+    const record = asRecord(value);
+    if (!record)
+        return stripNullValuesDeep(value);
+    return stripNullValuesDeep({
+        ...record,
+        ...(record.uiComponentChoices !== undefined
+            ? {
+                uiComponentChoices: normalizeNewComponentSpecReference(record.uiComponentChoices),
+            }
+            : {}),
+    });
+}, z
     .object({
     schemaVersion: z.literal(1),
     sourceBinding: z
@@ -1971,6 +2045,7 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             ...checkUiDesignCoverage(analysis.canonical),
             ...checkUiStateAttribution(analysis.canonical),
             ...checkDependencies(analysis.canonical, await deriveAllowedDependenciesFromRun(input.runDir)),
+            ...checkTargetPaths(analysis.canonical, await deriveWriteSetFromRun(input.runDir)),
         ];
         if (policyPreFindings.length > 0)
             throw new Error(`frontend plan policy pre-check failed (fix these plan facts, then re-commit and finalize): ${policyPreFindings

package/dist/workflows/dag/frontend-review-findings.js

@@ -0,0 +1,238 @@
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readTypedEventStoreFromJsonl, } from "./frontend-typed-event-store.js";
+/**
+ * Frontend review findings → downstream work (direction A).
+ *
+ * When `frontend-review-pi` commits `request_review_changes`, the implementation
+ * must not silently finish: the run becomes "not passed" (partial_failed +
+ * terminalReason=review-request-changes), and the committed findings are
+ * rendered into a downstream-task PRD draft that a later DAG round can consume
+ * instead of repeating the previous flow. Rendering is deterministic (pure);
+ * only the JSONL read and PRD write are IO.
+ */
+export const FRONTEND_REVIEW_FINDINGS_PRD_REL = "contracts/frontend-review-findings-prd.md";
+/** Review node id whose committed typed facts drive the findings PRD. */
+export const FRONTEND_REVIEW_NODE_ID = "frontend-review-pi";
+/** Deterministic issueCategory → failure owner mapping (A+B AC-009 §4.10). */
+export function classifyReviewIssueCategoryFailureOwner(issueCategory) {
+    switch (issueCategory) {
+        case "implementation-mismatch":
+            return "implementation";
+        case "approved-design-defect":
+            return "plan";
+        case "target-surface-defect":
+            return "scout";
+        case "contract-requirement-gap":
+            return "contract";
+        case "unknown":
+        default:
+            return "unknown";
+    }
+}
+const API_SIGNAL_RE = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i;
+/** Negations for the API signal. CJK "无 API/无接口" has no \b boundary, so
+ * it is matched separately from the ASCII no api/not-needed forms. */
+const API_NEGATION_RE = /(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])|无\s*api|无\s*接口/i;
+const SMALL_SIGNAL_WORDS = [
+    "单文件局部修复",
+    "局部样式",
+    "文案调整",
+    "无远程接口",
+];
+function topLevelDir(p) {
+    const normalized = p.replace(/\\/g, "/");
+    const first = normalized.split("/").filter(Boolean)[0] ?? "";
+    return first;
+}
+/** Collect unique non-empty finding `file` values (sorted, de-duplicated). */
+function findingTargetFiles(fact) {
+    const files = new Set();
+    for (const finding of fact.findings) {
+        if (typeof finding.file === "string" && finding.file.trim()) {
+            files.add(finding.file.trim());
+        }
+    }
+    return [...files].sort();
+}
+/**
+ * Deterministically derive the fix scope for the downstream task. Same fact
+ * always yields the same scope. The shape mirrors `resolveFrontendTaskShape`
+ * signals (concentrated paths, no remote API → micro/small) so that when the
+ * PRD draft is used as the next task's requirement, the frontend DAG generator
+ * routes a small fix to micro/small instead of the full 11-node standard
+ * topology.
+ */
+export function deriveFrontendReviewFixScope(fact) {
+    const targetFiles = findingTargetFiles(fact);
+    const blob = fact.findings
+        .map((f) => `${f.issue} ${f.requiredChange ?? ""} ${f.file ?? ""}`)
+        .join("\n");
+    const hasApiSignal = API_SIGNAL_RE.test(blob) && !API_NEGATION_RE.test(blob);
+    const topDirs = new Set(targetFiles.map(topLevelDir));
+    const concentrated = targetFiles.length > 0 && topDirs.size <= 1 && targetFiles.length <= 4;
+    let shape;
+    let complexity;
+    let reason;
+    if (targetFiles.length === 0) {
+        shape = "standard";
+        complexity = "medium";
+        reason =
+            "findings carry no file references; scope unknown, keep standard topology";
+    }
+    else if (hasApiSignal) {
+        shape = "standard";
+        complexity = "medium";
+        reason = `findings reference a remote API signal; standard topology required (files=${targetFiles.length})`;
+    }
+    else if (concentrated && targetFiles.length <= 1) {
+        shape = "micro";
+        complexity = "trivial";
+        reason = "single-file concentrated fix without remote API";
+    }
+    else if (concentrated) {
+        shape = "small";
+        complexity = "low";
+        reason = `concentrated fix across ${targetFiles.length} file(s) in one top-level directory`;
+    }
+    else {
+        shape = "standard";
+        complexity = "medium";
+        reason = `fix spans ${targetFiles.length} file(s) across ${topDirs.size} top-level directories; standard topology`;
+    }
+    const allowedPaths = [
+        ...new Set([
+            ...targetFiles,
+            ...targetFiles.map((f) => `${topLevelDir(f)}/**`),
+        ]),
+    ].sort();
+    return {
+        shape,
+        complexity,
+        targetFiles,
+        allowedPaths,
+        smallSignals: [...SMALL_SIGNAL_WORDS],
+        hasApiSignal,
+        reason,
+    };
+}
+/**
+ * Read the committed `request_review_changes` fact from the review node's typed
+ * event store. Returns undefined when no committed request fact exists (e.g.
+ * approve_review, missing store, or an unreadable store).
+ */
+export async function readCommittedReviewRequestFact(input) {
+    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    let records;
+    try {
+        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, reviewNodeId, "review-typed-facts.jsonl"));
+    }
+    catch {
+        return undefined;
+    }
+    const committed = records.filter((record) => record.phase === "committed");
+    if (committed.length === 0)
+        return undefined;
+    // A committed approve_review means the review passed; only a committed
+    // request_review_changes carries a "not passed" verdict.
+    const request = committed.find((record) => record.fact.kind === "request_review_changes");
+    if (!request)
+        return undefined;
+    const fact = request.fact;
+    if (typeof fact !== "object" || fact === null)
+        return undefined;
+    return fact;
+}
+function bulletList(items) {
+    if (!items || items.length === 0)
+        return "_(none)_";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function findingLines(findings) {
+    if (findings.length === 0)
+        return "_(none)_";
+    return findings
+        .map((finding) => {
+        const location = [finding.file, finding.line]
+            .filter((value) => value !== undefined)
+            .join(":");
+        const prefix = location ? `[${location}] ` : "";
+        const requiredChange = finding.requiredChange
+            ? `\n  - requiredChange: ${finding.requiredChange}`
+            : "";
+        return `- ${prefix}${finding.severity}: ${finding.issue}${requiredChange}`;
+    })
+        .join("\n");
+}
+/**
+ * Deterministically render a downstream-task PRD draft from a committed
+ * `request_review_changes` fact. Same fact always renders byte-identical
+ * output; the parent run id and review node id are the only context.
+ */
+export function renderFrontendReviewFindingsPrd(input) {
+    const { parentRunId, fact } = input;
+    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    const restartPhase = classifyReviewIssueCategoryFailureOwner(fact.issueCategory);
+    const scope = deriveFrontendReviewFixScope(fact);
+    const targetSummary = scope.targetFiles.length > 0
+        ? scope.targetFiles.join(", ")
+        : fact.issueCategory;
+    return [
+        `# 修复 review 发现（${scope.shape}）：${targetSummary}`,
+        "",
+        "## 背景",
+        "",
+        `- parentRunId: \`${parentRunId}\``,
+        `- reviewNodeId: \`${reviewNodeId}\``,
+        `- typedVerdict: \`request_review_changes\``,
+        `- issueCategory: \`${fact.issueCategory}\``,
+        `- restartPhase/failureOwner: \`${restartPhase}\``,
+        "",
+        "## 修复范围（供下一轮任务生成路由）",
+        "",
+        `- 建议 shape：\`${scope.shape}\`（micro=7 / small=10 / standard=11 节点）`,
+        `- 建议 complexity：\`${scope.complexity}\``,
+        `- 推导依据：${scope.reason}`,
+        ...(scope.hasApiSignal ? ["- ⚠️ findings 含远程 API/接口信号，走 standard 拓扑"] : []),
+        scope.targetFiles.length > 0
+            ? [`- 目标文件：${scope.targetFiles.map((f) => `\`${f}\``).join(", ")}`]
+            : ["- 目标文件：_(findings 未提供 file 引用，需人工补全)_"],
+        scope.allowedPaths.length > 0
+            ? [`- 建议 allowedPaths：${scope.allowedPaths.map((p) => `\`${p}\``).join(", ")}`]
+            : [],
+        scope.shape === "micro" || scope.shape === "small"
+            ? [`- 范围信号：${scope.smallSignals.join("、")}（供 shape 分类器识别，避免退化为全节点流程）`]
+            : [],
+        "",
+        "## 问题清单",
+        "",
+        findingLines(fact.findings),
+        "",
+        "## 证据引用",
+        "",
+        bulletList(fact.evidenceRefs),
+        "",
+        "## 修复目标",
+        "",
+        `- 按 issueCategory 映射的重启阶段（${restartPhase}）定点修复，不复用上一轮未通过的实现。`,
+        "- 逐条关闭上面「问题清单」中的 findings，并保留上一轮已通过的验证目标继续有效。",
+        "- 完成修复后重新走 frontend DAG 的 implement → verify → review 链，直到 review 提交 approve_review。",
+        "",
+    ].join("\n");
+}
+/** Write the findings PRD draft under the run dir (run-owned artifact). */
+export async function writeFrontendReviewFindingsPrd(input) {
+    const markdown = renderFrontendReviewFindingsPrd(input);
+    const abs = path.join(input.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, markdown, "utf8");
+    return FRONTEND_REVIEW_FINDINGS_PRD_REL;
+}
+export async function readFrontendReviewFindingsPrd(runDir) {
+    try {
+        return await readFile(path.join(runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -291,15 +291,17 @@ export function assemblePlanPatchFromCommittedFacts(records) {
         if (routes.length > 0)
             patch.targets = { routes };
     }
-    const componentChoice = facts.find((fact) => fact.kind === "component-choice");
-    if (componentChoice) {
-        if (Array.isArray(componentChoice.uiComponentChoices)) {
-            patch.uiComponentChoices = componentChoice.uiComponentChoices.filter(isRecord);
-        }
-        const stylingStrategy = asString(componentChoice.stylingStrategy);
-        if (stylingStrategy)
-            patch.stylingStrategy = stylingStrategy;
-    }
+    const componentChoices = facts.filter((fact) => fact.kind === "component-choice");
+    const collectedChoices = componentChoices.flatMap((fact) => Array.isArray(fact.uiComponentChoices)
+        ? fact.uiComponentChoices.filter(isRecord)
+        : []);
+    const stylingStrategy = componentChoices
+        .map((fact) => asString(fact.stylingStrategy))
+        .find((value) => value.length > 0);
+    if (collectedChoices.length > 0)
+        patch.uiComponentChoices = collectedChoices;
+    if (stylingStrategy)
+        patch.stylingStrategy = stylingStrategy;
     const stateFlow = facts.find((fact) => fact.kind === "state-flow");
     if (stateFlow) {
         if (Array.isArray(stateFlow.uiStates)) {
@@ -330,7 +332,19 @@ export function assemblePlanPatchFromCommittedFacts(records) {
     const requirements = facts
         .filter((fact) => fact.kind === "plan-requirement")
         .map((fact) => fact.entry)
-        .filter(isRecord);
+        .filter(isRecord)
+        .map((entry) => {
+        // The canonical contract schema requires a non-empty
+        // expectedOutcome, but the plan should not be forced to re-write
+        // full outcome prose for every requirement (the contract node
+        // already captured requirement semantics). Derive a deterministic
+        // placeholder from the requirement id when omitted.
+        if (isRecord(entry) && !asString(entry.expectedOutcome)) {
+            const id = asString(entry.id) || "requirement";
+            return { ...entry, expectedOutcome: `implied by contract: ${id}` };
+        }
+        return entry;
+    });
     if (requirements.length > 0)
         patch.requirements = requirements;
     const verificationTargets = facts

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

@@ -29,7 +29,7 @@ const SHAPE_ESCALATION_PATTERNS = [
 ];
 const SHAPE_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 },
+    { id: "no-remote", re: /no\s+api|无\s*api|无\s*接口|本地状态|local\s+state\s+only|pure\s+ui/i },
 ];
 const SHAPE_SPLIT_REQUIRED_PATTERN = /拆分|split\s+(?:requirement|task|需求)|large\s+requirement|大型需求|多步骤需求/i;
 const EXECUTABLE_SHAPE_RANK = {
@@ -77,7 +77,8 @@ function resolveBaselineFrontendTaskShape(input) {
     const spread = pathSpreadScore(paths);
     const concentrated = spread <= 1 && paths.length <= 4;
     const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
+            /无\s*api|无\s*接口/i.test(blob));
     const complexity = (input.complexity ?? "").toLowerCase();
     // split-required wins over everything: it is a termination/escalation
     // signal, not an executable topology.
@@ -258,7 +259,8 @@ export function deriveFrontendRuntimeShapeFacts(input) {
     const escalationSignals = collectEscalationSignals(blob, supervised);
     const paths = input.allowedPaths ?? [];
     const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
+            /无\s*api|无\s*接口/i.test(blob));
     const requiresFull = escalationSignals.length > 0 || pathSpreadScore(paths) > 1 || hasApiSignal;
     return {
         splitRequired: input.splitRequired,

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

@@ -2,6 +2,7 @@ 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.*)$/;
@@ -290,7 +291,8 @@ 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 : "";
@@ -319,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))) {

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

@@ -1,6 +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 ?? "") });
@@ -19,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 ?? []);
@@ -71,8 +73,8 @@ export async function materializeFrontendTestCaseManifest(input) {
                 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,6 +1,7 @@
 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;
@@ -15,7 +16,8 @@ const SECTION_ALIASES = {
 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;
@@ -49,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");
@@ -89,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

@@ -1,6 +1,7 @@
 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 续跑。";
@@ -65,9 +66,9 @@ function resolveBaseUrl(context) {
     }
     return null;
 }
-async function writeProbe(workspaceRoot, probe) {
-    const probePath = path.join(workspaceRoot, FRONTEND_TEST_PROBE_REL);
-    const contextPath = path.join(workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+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 = "";
@@ -84,14 +85,16 @@ async function writeProbe(workspaceRoot, probe) {
     await writeFile(contextPath, next, "utf8");
 }
 export async function probeFrontendTestEnvironment(input) {
+    const layout = input.layout ?? defaultFrontendTestLayout();
     const curl = input.curl ?? defaultCurlRunner;
-    const contextPath = path.join(input.workspaceRoot, FRONTEND_TEST_CONTEXT_REL);
+    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 ${FRONTEND_TEST_CONTEXT_REL}` };
+        return { ok: false, stderr: `missing ${contextRel}` };
     }
     const rawUrl = resolveBaseUrl(context);
     if (!rawUrl) {
@@ -139,7 +142,7 @@ export async function probeFrontendTestEnvironment(input) {
             ...(extra.hint ? { hint: extra.hint } : {}),
             ...(extra.baseUrlSource ? { baseUrlSource: extra.baseUrlSource } : {}),
         };
-        await writeProbe(input.workspaceRoot, probe);
+        await writeProbe(input.workspaceRoot, probe, layout);
         const payload = {
             blockedReason: reason,
             baseUrl: probe.baseUrlRedacted,
@@ -218,7 +221,7 @@ export async function probeFrontendTestEnvironment(input) {
         curlExit: result.status,
         errorClass: null,
     };
-    await writeProbe(input.workspaceRoot, probe);
+    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}`,

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));