@tea-agent/loop-agent 0.21.0 → 0.23.1

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

@@ -34,15 +34,17 @@ export function isFrontendRepairable(failureClass) {
 }
 export function classifyFrontendFailure(input) {
     const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
+    const failureDiagnosticBlob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
     if (input.nodeId.includes("contract") ||
         blob.includes("contract mismatch") ||
         blob.includes("source binding")) {
         return "contract";
     }
-    if (blob.includes("forbidden") ||
-        blob.includes("write guard") ||
-        blob.includes("write-set") ||
-        blob.includes("writeset")) {
+    if (input.failureCategory === "write-guard" ||
+        failureDiagnosticBlob.includes("forbidden") ||
+        failureDiagnosticBlob.includes("write guard") ||
+        failureDiagnosticBlob.includes("write-set") ||
+        failureDiagnosticBlob.includes("writeset")) {
         return "path";
     }
     if (blob.includes("package.json") ||

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

@@ -2,6 +2,9 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "./frontend-worktree-diff.js";
+import { frontendLintAssessmentArtifactSchema } from "./frontend-lint-baseline.js";
+import { frontendImplementationContractSchema } from "./frontend-implementation-contract.js";
+import { frontendRepairAssessmentSchema } from "./frontend-repair.js";
 export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v1";
 async function readRequiredJson(runDir, relativePath) {
     try {
@@ -11,17 +14,81 @@ async function readRequiredJson(runDir, relativePath) {
         throw new Error(`frontend review context missing or invalid ${relativePath}`);
     }
 }
+async function readOptionalLintAssessment(runDir) {
+    const relativePath = "contracts/frontend-lint-assessment.json";
+    try {
+        const decoded = JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
+        return frontendLintAssessmentArtifactSchema.parse(decoded);
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        throw new Error(`frontend review context invalid ${relativePath}`);
+    }
+}
+function assertReviewEvidence(input) {
+    const contract = frontendImplementationContractSchema.safeParse(input.contract);
+    if (!contract.success)
+        throw new Error("frontend review context invalid implementation contract");
+    const trace = input.verificationTrace;
+    const expectedTargets = new Map(contract.data.verificationTargets.map((target) => [target.id, target]));
+    const actualTargets = Array.isArray(trace?.targets) ? trace.targets : [];
+    const mockEvidenceBound = contract.data.mockApi.strategy === "not-needed" ||
+        (typeof trace?.mockCommandNodeId === "string" && trace.mockCommandNodeId.length > 0 &&
+            Array.isArray(trace?.mockCommandLabels) && trace.mockCommandLabels.length > 0 &&
+            Array.isArray(trace?.mockCommandTexts) && trace.mockCommandTexts.length === trace.mockCommandLabels.length &&
+            trace.mockCommandTexts.every((command) => typeof command === "string" && command.length > 0));
+    const actualIds = new Set();
+    const targetsMatch = actualTargets.every((rawTarget) => {
+        if (!rawTarget || typeof rawTarget !== "object")
+            return false;
+        const target = rawTarget;
+        const id = typeof target.id === "string" ? target.id : "";
+        const expected = expectedTargets.get(id);
+        if (!expected || actualIds.has(id))
+            return false;
+        actualIds.add(id);
+        return target.commandLabel === expected.commandLabel &&
+            target.file === expected.file &&
+            target.symbol === expected.symbol &&
+            Array.isArray(target.matchedNodeIds) && target.matchedNodeIds.length > 0;
+    });
+    if (!trace ||
+        trace.schemaId !== "frontend-verification-trace-v1" ||
+        trace.contractSchemaId !== "frontend-implementation-contract-v1" ||
+        trace.browserStatus !== "not-run" ||
+        trace.visualStatus !== "not-run" ||
+        !Array.isArray(trace.targets) ||
+        trace.targets.length === 0 ||
+        trace.targets.some((target) => target?.status !== "ok") ||
+        !targetsMatch ||
+        actualIds.size !== expectedTargets.size ||
+        !mockEvidenceBound ||
+        trace.mockStrategy !== contract.data.mockApi.strategy) {
+        throw new Error("frontend review context verification trace is not bound to a passing contract");
+    }
+    const assessment = frontendRepairAssessmentSchema.safeParse(input.repairAssessment);
+    if (!assessment.success)
+        throw new Error("frontend review context invalid repair assessment");
+}
 export async function runFrontendReviewContextGate(input) {
     const diff = await runFrontendWorktreeDiffGate(input);
     const contract = await readRequiredJson(input.runDir, "contracts/frontend-implementation-contract.json");
     const verificationTrace = await readRequiredJson(input.runDir, "contracts/frontend-verification-trace.json");
     const repairAssessment = await readRequiredJson(input.runDir, "contracts/frontend-repair-assessment.json");
+    const lintAssessment = await readOptionalLintAssessment(input.runDir);
+    assertReviewEvidence({ contract, verificationTrace, repairAssessment });
     const payload = {
         schemaVersion: 1,
         schemaId: FRONTEND_REVIEW_CONTEXT_SCHEMA_ID,
         contract,
         verificationTrace,
         repairAssessment,
+        ...(lintAssessment ? { lintAssessment } : {}),
         diff: {
             schemaId: diff.schemaId,
             patchPath: diff.patchPath,

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

@@ -0,0 +1,105 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+const CASE_ID = /^FE-[A-Za-z0-9]+-\d{3}-(?:core|boundary|flow|backend)$/i;
+const AC_ID = /^AC(?:-[A-Z0-9]+)+$/i;
+const PLACEHOLDER = /\b(?:TODO|TBD|FIXME)\b|结果正确|页面正常|按实际情况处理|验证成功/i;
+const SECTION_ALIASES = {
+    purpose: ["Test Purpose", "测试目的", "测试场景"],
+    source: ["Source References", "需求依据"],
+    preconditions: ["Preconditions", "前置条件"],
+    steps: ["Steps", "操作步骤"],
+    expected: ["Expected Results", "预期结果"],
+    automation: ["Automation Notes", "自动化映射", "自动化说明"],
+};
+function section(body, names) {
+    const marker = new RegExp(`^###\\s+(?:${names.map((v) => v.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")).join("|")})\\s*$`, "mi");
+    const hit = marker.exec(body);
+    if (!hit)
+        return "";
+    const rest = body.slice(hit.index + hit[0].length);
+    const next = /^###\s+/m.exec(rest);
+    return rest.slice(0, next?.index ?? rest.length).trim();
+}
+function hasList(value) { return /^\s*(?:\d+[.)]|[-*+])\s+\S+/m.test(value); }
+function hasAssertion(value) { return /(?:status|状态|包含|显示|等于|为|可见|不可见|跳转|错误|成功|失败|should|expect|assert|must)/i.test(value); }
+export async function validateFrontendCaseContent(input) {
+    const root = path.join(input.workspaceRoot, "testcase/frontend/cases");
+    const manifestPath = path.join(root, "manifest.json");
+    const findings = [];
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+    }
+    catch {
+        findings.push({ ruleId: "manifest-unavailable", detail: "manifest.json is missing or invalid" });
+        return render(findings);
+    }
+    if (!Array.isArray(manifest.cases) || manifest.cases.length === 0) {
+        findings.push({ ruleId: "empty-cases", detail: "cases must be a non-empty array" });
+        return render(findings);
+    }
+    const seen = new Set();
+    const covered = new Set();
+    for (const item of manifest.cases) {
+        const id = typeof item?.caseId === "string" ? item.caseId : "?";
+        if (seen.has(id))
+            findings.push({ ruleId: "duplicate-case-id", caseId: id, detail: "caseId is duplicated" });
+        seen.add(id);
+        if (!CASE_ID.test(id))
+            findings.push({ ruleId: "case-id-shape", caseId: id, detail: "caseId must match FE-<FEATURE>-<NNN>-<dimension>" });
+        const acIds = Array.isArray(item?.acIds) ? item.acIds : [];
+        for (const ac of acIds) {
+            if (typeof ac !== "string" || !AC_ID.test(ac))
+                findings.push({ ruleId: "ac-id-shape", caseId: id, detail: `invalid AC id: ${String(ac)}` });
+            else {
+                covered.add(ac);
+                if (input.requiredAcIds?.length && !input.requiredAcIds.includes(ac))
+                    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`);
+        let body = "";
+        try {
+            body = await readFile(file, "utf8");
+        }
+        catch {
+            findings.push({ ruleId: "case-file-missing", caseId: id, detail: `missing case file: ${item?.casePath || file}` });
+            continue;
+        }
+        if (PLACEHOLDER.test(body))
+            findings.push({ ruleId: "placeholder-wording", caseId: id, detail: "case contains placeholder or non-assertable wording" });
+        for (const [key, names] of Object.entries(SECTION_ALIASES))
+            if (!section(body, names))
+                findings.push({ ruleId: `missing-${key}`, caseId: id, detail: `missing section: ${names.join(" or ")}` });
+        const steps = section(body, SECTION_ALIASES.steps), expected = section(body, SECTION_ALIASES.expected);
+        if (!hasList(steps))
+            findings.push({ ruleId: "unstructured-steps", caseId: id, detail: "steps should contain numbered or bulleted executable actions" });
+        if (!hasList(expected) || !hasAssertion(expected))
+            findings.push({ ruleId: "unassertable-expected", caseId: id, detail: "expected results should contain structured, assertable outcomes" });
+        for (const ac of acIds)
+            if (typeof ac === "string" && !body.includes(ac))
+                findings.push({ ruleId: "ac-not-in-case", caseId: id, detail: `${ac} is not explicitly referenced by the case body` });
+        if (acIds.length && !acIds.some((ac) => body.includes(ac) && (steps.includes(ac) || expected.includes(ac))))
+            findings.push({ ruleId: "ac-not-linked-to-verification", caseId: id, detail: "AC is not linked to steps or expected results" });
+    }
+    for (const ac of input.requiredAcIds ?? [])
+        if (!covered.has(ac))
+            findings.push({ ruleId: "missing-ac-coverage", detail: `${ac} is not covered by any frontend case` });
+    return render(findings);
+}
+function render(findings) {
+    const status = findings.length ? "FAIL" : "PASS";
+    const lines = ["# Frontend Test Case Quality Advisory", "", "## Status", "", status, "", `- Findings: ${findings.length}`, "- Enforcement: advisory; findings do not block execution", "", "## Findings", "", ...(findings.length ? findings.map((f) => `- [${f.ruleId}]${f.caseId ? ` ${f.caseId}` : ""}: ${f.detail}`) : ["- None"]), ""];
+    const markdown = lines.join("\n");
+    const esc = (v) => v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+    const html = `<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>前端测试用例质量建议报告</title><style>body{font:16px system-ui,"Microsoft YaHei","PingFang SC",sans-serif;margin:0;padding:2rem;color:#172033;background:#f6f8fb}main{max-width:1100px;margin:auto;background:white;padding:2rem;border-radius:16px;box-shadow:0 8px 28px rgba(23,32,51,.08)}h1{color:#17365d;margin-top:0}.badge{display:inline-block;padding:.35rem .7rem;border-radius:999px;background:${findings.length ? "#fff3cd" : "#ecfdf3"};color:${findings.length ? "#946200" : "#067647"}}li{margin:.7rem 0}code{color:#667085}p{line-height:1.7}</style></head><body><main><h1>前端测试用例质量建议报告</h1><p><span class="badge">${findings.length ? "发现问题" : "检查通过"}</span> <strong>仅供改进</strong>：以下问题属于建议性检查结果，不会阻塞后续测试执行。</p><p>问题数量：${findings.length}</p><h2>建议项明细</h2><ul>${findings.length ? findings.map((f) => `<li><code>${esc(f.ruleId)}</code> ${f.caseId ? `<strong>${esc(f.caseId)}</strong> ` : ""}${esc(f.detail)}</li>`).join("") : "<li>未发现问题。</li>"}</ul></main></body></html>`;
+    return { findings, markdown, html };
+}
+export async function writeFrontendCaseQualityReports(input) {
+    const result = await validateFrontendCaseContent(input);
+    const dir = path.join(input.workspaceRoot, input.outputDir ?? "testcase/frontend/reports");
+    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");
+    return result;
+}

package/dist/workflows/dag/frontend-test-result-contract.js

@@ -3,6 +3,7 @@ import { lstat, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
+import { validateFrontendCaseContent } from "./frontend-test-case-quality.js";
 export const FRONTEND_TEST_RESULT_SCHEMA_ID = "frontend-test-result-v1";
 const safeRelativePathSchema = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
     !path.win32.isAbsolute(value) &&
@@ -33,6 +34,11 @@ export const frontendTestResultContractSchema = z.object({
         evidence: z.array(z.object({ path: safeRelativePathSchema, sha256: sha256Schema }).strict()),
         blockedReason: z.string().min(1).optional(),
     }).strict()).min(1),
+    advisoryFindings: z.array(z.object({
+        ruleId: z.string().min(1),
+        caseId: z.string().min(1).optional(),
+        detail: z.string().min(1),
+    }).strict()),
     totals: z.object({
         cases: z.number().int().positive(),
         passed: z.number().int().min(0),
@@ -79,24 +85,24 @@ async function readEvidenceFile(repoRoot, evidenceRoot, relative) {
     const repoRootResolved = await realpath(repoRoot);
     const evidenceRootResolved = await realpath(evidenceRoot);
     assertInside(repoRootResolved, evidenceRootResolved, "evidenceDir");
-    // Accept either evidence-root-relative paths or repo-relative paths under the case evidence root.
-    const normalized = relative.replaceAll("\\", "/");
+    // Paths rooted at testcase/ are repository-relative; all other safe paths are case-local.
+    const normalized = relative;
     const evidenceRootRel = path.relative(repoRootResolved, evidenceRootResolved).replaceAll("\\", "/");
-    let candidate = normalized;
-    if (normalized === evidenceRootRel || normalized.startsWith(`${evidenceRootRel}/`)) {
-        candidate = path.relative(evidenceRootResolved, path.resolve(repoRootResolved, normalized)).replaceAll("\\", "/");
-    }
-    else if (normalized.startsWith("testcase/frontend/evidence/")) {
-        candidate = path.relative(evidenceRootResolved, path.resolve(repoRootResolved, normalized)).replaceAll("\\", "/");
-    }
-    if (!candidate || candidate.startsWith("..") || path.isAbsolute(candidate)) {
+    const isCurrentCaseRepoPath = normalized === evidenceRootRel || normalized.startsWith(`${evidenceRootRel}/`);
+    const isRepoRelative = normalized.startsWith("testcase/") && !isCurrentCaseRepoPath;
+    const absolute = isRepoRelative
+        ? path.resolve(repoRootResolved, normalized)
+        : path.resolve(evidenceRootResolved, normalized);
+    assertInside(repoRootResolved, absolute, "evidence path");
+    if (isRepoRelative && normalized.startsWith("testcase/frontend/evidence/")) {
         throw new Error(`evidence path escapes evidence root: ${relative}`);
     }
-    const absolute = path.resolve(evidenceRootResolved, candidate);
-    assertInside(evidenceRootResolved, absolute, "evidence path");
+    if (!isRepoRelative)
+        assertInside(evidenceRootResolved, absolute, "evidence path");
     const resolved = await realpath(absolute);
     assertInside(repoRootResolved, resolved, "evidence realpath");
-    assertInside(evidenceRootResolved, resolved, "evidence realpath under case root");
+    if (!isRepoRelative)
+        assertInside(evidenceRootResolved, resolved, "evidence realpath under case root");
     const info = await lstat(resolved);
     if (!info.isFile())
         throw new Error(`evidence is not a file: ${relative}`);
@@ -117,13 +123,20 @@ export async function materializeFrontendTestResult(input) {
     if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.cases) || manifest.cases.length === 0) {
         throw new Error("invalid or empty frontend case manifest");
     }
+    const advisoryFindings = [];
+    const contentQuality = await validateFrontendCaseContent({
+        workspaceRoot: input.workspaceRoot,
+        requiredAcIds: sourceBinding.requirementIds ?? [],
+    });
+    advisoryFindings.push(...contentQuality.findings);
     const requiredIds = new Set(sourceBinding.requirementIds ?? []);
     const covered = new Set();
     const cases = [];
     for (const raw of manifest.cases) {
         const item = raw;
         if (!item || typeof item.caseId !== "string" || !Array.isArray(item.acIds) || typeof item.evidenceDir !== "string") {
-            throw new Error("invalid frontend manifest case");
+            advisoryFindings.push({ ruleId: "invalid-manifest-case", detail: "manifest case is missing caseId, acIds, or evidenceDir" });
+            continue;
         }
         const evidencePrefix = `testcase/frontend/evidence/${item.caseId}`;
         if (!(item.evidenceDir === evidencePrefix || item.evidenceDir.startsWith(`${evidencePrefix}/`))) {
@@ -131,28 +144,43 @@ export async function materializeFrontendTestResult(input) {
         }
         for (const acId of item.acIds) {
             if (requiredIds.size > 0 && !requiredIds.has(acId))
-                throw new Error(`unknown AC in manifest: ${acId}`);
+                advisoryFindings.push({ ruleId: "unknown-ac", caseId: item.caseId, detail: `unknown AC: ${acId}` });
             covered.add(acId);
         }
         const workspaceRootResolved = await realpath(input.workspaceRoot);
         const evidenceRoot = path.resolve(workspaceRootResolved, item.evidenceDir);
         assertInside(workspaceRootResolved, evidenceRoot, "evidenceDir");
-        const resultRaw = JSON.parse(await readFile(path.join(evidenceRoot, "case-result.json"), "utf-8"));
-        const status = caseStatusSchema.parse(resultRaw.status);
-        if (resultRaw.caseId !== item.caseId || !Array.isArray(resultRaw.evidencePaths))
-            throw new Error(`invalid result identity for ${item.caseId}`);
-        if (status === "blocked" && (typeof resultRaw.blockedReason !== "string" || !resultRaw.blockedReason.trim()))
-            throw new Error(`blocked result requires reason for ${item.caseId}`);
-        const evidence = [await readEvidenceFile(input.workspaceRoot, evidenceRoot, "execution.md")];
-        for (const evidencePath of resultRaw.evidencePaths) {
-            if (typeof evidencePath !== "string" || evidencePath === "execution.md")
-                continue;
-            evidence.push(await readEvidenceFile(input.workspaceRoot, evidenceRoot, evidencePath));
+        let resultRaw = {};
+        try {
+            resultRaw = JSON.parse(await readFile(path.join(evidenceRoot, "case-result.json"), "utf-8"));
+        }
+        catch {
+            advisoryFindings.push({ ruleId: "missing-or-invalid-case-result", caseId: item.caseId, detail: "case-result.json is missing or invalid" });
         }
-        if (status === "passed" && !evidence.some((entry) => /\.(png|jpg|jpeg|webp|zip|har|webm|mp4|ya?ml|md)$/i.test(entry.path))) {
-            throw new Error(`passed case requires browser evidence: ${item.caseId}`);
+        const parsedStatus = caseStatusSchema.safeParse(resultRaw.status);
+        const status = parsedStatus.success ? parsedStatus.data : "blocked";
+        if (resultRaw.caseId !== undefined && resultRaw.caseId !== item.caseId)
+            advisoryFindings.push({ ruleId: "case-result-identity", caseId: item.caseId, detail: "case-result caseId does not match manifest" });
+        if (status === "blocked" && resultRaw.blockedReason !== undefined && (typeof resultRaw.blockedReason !== "string" || !resultRaw.blockedReason.trim()))
+            advisoryFindings.push({ ruleId: "blocked-reason", caseId: item.caseId, detail: "blocked result has no usable reason" });
+        const evidence = [];
+        const evidencePaths = Array.isArray(resultRaw.evidencePaths) ? resultRaw.evidencePaths : [];
+        for (const evidencePath of ["execution.md", ...evidencePaths]) {
+            if (typeof evidencePath !== "string" || evidencePath === "execution.md" && evidence.some((entry) => entry.path.endsWith("/execution.md")))
+                continue;
+            try {
+                evidence.push(await readEvidenceFile(input.workspaceRoot, evidenceRoot, evidencePath));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (/unsafe evidence path|escapes (?:evidence root|its allowed root)|evidence realpath/.test(message))
+                    throw error;
+                advisoryFindings.push({ ruleId: "missing-evidence", caseId: item.caseId, detail: `evidence is unavailable: ${evidencePath}` });
+            }
         }
-        cases.push({ caseId: item.caseId, acIds: item.acIds, status, evidence, ...(status === "blocked" ? { blockedReason: resultRaw.blockedReason } : {}) });
+        if (status === "passed" && !evidence.some((entry) => /\.(png|jpg|jpeg|webp|zip|har|webm|mp4|ya?ml|md)$/i.test(entry.path)))
+            advisoryFindings.push({ ruleId: "passed-without-browser-evidence", caseId: item.caseId, detail: "passed case has no browser evidence" });
+        cases.push({ caseId: item.caseId, acIds: item.acIds, status, evidence, ...(status === "blocked" && typeof resultRaw.blockedReason === "string" && resultRaw.blockedReason.trim() ? { blockedReason: resultRaw.blockedReason } : {}) });
     }
     const missing = [...requiredIds].filter((id) => !covered.has(id));
     const totals = {
@@ -167,6 +195,7 @@ export async function materializeFrontendTestResult(input) {
         sourceBinding,
         manifest: { path: manifestPath, sha256: sha256(await readFile(manifestAbsolute)) },
         cases,
+        advisoryFindings,
         totals,
         acceptanceCoverage: { covered: [...covered].sort(), missing: missing.sort() },
         integrationMode: outcome === "passed" ? "real" : "none",
@@ -186,10 +215,9 @@ export function buildFrontendTestOutcomeGateShellSnippet(options) {
     ].join("; ");
 }
 /**
- * Shared frontend-test evidence gate for map children + node 7.
- * - Hard fail only on manifest/path integrity (unsafe evidenceDir / escape).
- * - Missing or malformed case-result/execution is healed to status=blocked
- *   with blockedReason=invalid-evidence-shape so result materialize + retrospect can run.
+ * Shared frontend-test evidence advisory check for map children + node 7.
+ * Hard-fails only for unsafe evidence directories or evidence paths. Missing,
+ * malformed, or empty evidence is reported without mutating case outputs.
  */
 export function buildFrontendCaseEvidenceValidateShellSnippet() {
     const body = [
@@ -201,16 +229,7 @@ export function buildFrontendCaseEvidenceValidateShellSnippet() {
         "const statuses=new Set(['passed','failed','blocked']);",
         "const issues=[];",
         "let hardFail=false;",
-        "let evidenceContentCount=0;",
-        "function hasEvidenceContent(dir){if(!fs.existsSync(dir))return false;const pending=[dir];while(pending.length){const current=pending.pop();for(const entry of fs.readdirSync(current,{withFileTypes:true})){const candidate=path.join(current,entry.name);if(entry.isDirectory()){pending.push(candidate);}else if(entry.isFile()&&fs.statSync(candidate).size>0){return true;}}}return false;}",
-        "function writeBlocked(dir,caseId,reason,detail){",
-        " fs.mkdirSync(dir,{recursive:true});",
-        " const execution=path.join(dir,'execution.md');",
-        " const note='# '+caseId+'\\n\\nStatus: blocked\\n\\nReason: '+reason+(detail?('\\n\\nDetail: '+detail):'')+'\\n';",
-        " fs.writeFileSync(execution,note);",
-        " fs.writeFileSync(path.join(dir,'case-result.json'),JSON.stringify({caseId:caseId,status:'blocked',blockedReason:reason,evidencePaths:['execution.md']},null,2)+'\\n');",
-        "}",
-        "function isSafeRel(p){return typeof p==='string'&&p.length>0&&!path.isAbsolute(p)&&!p.includes('..');}",
+        "function isSafeRel(p){return typeof p==='string'&&p.length>0&&!path.isAbsolute(p)&&!path.win32.isAbsolute(p)&&!p.includes('..');}",
         "for(const c of manifest.cases){",
         " const id=c&&typeof c.caseId==='string'?c.caseId:'?';",
         " const dir=c&&c.evidenceDir;",
@@ -220,32 +239,18 @@ export function buildFrontendCaseEvidenceValidateShellSnippet() {
         " }",
         " const execution=path.join(dir,'execution.md');",
         " const resultPath=path.join(dir,'case-result.json');",
-        " if(hasEvidenceContent(dir))evidenceContentCount++;",
-        " let healReason=null; let healDetail=null;",
-        " if(!fs.existsSync(execution)){healReason='invalid-evidence-shape';healDetail='missing execution.md';}",
-        " if(!fs.existsSync(resultPath)){healReason='invalid-evidence-shape';healDetail=(healDetail?healDetail+'; ':'')+'missing case-result.json';}",
+        " if(!fs.existsSync(execution)||!fs.statSync(execution).isFile()||fs.statSync(execution).size===0)issues.push({ruleId:'missing-execution',caseId:id,detail:'execution.md is missing or empty'});",
         " let result=null;",
-        " if(!healReason){",
-        "  try{result=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch(e){healReason='invalid-evidence-shape';healDetail='invalid JSON case-result.json';}",
-        " }",
-        " if(!healReason){",
-        "  if(!result||result.caseId!==id||!statuses.has(result.status)||!Array.isArray(result.evidencePaths)||result.evidencePaths.some(p=>!isSafeRel(p))){",
-        "   healReason='invalid-evidence-shape';healDetail='caseId/status/evidencePaths contract';",
-        "  } else if(result.status==='passed'&&(result.evidencePaths.length<1||!result.evidencePaths.some(p=>/\\.(png|jpg|jpeg|webp|zip|har|webm|mp4|md)$/i.test(p)))){",
-        "   healReason='invalid-evidence-shape';healDetail='passed requires browser evidence path';",
-        "  } else if(result.status==='blocked'&&(typeof result.blockedReason!=='string'||!result.blockedReason.trim())){",
-        "   healReason='invalid-evidence-shape';healDetail='blocked requires blockedReason';",
-        "  }",
-        " }",
-        " if(healReason){",
-        "  writeBlocked(dir,id,healReason,healDetail);",
-        "  issues.push({ruleId:healReason,caseId:id,detail:healDetail,healed:true});",
-        " }",
+        " if(!fs.existsSync(resultPath)){issues.push({ruleId:'missing-case-result',caseId:id,detail:'case-result.json is missing'});continue;}",
+        " try{result=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch(e){issues.push({ruleId:'invalid-case-result',caseId:id,detail:'case-result.json is malformed'});continue;}",
+        " if(!result||result.caseId!==id)issues.push({ruleId:'case-result-identity',caseId:id,detail:'case-result caseId does not match manifest'});",
+        " if(!statuses.has(result&&result.status))issues.push({ruleId:'invalid-case-status',caseId:id,detail:'status must be passed, failed, or blocked'});",
+        " if(!Array.isArray(result&&result.evidencePaths)){issues.push({ruleId:'invalid-evidence-paths',caseId:id,detail:'evidencePaths must be an array'});}else{for(const p of result.evidencePaths){if(!isSafeRel(p)){hardFail=true;issues.push({ruleId:'unsafe-evidence-path',caseId:id,detail:String(p)});continue;}const currentPrefix=prefix+'/';if(p.startsWith('testcase/frontend/evidence/')&&!p.startsWith(currentPrefix)){hardFail=true;issues.push({ruleId:'cross-case-evidence-path',caseId:id,detail:p});continue;}const target=p.startsWith('testcase/')?p:path.join(dir,p);if(!fs.existsSync(target)||!fs.statSync(target).isFile()||fs.statSync(target).size===0)issues.push({ruleId:'missing-evidence',caseId:id,detail:p+' is missing or empty'});}}",
+        " if(result&&result.status==='passed'&&(!Array.isArray(result.evidencePaths)||!result.evidencePaths.some(p=>/\\.(png|jpg|jpeg|webp|zip|har|webm|mp4)$/i.test(p))))issues.push({ruleId:'passed-without-browser-evidence',caseId:id,detail:'passed case has no screenshot, HAR, video, or equivalent browser artifact'});",
+        " if(result&&result.status==='blocked'&&(typeof result.blockedReason!=='string'||!result.blockedReason.trim()))issues.push({ruleId:'blocked-reason',caseId:id,detail:'blocked result has no usable reason'});",
         "}",
         "if(hardFail){console.error('frontend-test evidence hard-fail: '+JSON.stringify(issues)); process.exit(1);}",
-        "if(evidenceContentCount===0){console.error('frontend-test evidence hard-fail: no frontend case evidence content'); process.exit(1);}",
-        "const healed=issues.filter(i=>i.healed).length;",
-        "console.log('frontend case evidence validation ok cases='+manifest.cases.length+' healed='+healed+(issues.length?(' issues='+JSON.stringify(issues)):''));",
+        "console.log('frontend case evidence advisory validation ok cases='+manifest.cases.length+' findings='+issues.length+(issues.length?(' issues='+JSON.stringify(issues)):''));",
     ].join("");
     return ["node -e", JSON.stringify(body)].join(" ");
 }

package/dist/workflows/dag/frontend-verification-trace.js

@@ -26,6 +26,15 @@ function parseMockStrategyFromAssess(text) {
     const match = text.match(/^\s*MOCK_STRATEGY:\s*([a-z0-9-]+)\s*$/im);
     return match?.[1] ?? null;
 }
+function symbolEvidenceCandidates(symbol) {
+    const normalized = symbol.trim().toLowerCase();
+    if (normalized === "all describe blocks")
+        return ["describe("];
+    const describeTitle = symbol.match(/^describe\((?:['"])(.+?)(?:['"])/i)?.[1];
+    if (describeTitle)
+        return [symbol, describeTitle, "describe("];
+    return [symbol];
+}
 async function assertFileAndSymbol(input) {
     const issues = [];
     const absolute = path.resolve(input.workspaceRoot, input.file);
@@ -49,7 +58,8 @@ async function assertFileAndSymbol(input) {
     }
     if (input.symbol) {
         const content = await readFile(absolute, "utf8");
-        if (!content.includes(input.symbol)) {
+        const matched = symbolEvidenceCandidates(input.symbol).some((candidate) => content.includes(candidate));
+        if (!matched) {
             issues.push(`symbol not found: ${input.symbol} in ${input.file}`);
         }
     }
@@ -115,6 +125,20 @@ export async function runFrontendVerificationTraceGate(input) {
         : await loadFirstNode(behaviorCandidates);
     assertNodeFinished(staticNode.nodeId, staticNode.record);
     assertNodeFinished(behaviorNode.nodeId, behaviorNode.record);
+    const mockCommandLabels = input.evidence?.mock?.commandLabels ?? [];
+    const mockCommandNodeId = input.evidence?.mock?.nodeId;
+    const mockCommandTexts = input.evidence?.mock?.commandTexts ?? [];
+    if (input.evidence && contract.mockApi.strategy !== "not-needed" && mockCommandLabels.length === 0) {
+        throw new Error("trace: selected Mock strategy requires successful Mock verification commands");
+    }
+    if (input.evidence) {
+        if (input.evidence.static.commandLabels.length === 0) {
+            throw new Error("trace: no successful static verification commands in current run");
+        }
+        if (input.evidence.behavior.commandLabels.length === 0) {
+            throw new Error("trace: no successful behavior verification commands in current run");
+        }
+    }
     const labelOwners = collectCommandLabels({ nodeId: staticNode.nodeId, record: staticNode.record }, { nodeId: behaviorNode.nodeId, record: behaviorNode.record });
     // Legacy runs may still carry a standalone Mock assessment. New slim runs
     // bind the strategy directly through the validated implementation contract.
@@ -173,6 +197,9 @@ export async function runFrontendVerificationTraceGate(input) {
         visualStatus: "not-run",
         targets,
         mockStrategy: contract.mockApi.strategy,
+        mockCommandLabels,
+        mockCommandNodeId,
+        mockCommandTexts,
     };
     if (input.writeArtifact !== false) {
         const artifactRel = "contracts/frontend-verification-trace.json";
@@ -185,6 +212,9 @@ export async function runFrontendVerificationTraceGate(input) {
             browserStatus: result.browserStatus,
             visualStatus: result.visualStatus,
             mockStrategy: result.mockStrategy,
+            mockCommandLabels: result.mockCommandLabels,
+            mockCommandNodeId: result.mockCommandNodeId,
+            mockCommandTexts: result.mockCommandTexts,
             targets: result.targets,
         }, null, 2)}\n`, "utf8");
         result.artifactPath = artifactPath;

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 export const FRONTEND_WORKTREE_DIFF_SCHEMA_ID = "frontend-worktree-diff-v1";
+export const FRONTEND_WORKTREE_BASELINE_SCHEMA_ID = "frontend-worktree-baseline-v1";
 function runGit(cwd, args) {
     return new Promise((resolve, reject) => {
         const child = spawn("git", args, {
@@ -31,6 +32,45 @@ function splitLines(text) {
         .map((line) => line.trim())
         .filter(Boolean);
 }
+function statusPaths(status) {
+    return splitLines(status)
+        .map((line) => line.slice(3).split(" -> ").at(-1) ?? "")
+        .filter(Boolean)
+        .sort();
+}
+async function sha256File(filePath) {
+    try {
+        const bytes = await readFile(filePath);
+        return createHash("sha256").update(bytes).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureFrontendWorktreeBaseline(input) {
+    const root = path.resolve(input.workspaceRoot);
+    const status = await runGit(root, [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+    ]);
+    if (status.code !== 0) {
+        throw new Error(`frontend worktree baseline failed: ${status.stderr.trim() || status.stdout.trim()}`);
+    }
+    const files = statusPaths(status.stdout);
+    const hashes = {};
+    for (const file of files)
+        hashes[file] = await sha256File(path.join(root, file));
+    const relative = "contracts/frontend-worktree-baseline.json";
+    await writeDagRunJsonArtifact(input.runDir, relative, {
+        schemaVersion: 1,
+        schemaId: FRONTEND_WORKTREE_BASELINE_SCHEMA_ID,
+        files,
+        hashes,
+        capturedAt: new Date().toISOString(),
+    });
+    return relative;
+}
 /**
  * Capture the current workspace worktree as a run-owned review artifact.
  *
@@ -41,6 +81,22 @@ function splitLines(text) {
  */
 export async function runFrontendWorktreeDiffGate(input) {
     const root = path.resolve(input.workspaceRoot);
+    let baseline;
+    try {
+        const raw = JSON.parse(await readFile(path.join(input.runDir, "contracts/frontend-worktree-baseline.json"), "utf8"));
+        if (raw.schemaId !== FRONTEND_WORKTREE_BASELINE_SCHEMA_ID) {
+            throw new Error("invalid baseline schema");
+        }
+        baseline = { files: raw.files ?? [], hashes: raw.hashes ?? {} };
+    }
+    catch (error) {
+        if (input.requireBaseline) {
+            throw new Error(`frontend worktree baseline is missing or invalid: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (input.requireBaseline && !baseline) {
+        throw new Error("frontend worktree baseline is required for this review context");
+    }
     const revParse = await runGit(root, ["rev-parse", "--is-inside-work-tree"]);
     if (revParse.code !== 0 || revParse.stdout.trim() !== "true") {
         throw new Error(`frontend worktree diff gate requires a git worktree: ${revParse.stderr.trim() || revParse.stdout.trim() || "not a git repository"}`);
@@ -67,11 +123,30 @@ export async function runFrontendWorktreeDiffGate(input) {
     if (untracked.code !== 0) {
         throw new Error(`frontend worktree diff gate ls-files failed: ${untracked.stderr.trim() || untracked.stdout.trim()}`);
     }
-    const changedFiles = splitLines(nameOnly.stdout).sort();
-    const untrackedFiles = splitLines(untracked.stdout).sort();
-    const patchBody = diff.stdout.endsWith("\n") || diff.stdout.length === 0
-        ? diff.stdout
-        : `${diff.stdout}\n`;
+    const changedFilesAll = splitLines(nameOnly.stdout).sort();
+    const untrackedFilesAll = splitLines(untracked.stdout).sort();
+    if (baseline) {
+        for (const file of baseline.files) {
+            const currentHash = await sha256File(path.join(root, file));
+            if (currentHash !== baseline.hashes[file]) {
+                throw new Error(`frontend worktree diff overlaps pre-existing change: ${file}`);
+            }
+        }
+    }
+    const baselineFiles = new Set(baseline?.files ?? []);
+    const changedFiles = changedFilesAll.filter((file) => !baselineFiles.has(file));
+    const untrackedFiles = untrackedFilesAll.filter((file) => !baselineFiles.has(file));
+    const patchSource = baseline
+        ? changedFiles.length > 0
+            ? await runGit(root, ["diff", "--binary", "HEAD", "--", ...changedFiles])
+            : { code: 0, stdout: "", stderr: "" }
+        : diff;
+    if (patchSource.code !== 0) {
+        throw new Error(`frontend worktree diff filtering failed: ${patchSource.stderr.trim() || patchSource.stdout.trim()}`);
+    }
+    const patchBody = patchSource.stdout.endsWith("\n") || patchSource.stdout.length === 0
+        ? patchSource.stdout
+        : `${patchSource.stdout}\n`;
     const untrackedSection = untrackedFiles.length === 0
         ? ""
         : [