@tea-agent/loop-agent 0.16.15 → 0.16.16

package/CHANGELOG.md

@@ -4,11 +4,15 @@
 
 ### 改进
 
+- 前端浏览器测试 DAG 的复盘报告现写入 `testcase/frontend/reports/**`，不再要求 `docs/test-reports/**` 权限；任务执行约束可以安全禁止整个 `docs/**`，同时仍保留可审计的测试资产。
+- `frontend-test` 结果链新增 run-owned `frontend-test-result-v1`、单次用例修订与终审门禁；只有所有浏览器用例和 AC 覆盖通过且结果合同明确为 real/pass 时，Worker 才会投影真实集成。
+
 - 后端测试 DAG 从 38 个收敛为 24 个真实顶层节点；使用 fail-closed `runIf` 和复合 Shell capability 减少调度，同时保留双合同、Manifest、语义评审、JUnit、Result、分类、修复安全、追踪和最终 outcome 证据。三条可选修订/修复分支仍各最多执行一次。
 - Backend Test Analysis、Case Manifest、Semantic Review 与 Classification 的严格 JSON 契约进一步对齐，生成和修订节点明确字段白名单、`sourceBinding` 与 evidence gap 约束，避免模型自定义字段导致确定性门禁失败。
 
 ### 修复
 
+- `frontend-test` 的 case review 现在是 fail-closed browser gate：只有 `VERDICT: pass` 才能物化 manifest 并启动动态 browser map；生成的 case 固定使用默认 browser session，要求每个子场景的 fixture/UI reset 和 fresh snapshot，并由确定性节点校验每个 case 的 `execution.md`、`case-result.json`、`caseId`、`status`、`evidencePaths` 及 blocked `blockedReason`。
 - 前端实现计划/修订节点会注入当前包内权威 `frontend-implementation-contract-v1` Schema 与固定 source binding，避免模型猜测字段导致契约门禁失败。
 - 前端 Mock 策略节点的 canonical 输出会把首条 `MOCK_STRATEGY:` 协议行提升为第一行，避免解释性前言触发 `first-non-empty` 门禁误判。
 - 前端规范回退目录统一为本地 `openspec/`，DAG 能力发现、提示词、Skill 与验证证据检查不再查找大小写不一致的旧目录名。
@@ -18,6 +22,12 @@
 - Pi SDK 执行长推理或大段结构化输出时不再把高频流式增量事件无界累积到内存；同一响应在多个生命周期事件中重复出现的 Token 用量只统计一次，避免 `Invalid string length` 和成本数据虚高。
 - 后端测试复合执行节点继续保持 clean environment、失败分类和 fail-closed outcome，并为 initial/final Result、repair eligibility、traceability 与 Observe 投影保留结构化运行证据。
 
+## [0.16.16] - 2026-07-20
+
+### 修复
+
+- 动态 DAG `itemsFrom` / JSON 选择器从 shell 节点 stdout 解析时，可跳过命令回显行并提取末尾 JSON 对象，避免 frontend-test `execute-frontend-cases-map` 在 materialize 门成功后仍因 `$ node -e ...` 前缀失败。
+
 ## [0.16.15] - 2026-07-20
 
 ### 修复

package/dist/executors/shell-executor.js

@@ -7,6 +7,7 @@ import { truncateOutput } from "../shared/output-truncation.js";
 import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand, } from "./shell-presets.js";
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
+import { materializeFrontendTestResult, } from "../workflows/dag/frontend-test-result-contract.js";
 import { formatFrontendVerificationTraceStdout, runFrontendVerificationTraceGate, } from "../workflows/dag/frontend-verification-trace.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "../workflows/dag/frontend-worktree-diff.js";
 import { formatFrontendFailureAssessStdout, formatFrontendRepairContractStdout, runFrontendFailureAssessGate, runFrontendRepairContractGate, } from "../workflows/dag/frontend-repair.js";
@@ -544,6 +545,15 @@ export async function executeDagShellNode(input, meta) {
                         sourceBinding: meta.spec.sourceBinding,
                     });
                     break;
+                case "frontend-test-result-v1":
+                    artifact = await materializeFrontendTestResult({
+                        runDir: meta.runDir,
+                        workspaceRoot: input.cwd,
+                        artifactName: gate.artifactName,
+                        outputDir: gate.outputDir,
+                        sourceBinding: meta.spec.sourceBinding,
+                    });
+                    break;
                 default:
                     throw new Error(`unsupported jsonArtifactGate.schemaId: ${String(gate.schemaId)}`);
             }

package/dist/worker/outcomes/adapters.js

@@ -124,12 +124,13 @@ class BackendTestAdapter {
 class FrontendTestAdapter {
     workflow = "frontend-test";
     project(input) {
-        const real = input.reportDecision.succeeded;
+        const structured = structuredArtifactsFromReport(input.dagReportRun);
+        const result = structured.find((artifact) => artifact.kind === "frontend-test-result" && artifact.schemaId === "frontend-test-result-v1");
+        // The projector validates the bound hash on disk. Missing result evidence is
+        // intentionally not upgraded from DAG completion to real integration.
+        const real = input.reportDecision.succeeded && Boolean(result);
         return {
-            artifacts: [
-                ...canonicalArtifacts(input),
-                ...structuredArtifactsFromReport(input.dagReportRun),
-            ],
+            artifacts: [...canonicalArtifacts(input), ...structured],
             acceptanceCoverage: [...input.acceptanceRefs],
             integrationStatus: { mock: false, real },
         };

package/dist/worker/outcomes/projector.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { readFile, stat } from "node:fs/promises";
 import { sha256File } from "../pool/run-store.js";
 import { taskOutcomeEnvelopeV1Schema } from "./types.js";
+import { frontendTestResultContractSchema } from "../../workflows/dag/frontend-test-result-contract.js";
 import { getOutcomeAdapter } from "./adapters.js";
 import { isPathAllowedForTask, mergeOutcomeArtifacts, projectDeclaredPathArtifacts, } from "./declared-artifacts.js";
 /**
@@ -117,6 +118,26 @@ export async function projectOutcome(input) {
             ...(artifact.schemaId ? { schemaId: artifact.schemaId } : {}),
         });
     }
+    // A frontend-test success is meaningful only when its finalizer produced a
+    // hash-verified real/pass result. This check deliberately happens after the
+    // generic rehash so report metadata cannot forge integration evidence.
+    if (workflow === "frontend-test") {
+        const results = validatedArtifacts.filter((artifact) => artifact.kind === "frontend-test-result" &&
+            artifact.schemaId === "frontend-test-result-v1");
+        if (results.length !== 1) {
+            return contractError("frontend-test requires exactly one hash-bound frontend-test-result-v1 artifact", ["frontend-test-result-v1"]);
+        }
+        try {
+            const resultArtifact = results[0];
+            const result = frontendTestResultContractSchema.parse(JSON.parse(await readFile(path.resolve(input.repoRoot, resultArtifact.path), "utf-8")));
+            if (result.outcome !== "passed" || result.integrationMode !== "real") {
+                return contractError(`frontend-test result is not a real pass: outcome=${result.outcome} integrationMode=${result.integrationMode}`);
+            }
+        }
+        catch (error) {
+            return contractError(`invalid frontend-test-result-v1 artifact: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // 5. Shell verification from report decision (exit-zero = report succeeded).
     const shellVerification = {
         exitZero: input.reportDecision.succeeded,

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -1,4 +1,4 @@
-import { mkdir } 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";
 import { executeDagNode, } from "../node-execution.js";
@@ -81,6 +81,28 @@ export function resolveRunLocalPath(runDir, ref, label) {
     }
     return resolved;
 }
+async function materializeTokenBudgetBlockedEvidence(input) {
+    if (!input.workspaceRef)
+        return;
+    const workspace = resolveRunLocalPath(input.cwd, input.workspaceRef, "workspaceRef");
+    await mkdir(workspace, { recursive: true });
+    const resultPath = path.join(workspace, "case-result.json");
+    const caseId = typeof input.item === "object" && input.item !== null &&
+        typeof input.item.caseId === "string"
+        ? input.item.caseId
+        : String(input.item);
+    try {
+        const existing = JSON.parse(await readFile(resultPath, "utf-8"));
+        if (existing.caseId === caseId &&
+            (existing.status === "passed" || existing.status === "failed" || existing.status === "blocked"))
+            return;
+    }
+    catch {
+        // Missing or malformed evidence is replaced only for a child that never started.
+    }
+    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: blocked\n\nReason: token-budget-exhausted\n`, "utf-8");
+    await writeFile(resultPath, `${JSON.stringify({ caseId, status: "blocked", blockedReason: "token-budget-exhausted", evidencePaths: ["execution.md"] }, null, 2)}\n`, "utf-8");
+}
 export async function executeDynamicMapExpansion(input) {
     const started = Date.now();
     const items = resolveItemsFromSelector(input.expansion.itemsFrom, input.state);
@@ -195,6 +217,16 @@ export async function executeDynamicMapExpansion(input) {
                     }
                     continue;
                 }
+                try {
+                    await materializeTokenBudgetBlockedEvidence({
+                        cwd: input.cwd,
+                        workspaceRef: workspaceRefs[children.indexOf(remaining)],
+                        item: items[children.indexOf(remaining)],
+                    });
+                }
+                catch (error) {
+                    throw new Error(`failed to materialize token-budget blocked evidence for ${remaining.id}: ${error instanceof Error ? error.message : String(error)}`);
+                }
                 record.status = "SKIPPED";
                 record.stderr = "blocked: token-budget-exhausted";
                 if (!blockedChildren.some((entry) => entry.nodeId === remaining.id)) {

package/dist/workflows/dag/dynamic-runtime/shared.js

@@ -21,12 +21,10 @@ export function getNodeOutputAsJson(state, nodeId) {
     if (!raw) {
         throw new Error(`itemsFrom upstream node "${nodeId}" has no JSON output`);
     }
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`itemsFrom upstream node "${nodeId}" output is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    const parsed = parseJsonFromText(raw);
+    if (parsed !== undefined)
+        return parsed;
+    throw new Error(`itemsFrom upstream node "${nodeId}" output is not valid JSON: ${raw.slice(0, 120)}`);
 }
 /** Normalize a line the same way verdict gates do (strip whole-line Markdown emphasis). */
 export function normalizeVerdictCandidateLine(value) {
@@ -147,10 +145,29 @@ export function parseConditionLiteral(raw) {
     return Number.isFinite(numeric) ? numeric : trimmed;
 }
 export function parseJsonFromText(value) {
-    if (!value?.trim())
+    const raw = value?.trim();
+    if (!raw)
         return undefined;
+    // Pure JSON first.
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        // continue
+    }
+    // Shell executor stdout prefixes each command with `$ <command>`. Dynamic
+    // selectors must consume exactly one trailing JSON payload after those echoes.
+    // Reject multi-payload or mixed prose to keep map expansion fail-closed.
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    if (lines.length < 2)
+        return undefined;
+    const payload = lines.at(-1)?.trim();
+    const prefix = lines.slice(0, -1);
+    if (!payload || prefix.some((line) => !line.startsWith("$ "))) {
+        return undefined;
+    }
     try {
-        return JSON.parse(value);
+        return JSON.parse(payload);
     }
     catch {
         return undefined;

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

@@ -0,0 +1,165 @@
+import { createHash } from "node:crypto";
+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";
+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) &&
+    !value.includes("\\") &&
+    value.split("/").every((part) => part.length > 0 && part !== "." && part !== ".."), "must be a safe repo-relative POSIX path");
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const caseStatusSchema = z.enum(["passed", "failed", "blocked"]);
+export const frontendTestResultContractSchema = z.object({
+    schemaVersion: z.literal(1),
+    sourceBinding: z.object({
+        taskId: z.string().min(1),
+        sources: z.array(z.object({
+            kind: z.enum(["requirement", "constraint", "reference"]),
+            path: safeRelativePathSchema,
+            sha256: sha256Schema,
+        }).strict()).min(1),
+        requirementIds: z.array(z.string().min(1)),
+    }).strict(),
+    manifest: z.object({
+        path: safeRelativePathSchema,
+        sha256: sha256Schema,
+    }).strict(),
+    cases: z.array(z.object({
+        caseId: z.string().min(1),
+        acIds: z.array(z.string().min(1)).min(1),
+        status: caseStatusSchema,
+        evidence: z.array(z.object({ path: safeRelativePathSchema, sha256: sha256Schema }).strict()),
+        blockedReason: z.string().min(1).optional(),
+    }).strict()).min(1),
+    totals: z.object({
+        cases: z.number().int().positive(),
+        passed: z.number().int().min(0),
+        failed: z.number().int().min(0),
+        blocked: z.number().int().min(0),
+    }).strict(),
+    acceptanceCoverage: z.object({
+        covered: z.array(z.string().min(1)),
+        missing: z.array(z.string().min(1)),
+    }).strict(),
+    integrationMode: z.enum(["real", "none"]),
+    outcome: z.enum(["passed", "failed", "incomplete"]),
+}).strict().superRefine((value, ctx) => {
+    if (value.totals.cases !== value.cases.length) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["totals", "cases"], message: "totals.cases must equal cases length" });
+    }
+    for (const status of ["passed", "failed", "blocked"]) {
+        const actual = value.cases.filter((item) => item.status === status).length;
+        if (value.totals[status] !== actual) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["totals", status], message: `totals.${status} must equal case status count` });
+        }
+    }
+    if (value.outcome === "passed" && (value.totals.failed > 0 || value.totals.blocked > 0 || value.acceptanceCoverage.missing.length > 0 || value.integrationMode !== "real")) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["outcome"], message: "passed requires all cases passed, complete AC coverage, and real integration" });
+    }
+    if (value.integrationMode === "real" && value.outcome !== "passed") {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["integrationMode"], message: "real integration requires passed outcome" });
+    }
+});
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function assertInside(root, candidate, label) {
+    const relative = path.relative(root, candidate);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`${label} escapes its allowed root`);
+    }
+}
+async function readEvidenceFile(repoRoot, evidenceRoot, relative) {
+    if (!safeRelativePathSchema.safeParse(relative).success) {
+        throw new Error(`unsafe evidence path: ${relative}`);
+    }
+    const absolute = path.resolve(evidenceRoot, relative);
+    assertInside(evidenceRoot, absolute, "evidence path");
+    const resolved = await realpath(absolute);
+    assertInside(repoRoot, resolved, "evidence realpath");
+    const info = await lstat(resolved);
+    if (!info.isFile())
+        throw new Error(`evidence is not a file: ${relative}`);
+    return { path: relative, sha256: sha256(await readFile(resolved)) };
+}
+export async function materializeFrontendTestResult(input) {
+    if (!/^[a-z0-9][a-z0-9._-]*\.json$/.test(input.artifactName) || !/^[a-z0-9][a-z0-9._-]*$/.test(input.outputDir)) {
+        throw new Error("unsafe structured artifact path");
+    }
+    const sourceBinding = input.sourceBinding;
+    if (!sourceBinding?.taskId || !sourceBinding.sources?.length) {
+        throw new Error("frontend-test result requires frozen sourceBinding");
+    }
+    const manifestPath = "testcase/frontend/cases/manifest.json";
+    const manifestAbsolute = path.resolve(input.workspaceRoot, manifestPath);
+    const manifest = JSON.parse(await readFile(manifestAbsolute, "utf-8"));
+    if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.cases) || manifest.cases.length === 0) {
+        throw new Error("invalid or empty frontend case manifest");
+    }
+    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");
+        }
+        if (!item.evidenceDir.startsWith(`testcase/frontend/evidence/${item.caseId}/`)) {
+            throw new Error(`unsafe evidenceDir for ${item.caseId}`);
+        }
+        for (const acId of item.acIds) {
+            if (requiredIds.size > 0 && !requiredIds.has(acId))
+                throw new Error(`unknown AC in manifest: ${acId}`);
+            covered.add(acId);
+        }
+        const evidenceRoot = path.resolve(input.workspaceRoot, item.evidenceDir);
+        assertInside(input.workspaceRoot, 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));
+        }
+        if (status === "passed" && !evidence.some((entry) => /\.(png|jpg|jpeg|webp|zip|har|webm|mp4|ya?ml)$/i.test(entry.path))) {
+            throw new Error(`passed case requires browser evidence: ${item.caseId}`);
+        }
+        cases.push({ caseId: item.caseId, acIds: item.acIds, status, evidence, ...(status === "blocked" ? { blockedReason: resultRaw.blockedReason } : {}) });
+    }
+    const missing = [...requiredIds].filter((id) => !covered.has(id));
+    const totals = {
+        cases: cases.length,
+        passed: cases.filter((item) => item.status === "passed").length,
+        failed: cases.filter((item) => item.status === "failed").length,
+        blocked: cases.filter((item) => item.status === "blocked").length,
+    };
+    const outcome = totals.failed > 0 ? "failed" : totals.blocked > 0 || missing.length > 0 ? "incomplete" : "passed";
+    const result = frontendTestResultContractSchema.parse({
+        schemaVersion: 1,
+        sourceBinding,
+        manifest: { path: manifestPath, sha256: sha256(await readFile(manifestAbsolute)) },
+        cases,
+        totals,
+        acceptanceCoverage: { covered: [...covered].sort(), missing: missing.sort() },
+        integrationMode: outcome === "passed" ? "real" : "none",
+        outcome,
+    });
+    const relativePath = path.posix.join(input.outputDir, input.artifactName);
+    const artifactPath = await writeDagRunJsonArtifact(input.runDir, relativePath, result);
+    return { path: artifactPath, sha256: sha256(`${JSON.stringify(result, null, 2)}\n`), schemaId: FRONTEND_TEST_RESULT_SCHEMA_ID };
+}
+export function buildFrontendTestOutcomeGateShellSnippet(options) {
+    const resultRelativePath = options?.resultRelativePath ?? "contracts/frontend-test-result.json";
+    return [
+        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for frontend-test outcome gate" >&2; exit 2; }',
+        `RESULT="\${HARNESS_DAG_RUN_DIR}/${resultRelativePath}"`,
+        'test -f "${RESULT}" || { echo "missing frontend-test result: ${RESULT}" >&2; exit 2; }',
+        `node -e 'const fs=require("fs");const r=JSON.parse(fs.readFileSync(process.argv[1],"utf8"));const ok=r.outcome==="passed"&&r.integrationMode==="real"&&Number(r.totals?.failed||0)===0&&Number(r.totals?.blocked||0)===0&&Array.isArray(r.acceptanceCoverage?.missing)&&r.acceptanceCoverage.missing.length===0;console.log("frontend-test outcome="+r.outcome+" integrationMode="+r.integrationMode);if(!ok)process.exit(1);' "\${RESULT}"`,
+    ].join("; ");
+}

package/dist/workflows/dag/init-hybrid.js

@@ -20,6 +20,7 @@ import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "
 import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
 import { buildBackendTestEffectiveResultSelectorShellSnippet, buildBackendTestRepairEligibilityShellSnippet, buildBackendTestRepairSafetyShellSnippet, } from "./backend-test-repair-contract.js";
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
+import { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
@@ -3660,11 +3661,8 @@ function buildFrontendTestHybridDag(sources) {
     const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
         pattern === "testcase/**" ||
         pattern === "**");
-    const hasReportWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" ||
-        pattern === "docs/**" ||
-        pattern === "**");
-    if (!hasFrontendTestWriteScope || !hasReportWriteScope) {
-        throw new Error('frontend-test requires task.json allowedPaths to include both "testcase/frontend/**" and "docs/test-reports/**" (or explicit containing globs).');
+    if (!hasFrontendTestWriteScope) {
+        throw new Error('frontend-test requires task.json allowedPaths to include "testcase/frontend/**" (or an explicit containing glob).');
     }
     const forbidden = commonForbiddenPaths(sources);
     const ragWriteSet = ["testcase/frontend/rag/**"];
@@ -3675,7 +3673,7 @@ function buildFrontendTestHybridDag(sources) {
         JSON.stringify([
             "const fs=require('fs'),path=require('path');",
             "const file='testcase/frontend/cases/manifest.json'; if(!fs.existsSync(file)) throw new Error('missing '+file);",
-            "const manifest=JSON.parse(fs.readFileSync(file,'utf8')); if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases)) throw new Error('invalid frontend case manifest');",
+            "const manifest=JSON.parse(fs.readFileSync(file,'utf8')); if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases)||manifest.cases.length===0) throw new Error('invalid or empty frontend case manifest');",
             "const dims=new Set(['core','boundary','flow','backend']);",
             "const seen=new Set(); const seenCasePath=new Set(); const seenEvidenceDir=new Set();",
             "for(const c of manifest.cases){",
@@ -3685,14 +3683,27 @@ function buildFrontendTestHybridDag(sources) {
             " if(!Array.isArray(c.acIds)||c.acIds.length===0||c.acIds.some(a=>typeof a!=='string'||!a.trim())) throw new Error('invalid acIds');",
             " for(const k of ['casePath','evidenceDir']){ const v=c[k]; if(typeof v!=='string'||path.isAbsolute(v)||v.includes('..')) throw new Error('unsafe '+k); }",
             " if(c.casePath!=='testcase/frontend/cases/'+c.caseId+'.md') throw new Error('casePath must match caseId');",
-            // Accept evidenceDir as case root or nested path under that root.
+            // Accept evidenceDir as the case root or a nested path under that root.
             " { const prefix='testcase/frontend/evidence/'+c.caseId; if(!(c.evidenceDir===prefix||c.evidenceDir.startsWith(prefix+'/'))) throw new Error('case path escapes frontend test roots'); }",
+            " if(!fs.existsSync(c.casePath)) throw new Error('missing case file '+c.casePath);",
             " if(seenCasePath.has(c.casePath)) throw new Error('duplicate casePath'); seenCasePath.add(c.casePath);",
             " if(seenEvidenceDir.has(c.evidenceDir)) throw new Error('duplicate evidenceDir'); seenEvidenceDir.add(c.evidenceDir);",
             "}",
             "process.stdout.write(JSON.stringify({cases:manifest.cases}));",
         ].join("")),
     ].join(" ");
+    const evidenceValidation = [
+        "node -e",
+        JSON.stringify([
+            "const fs=require('fs'),path=require('path');",
+            "const manifestPath='testcase/frontend/cases/manifest.json';if(!fs.existsSync(manifestPath))throw new Error('missing '+manifestPath);",
+            "const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));if(!Array.isArray(manifest.cases))throw new Error('invalid frontend case manifest');",
+            "const statuses=new Set(['passed','failed','blocked']);let failed=false;",
+            "for(const c of manifest.cases){const dir=c&&c.evidenceDir;if(!c||typeof c.caseId!=='string'||typeof dir!=='string'||path.isAbsolute(dir)||dir.includes('..')||!dir.startsWith('testcase/frontend/evidence/'+c.caseId+'/')){console.error('invalid case evidence target');failed=true;continue;}const execution=path.join(dir,'execution.md'),resultPath=path.join(dir,'case-result.json');if(!fs.existsSync(execution)){console.error(c.caseId+': missing '+execution);failed=true;}if(!fs.existsSync(resultPath)){console.error(c.caseId+': missing '+resultPath);failed=true;continue;}let result;try{result=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch{console.error(c.caseId+': invalid JSON '+resultPath);failed=true;continue;}if(!result||result.caseId!==c.caseId||!statuses.has(result.status)||!Array.isArray(result.evidencePaths)||result.evidencePaths.some(p=>typeof p!=='string'||path.isAbsolute(p)||p.includes('..'))){console.error(c.caseId+': result must have matching caseId, passed|failed|blocked status, and safe evidencePaths array');failed=true;continue;}if(result.status==='passed'&&(result.evidencePaths.length<2||!result.evidencePaths.some(p=>/\\.(png|jpg|jpeg|webp|zip|har|webm|mp4)$/i.test(p)))){console.error(c.caseId+': passed result requires browser evidence');failed=true;}if(result.status==='blocked'&&(typeof result.blockedReason!=='string'||!result.blockedReason.trim())){console.error(c.caseId+': blocked result requires blockedReason');failed=true;}}",
+            "if(failed)process.exit(1);console.log('frontend case evidence validation ok cases='+manifest.cases.length);",
+        ].join("")),
+    ].join(" ");
+    const frontendTestOutcomeGate = buildFrontendTestOutcomeGateShellSnippet();
     const spec = {
         version: 3,
         title: `Frontend test DAG: ${sources.taskConfig.title}`,
@@ -3706,7 +3717,8 @@ function buildFrontendTestHybridDag(sources) {
             "frontend-test-dag generates Markdown cases and browser evidence only; it must not generate pytest or Playwright test source code.",
             "Each browser case runs serially in a fresh Pi execution boundary. Persist its evidence before starting the next case.",
             "Use only the declared isolated test environment. Production URLs, real credentials, and unauthorized data are blocked.",
-            "Browser startup for generated cases must be playwright-cli open --browser=chrome --headed <base-url>.",
+            "Browser startup for generated cases must be playwright-cli open --browser=chrome --headed <base-url>; generated operations stay in the default browser session and must not use unverified named-session flags.",
+            "A frontend case review must emit VERDICT: pass before manifest materialization; request-revision blocks browser execution.",
             "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
         ],
         defaults: {
@@ -3748,8 +3760,21 @@ function buildFrontendTestHybridDag(sources) {
                 ].join("\n\n"),
             },
             {
-                id: "generate-frontend-functional-cases-pi",
+                id: "materialize-frontend-test-execution-shell",
                 depends_on: ["retrieve-frontend-test-context-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Fail-closed preflight for an isolated non-production frontend test execution contract.",
+                subtask_prompt: "Validate that RAG context declares a non-production base URL/env name, fixture/reset isolation, browser startup, and no credential values.",
+                shell: { commands: [["node -e", JSON.stringify("const fs=require('fs');const p='testcase/frontend/rag/context.md';if(!fs.existsSync(p))throw new Error('missing '+p);const s=fs.readFileSync(p,'utf8');const required=[['base URL',/base[- ]url/i],['fixture',/fixture/i],['reset',/reset|重置/i],['playwright-cli open --browser=chrome --headed',/playwright-cli open --browser=chrome --headed/i]];for(const [label,pattern] of required)if(!pattern.test(s))throw new Error('frontend-test execution contract missing '+label);if(/https?:\\/\\/(?:www\\.)?[^\\s]*(?:prod|production)/i.test(s))throw new Error('production URL forbidden');console.log('frontend-test-execution-v1 validated')")].join(" ")], cwd: ".", timeoutMs: 60000 },
+            },
+            {
+                id: "generate-frontend-functional-cases-pi",
+                depends_on: ["materialize-frontend-test-execution-shell"],
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -3763,8 +3788,8 @@ function buildFrontendTestHybridDag(sources) {
                     "Use skill playwright-cli-case-generator.",
                     "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and existing testcase/frontend/cases/. Write only testcase/frontend/cases/**.",
                     "Generate Markdown cases, index.md and manifest.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.",
-                    "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>.",
-                    "Each case must be independent, declare its session/preconditions/data cleanup, UI assertions, evidence paths under testcase/frontend/evidence/<case-id>/, and mark unsafe/missing dependencies blocked.",
+                    "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>. Use the same default browser session for every subsequent command; never write -s=<case-id> or assume named-session binding.",
+                    "Each case must be independently reproducible: for every executable sub-scenario state fixture/reset, UI reset, a fresh snapshot before references are used, exact evidence write point, preconditions/data cleanup, UI assertions, and evidence paths under testcase/frontend/evidence/<case-id>/. If the isolated environment is unavailable, require writing blocked evidence before any browser command.",
                 ].join("\n\n"),
             },
             {
@@ -3776,19 +3801,72 @@ function buildFrontendTestHybridDag(sources) {
                 writePolicy: "read-only",
                 allowedPaths: [...ragWriteSet, ...casesWriteSet],
                 forbiddenPaths: forbidden,
-                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes.",
-                subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, and evidence requirements. The verdict is advisory and does not block case execution.",
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes. request-revision blocks manifest materialization.",
+                subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, session consistency, fixture/UI reset and fresh snapshot steps, and evidence requirements. Any Important or Critical finding requires VERDICT: request-revision. Browser execution is blocked unless this review passes.",
             },
             {
-                id: "materialize-frontend-case-manifest-shell",
+                id: "revise-frontend-cases-pi",
                 depends_on: ["review-frontend-cases-pi"],
+                runIf: "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: "HIGH",
+                writePolicy: "exclusive",
+                writeSet: casesWriteSet,
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Apply the one permitted frontend case revision under testcase/frontend/cases/** only; no browser execution or evidence writes.",
+                subtask_prompt: "This is the only permitted case revision. Read the first review findings and the RAG package. Revise only testcase/frontend/cases/**, preserve traceable AC mappings, and do not execute a browser or write evidence.",
+            },
+            {
+                id: "review-frontend-cases-final-pi",
+                depends_on: ["revise-frontend-cases-pi"],
+                runIf: "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                role: "reviewer",
+                executor: "pi",
+                complexity: "HIGH",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision after the single allowed case revision; no writes.",
+                subtask_prompt: "Perform the final frontend case review after the sole permitted revision. Apply the same traceability, isolation, manifest, reset, session, snapshot, and evidence checks. First verdict line must be exact; any Important or Critical finding requires request-revision. Do not write files.",
+            },
+            {
+                id: "final-frontend-case-review-gate-shell",
+                depends_on: ["review-frontend-cases-pi", "review-frontend-cases-final-pi"],
+                dependsPolicy: "all-or-condition-skip",
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Pass-only effective frontend case review gate; final review takes precedence when the revision branch ran.",
+                subtask_prompt: "Authorize manifest materialization only after the effective frontend case review passes.",
+                shell: {
+                    commands: [],
+                    verdictGate: {
+                        fromNodeId: "review-frontend-cases-final-pi",
+                        fallbackFromNodeIds: ["review-frontend-cases-pi"],
+                        accept: ["VERDICT: pass"],
+                        label: "effective frontend case review",
+                        lineMode: "first-verdict-line",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
+            {
+                id: "materialize-frontend-case-manifest-shell",
+                depends_on: ["final-frontend-case-review-gate-shell"],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: casesWriteSet,
                 forbiddenPaths: forbidden,
-                outputContract: "stdout is exactly JSON { cases: [...] } after deterministic frontend manifest validation.",
+                outputContract: "Validated frontend manifest payload { cases: [...] }; shell command echo is permitted only as the prefix before exactly one final JSON line.",
                 subtask_prompt: "Validate and materialize the generated frontend case manifest.",
                 shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
             },
@@ -3812,6 +3890,7 @@ function buildFrontendTestHybridDag(sources) {
                     maxItems: config.maxCasesPerBatch,
                     maxExpandedNodes: config.maxCasesPerBatch,
                     childIdPrefix: "execute-frontend-case",
+                    workspaceTemplate: "{{case.evidenceDir}}",
                     tokenBudget: {
                         maxTokensPerCase: config.maxTokensPerCase,
                         maxTotalTokens: config.maxTotalTokens,
@@ -3835,15 +3914,67 @@ function buildFrontendTestHybridDag(sources) {
                         subtaskPromptTemplate: [
                             "Execute exactly case {{case.caseId}} from {{case.casePath}} using playwright-cli and webapp-testing. This is a fresh Pi session; do not use /new.",
                             "Use only the declared isolated test environment. If CLI/browser/base URL/credentials/fixture isolation is missing, record blocked rather than installing tools or guessing.",
-                            "Use playwright-cli open --browser=chrome --headed <base-url>. Persist execution.md, case-result.json, screenshots/trace/video/logs under {{case.evidenceDir}} before returning.",
+                            "Use exactly this browser start command prefix: playwright-cli open --browser=chrome --headed <base-url>. Do not put session flags before open. Every later playwright-cli command must use that same default browser session; must not use -s=<case-id>, -s=, or any named-session flag because no session binding is verified.",
+                            "For every sub-scenario, record fixture/reset, UI reset, and a fresh snapshot before using element references. If the isolated environment is missing, write blocked evidence before any browser command; do not open or connect to a browser.",
+                            "Before returning, always persist {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json. case-result.json must be JSON with matching caseId, status as passed, failed, or blocked, and evidencePaths array; a blocked result must include non-empty blockedReason and must never imply pass.",
+                            "Run a local deterministic validation before returning: node -e \"const fs=require('fs');const p='{{case.evidenceDir}}';const r=JSON.parse(fs.readFileSync(p+'case-result.json','utf8'));if(!fs.existsSync(p+'execution.md')||r.caseId!=='{{case.caseId}}'||!['passed','failed','blocked'].includes(r.status)||!Array.isArray(r.evidencePaths)||(r.status==='blocked'&&!(typeof r.blockedReason==='string'&&r.blockedReason.trim())))process.exit(1)\". Persist screenshots/trace/video/logs when actually available. execution.md must record the executed or blocked steps, base URL safety decision, fixture/reset and request-observation availability, and evidence file list.",
                             "A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
                         ].join("\n\n"),
                     },
                 },
             },
             {
-                id: "review-frontend-execution-pi",
+                id: "validate-frontend-case-evidence-shell",
                 depends_on: ["execute-frontend-cases-map"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
+                forbiddenPaths: forbidden,
+                outputContract: "Deterministic validation that every manifest case has execution.md and valid matching case-result.json; blocked results require blockedReason.",
+                subtask_prompt: "Validate all frontend case evidence before evidence review; fail closed on missing or malformed records.",
+                shell: { commands: [evidenceValidation], cwd: ".", timeoutMs: 120000 },
+            },
+            {
+                id: "materialize-frontend-test-result-shell",
+                depends_on: ["validate-frontend-case-evidence-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
+                forbiddenPaths: forbidden,
+                outputContract: "Run-owned hash-bound frontend-test-result-v1 derived only from the manifest and validated case evidence.",
+                subtask_prompt: "Materialize the authoritative frontend-test-result-v1. Do not use Pi prose or retrospective output as input.",
+                shell: {
+                    commands: [],
+                    jsonArtifactGate: {
+                        fromNodeId: "validate-frontend-case-evidence-shell",
+                        schemaId: "frontend-test-result-v1",
+                        artifactName: "frontend-test-result.json",
+                        outputDir: "contracts",
+                    },
+                    cwd: ".",
+                    timeoutMs: 120000,
+                },
+            },
+            {
+                id: "frontend-test-result-outcome-gate-shell",
+                depends_on: ["materialize-frontend-test-result-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [],
+                forbiddenPaths: forbidden,
+                outputContract: "Pass only when the run-owned frontend-test-result-v1 records outcome=passed and integrationMode=real.",
+                subtask_prompt: "Gate the authoritative frontend-test result before Pi review and retrospective.",
+                shell: { commands: [frontendTestOutcomeGate], cwd: ".", timeoutMs: 60000 },
+            },
+            {
+                id: "review-frontend-execution-pi",
+                depends_on: ["frontend-test-result-outcome-gate-shell"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -3861,11 +3992,11 @@ function buildFrontendTestHybridDag(sources) {
                 toolProfile: "write",
                 complexity: "MED",
                 writePolicy: "exclusive",
-                writeSet: ["docs/test-reports/**"],
-                allowedPaths: ["testcase/frontend/**", "docs/test-reports/**"],
+                writeSet: ["testcase/frontend/reports/**"],
+                allowedPaths: ["testcase/frontend/**"],
                 forbiddenPaths: forbidden,
-                outputContract: "Write frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
-                subtask_prompt: "Write the frontend test retrospective under docs/test-reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed.",
+                outputContract: "Write frontend-test retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
+                subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed. Do not write docs/**.",
             },
         ],
     };

package/dist/workflows/dag/types.js

@@ -91,6 +91,7 @@ export const dagJsonArtifactSchemaIdSchema = z.enum([
     "backend-test-semantic-review-v1",
     "backend-test-case-manifest-v1",
     "frontend-implementation-contract-v1",
+    "frontend-test-result-v1",
 ]);
 export const dagJsonArtifactGateSchema = z.object({
     fromNodeId: z.string().regex(/^[a-z][a-z0-9-]*$/),

package/docs/templates/frontend-test-dag.generate-cases.prompt.md

@@ -2,4 +2,21 @@
 
 Use `playwright-cli-case-generator`. Read only `testcase/frontend/rag/context.md`, `coverage-map.md`, and existing `testcase/frontend/cases/`; write only that cases directory. Produce Markdown cases, `index.md`, and schema-version-1 `manifest.json`. Do not generate pytest or Playwright source code.
 
-Each case is independently executable and includes AC mapping, preconditions, session, cleanup, UI assertions, and isolated evidence paths. Use dimensions `core`, `boundary`, `flow`, or `backend`. Never guess API fields, constraints, SLA, credentials, or unrecorded data. The open command is exactly `playwright-cli open --browser=chrome --headed <base-url>`.
+Each case is independently executable and includes AC mapping, preconditions, cleanup, UI assertions, and its isolated evidence path. Use dimensions `core`, `boundary`, `flow`, or `backend`. Never guess API fields, constraints, SLA, credentials, or unrecorded data.
+
+Every case must use this exact browser-start command prefix:
+
+```text
+playwright-cli open --browser=chrome --headed <base-url>
+```
+
+Do not put a session flag before `open`. Every later Playwright CLI command must stay in that same default browser session: do **not** emit `-s=<case-id>`, `-s=...`, or assume an undocumented named-session binding.
+
+For every executable sub-scenario, state the fixture/reset operation, UI reset operation, a fresh snapshot before using element references, and the exact evidence write point. If the isolated environment is unavailable, require writing blocked evidence before any browser command; do not open or connect to a browser.
+
+Each case must require the executor to persist, even when blocked:
+
+- `testcase/frontend/evidence/<case-id>/execution.md`
+- `testcase/frontend/evidence/<case-id>/case-result.json`
+
+`case-result.json` must be valid JSON containing the matching `caseId`, `status` (`passed`, `failed`, or `blocked`), and an `evidencePaths` array. A blocked result must include a non-empty `blockedReason`, such as `isolated-test-environment-unavailable` or `token-budget-exhausted`, and must never claim or imply a pass. `execution.md` records attempted or blocked steps, base-URL safety decision, fixture/reset and request-observation availability, timestamps, and the evidence-file list. Screenshots, snapshots, traces, videos, and logs are required only when actually available and must stay under the same case evidence directory.

package/docs/templates/frontend-test-dag.json

@@ -2,22 +2,412 @@
   "$schema": "./agent-dag.schema.json",
   "version": 3,
   "title": "Frontend test RAG DAG template",
-  "runtimeContract": { "schemaVersion": 1, "agentRuntime": "pi-only", "repairWriterProtocol": "explicit-node-v1" },
+  "runtimeContract": {
+    "schemaVersion": 1,
+    "agentRuntime": "pi-only",
+    "repairWriterProtocol": "explicit-node-v1"
+  },
   "objective": "Build a frontend test RAG package, generate Markdown cases, execute each case serially through playwright-cli, and retain browser evidence.",
   "globalConstraints": [
     "Do not generate pytest or Playwright source code.",
     "Only use declared isolated test environments; production URLs and real credentials are blocked.",
-    "Every generated browser start command is playwright-cli open --browser=chrome --headed <base-url>.",
+    "Every generated browser start command is playwright-cli open --browser=chrome --headed <base-url>; subsequent commands stay in that default session and must not use unverified named-session flags.",
+    "A frontend case review must emit VERDICT: pass before manifest materialization; request-revision blocks browser execution.",
     "Case children execute serially. Persist each case result, logs and browser evidence before the next child starts.",
     "A token threshold is a post-case stop check, not a model hard token cap; unstarted cases must be recorded as blocked: token-budget-exhausted."
   ],
   "tasks": [
-    { "id": "retrieve-frontend-test-context-pi", "depends_on": [], "executor": "pi", "role": "planner", "toolProfile": "write", "complexity": "HIGH", "writePolicy": "exclusive", "writeSet": ["testcase/frontend/rag/**"], "allowedPaths": ["REPLACE/WITH/SOURCE/PATH/**", "testcase/frontend/rag/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "RAG context.md and coverage-map.md.", "subtask_prompt_markdown": "./frontend-test-dag.retrieve-context.prompt.md" },
-    { "id": "generate-frontend-functional-cases-pi", "depends_on": ["retrieve-frontend-test-context-pi"], "executor": "pi", "role": "implementer", "toolProfile": "write", "complexity": "HIGH", "writePolicy": "exclusive", "writeSet": ["testcase/frontend/cases/**"], "allowedPaths": ["testcase/frontend/rag/**", "testcase/frontend/cases/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "Markdown cases, index.md and manifest.json schemaVersion 1; no test source code.", "subtask_prompt_markdown": "./frontend-test-dag.generate-cases.prompt.md" },
-    { "id": "review-frontend-cases-pi", "depends_on": ["generate-frontend-functional-cases-pi"], "executor": "pi", "role": "reviewer", "complexity": "HIGH", "writePolicy": "read-only", "allowedPaths": ["testcase/frontend/rag/**", "testcase/frontend/cases/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "First line VERDICT: pass or VERDICT: request-revision; no writes.", "subtask_prompt_markdown": "./frontend-test-dag.review-cases.prompt.md" },
-    { "id": "materialize-frontend-case-manifest-shell", "depends_on": ["review-frontend-cases-pi"], "executor": "shell", "role": "verifier", "complexity": "LOW", "writePolicy": "read-only", "allowedPaths": ["testcase/frontend/cases/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "stdout exactly JSON { cases: [...] } after manifest validation.", "subtask_prompt": "Validate the generated frontend case manifest." },
-    { "id": "execute-frontend-cases-map", "depends_on": ["materialize-frontend-case-manifest-shell"], "executor": "static", "role": "verifier", "complexity": "LOW", "writePolicy": "none", "allowedPaths": [], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "Serial aggregate of browser case results.", "subtask_prompt": "Expand the validated manifest into serial browser case children.", "static": { "resultMarkdown": "Frontend case map expansion barrier." }, "dynamicExpansion": { "type": "map_agent", "workflowNodeId": "execute-frontend-cases-map", "itemsFrom": "$.nodes['materialize-frontend-case-manifest-shell'].output.cases", "itemName": "case", "maxItems": 20, "maxExpandedNodes": 20, "childIdPrefix": "execute-frontend-case", "tokenBudget": { "maxTokensPerCase": 20000, "maxTotalTokens": 200000 }, "childTask": { "executor": "pi", "role": "verifier", "skills": ["playwright-cli", "webapp-testing"], "toolProfile": "write", "complexity": "MED", "subtaskPromptTemplate": "Execute {{case.caseId}} from {{case.casePath}} in a fresh Pi session. Use playwright-cli open --browser=chrome --headed <base-url>. Persist result, logs and screenshots/trace/video under {{case.evidenceDir}}; return compact JSON only.", "outputContract": "Compact JSON <=1200 chars.", "writePolicy": "exclusive", "allowedPaths": ["testcase/frontend/cases/{{case.caseId}}.md", "testcase/frontend/rag/context.md", "testcase/frontend/rag/coverage-map.md", "testcase/frontend/evidence/{{case.caseId}}/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "writeSet": ["testcase/frontend/evidence/{{case.caseId}}/**"] } } },
-    { "id": "review-frontend-execution-pi", "depends_on": ["execute-frontend-cases-map"], "executor": "pi", "role": "reviewer", "complexity": "HIGH", "writePolicy": "read-only", "allowedPaths": ["testcase/frontend/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "AC-to-case-to-browser-evidence review.", "subtask_prompt_markdown": "./frontend-test-dag.review-execution.prompt.md" },
-    { "id": "frontend-test-retrospect-pi", "depends_on": ["review-frontend-execution-pi"], "executor": "pi", "role": "closeout", "toolProfile": "write", "complexity": "MED", "writePolicy": "exclusive", "writeSet": ["docs/test-reports/**"], "allowedPaths": ["testcase/frontend/**", "docs/test-reports/**"], "forbiddenPaths": [".harness/**", "artifacts/**"], "outputContract": "Frontend test retrospective with A/B/C/D rating.", "subtask_prompt_markdown": "./frontend-test-dag.retrospect.prompt.md" }
+    {
+      "id": "retrieve-frontend-test-context-pi",
+      "depends_on": [],
+      "executor": "pi",
+      "role": "planner",
+      "toolProfile": "write",
+      "complexity": "HIGH",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/rag/**"
+      ],
+      "allowedPaths": [
+        "REPLACE/WITH/SOURCE/PATH/**",
+        "testcase/frontend/rag/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "RAG context.md and coverage-map.md.",
+      "subtask_prompt_markdown": "./frontend-test-dag.retrieve-context.prompt.md"
+    },
+    {
+      "id": "generate-frontend-functional-cases-pi",
+      "depends_on": [
+        "retrieve-frontend-test-context-pi"
+      ],
+      "executor": "pi",
+      "role": "implementer",
+      "toolProfile": "write",
+      "complexity": "HIGH",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/cases/**"
+      ],
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Markdown cases, index.md and manifest.json schemaVersion 1; no test source code.",
+      "subtask_prompt_markdown": "./frontend-test-dag.generate-cases.prompt.md"
+    },
+    {
+      "id": "review-frontend-cases-pi",
+      "depends_on": [
+        "generate-frontend-functional-cases-pi"
+      ],
+      "executor": "pi",
+      "role": "reviewer",
+      "complexity": "HIGH",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "First line VERDICT: pass or VERDICT: request-revision; request-revision blocks manifest materialization; no writes.",
+      "subtask_prompt_markdown": "./frontend-test-dag.review-cases.prompt.md"
+    },
+    {
+      "id": "review-frontend-cases-gate-shell",
+      "depends_on": [
+        "review-frontend-cases-pi"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Deterministic gate: block manifest materialization and browser execution unless review-frontend-cases-pi emits VERDICT: pass.",
+      "subtask_prompt": "Enforce the frontend case review verdict before manifest materialization.",
+      "shell": {
+        "commands": [],
+        "verdictGate": {
+          "fromNodeId": "review-frontend-cases-pi",
+          "accept": [
+            "VERDICT: pass"
+          ],
+          "label": "frontend case review",
+          "lineMode": "first-verdict-line"
+        },
+        "cwd": ".",
+        "timeoutMs": 60000
+      }
+    },
+    {
+      "id": "revise-frontend-cases-pi",
+      "depends_on": [
+        "review-frontend-cases-pi"
+      ],
+      "runIf": "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+      "executor": "pi",
+      "role": "implementer",
+      "toolProfile": "write",
+      "complexity": "HIGH",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/cases/**"
+      ],
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Apply the one permitted frontend case revision; no browser execution or evidence writes.",
+      "subtask_prompt": "Apply the sole allowed case revision from the first review. Change only testcase/frontend/cases/**; preserve AC traceability. Do not execute browsers or write evidence."
+    },
+    {
+      "id": "review-frontend-cases-final-pi",
+      "depends_on": [
+        "revise-frontend-cases-pi"
+      ],
+      "runIf": "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+      "executor": "pi",
+      "role": "reviewer",
+      "complexity": "HIGH",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "First line VERDICT: pass or VERDICT: request-revision after the single allowed revision; no writes.",
+      "subtask_prompt_markdown": "./frontend-test-dag.review-cases.prompt.md"
+    },
+    {
+      "id": "final-frontend-case-review-gate-shell",
+      "depends_on": [
+        "review-frontend-cases-pi",
+        "review-frontend-cases-final-pi"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/rag/**",
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Pass-only effective case review gate; final review takes precedence when revision ran.",
+      "subtask_prompt": "Enforce the frontend case review verdict before manifest materialization.",
+      "shell": {
+        "commands": [],
+        "verdictGate": {
+          "fromNodeId": "review-frontend-cases-final-pi",
+          "fallbackFromNodeIds": [
+            "review-frontend-cases-pi"
+          ],
+          "accept": [
+            "VERDICT: pass"
+          ],
+          "label": "effective frontend case review",
+          "lineMode": "first-verdict-line"
+        },
+        "cwd": ".",
+        "timeoutMs": 60000
+      },
+      "dependsPolicy": "all-or-condition-skip"
+    },
+    {
+      "id": "materialize-frontend-case-manifest-shell",
+      "depends_on": [
+        "final-frontend-case-review-gate-shell"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/cases/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Validated frontend manifest payload { cases: [...] }; shell command echo is permitted only as the prefix before exactly one final JSON line.",
+      "subtask_prompt": "Validate and materialize the generated frontend case manifest.",
+      "shell": {
+        "commands": [
+          "node -e \"const fs=require('fs'),path=require('path');const file='testcase/frontend/cases/manifest.json';if(!fs.existsSync(file))throw new Error('missing '+file);const manifest=JSON.parse(fs.readFileSync(file,'utf8'));if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases))throw new Error('invalid frontend case manifest');const dims=new Set(['core','boundary','flow','backend']);const ids=new Set(),paths=new Set(),evidence=new Set();for(const c of manifest.cases){if(!c||typeof c.caseId!=='string'||!/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/.test(c.caseId)||ids.has(c.caseId))throw new Error('invalid or duplicate caseId');ids.add(c.caseId);if(!dims.has(c.dimension))throw new Error('invalid dimension');if(!Array.isArray(c.acIds)||!c.acIds.length||c.acIds.some(a=>typeof a!=='string'||!a.trim()))throw new Error('invalid acIds');for(const key of ['casePath','evidenceDir']){const value=c[key];if(typeof value!=='string'||path.isAbsolute(value)||value.includes('..'))throw new Error('unsafe '+key);}if(c.casePath!=='testcase/frontend/cases/'+c.caseId+'.md')throw new Error('casePath must match caseId');if(!c.evidenceDir.startsWith('testcase/frontend/evidence/'+c.caseId+'/'))throw new Error('case path escapes frontend test roots');if(paths.has(c.casePath))throw new Error('duplicate casePath');paths.add(c.casePath);if(evidence.has(c.evidenceDir))throw new Error('duplicate evidenceDir');evidence.add(c.evidenceDir);}process.stdout.write(JSON.stringify({cases:manifest.cases}));\""
+        ],
+        "cwd": ".",
+        "timeoutMs": 120000
+      }
+    },
+    {
+      "id": "execute-frontend-cases-map",
+      "depends_on": [
+        "materialize-frontend-case-manifest-shell"
+      ],
+      "executor": "static",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "none",
+      "allowedPaths": [],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Serial aggregate of browser case results.",
+      "subtask_prompt": "Expand the validated manifest into serial browser case children.",
+      "static": {
+        "resultMarkdown": "Frontend case map expansion barrier."
+      },
+      "dynamicExpansion": {
+        "type": "map_agent",
+        "workflowNodeId": "execute-frontend-cases-map",
+        "itemsFrom": "$.nodes['materialize-frontend-case-manifest-shell'].output.cases",
+        "itemName": "case",
+        "maxItems": 20,
+        "maxExpandedNodes": 20,
+        "childIdPrefix": "execute-frontend-case",
+        "tokenBudget": {
+          "maxTokensPerCase": 20000,
+          "maxTotalTokens": 200000
+        },
+        "childTask": {
+          "executor": "pi",
+          "role": "verifier",
+          "skills": [
+            "playwright-cli",
+            "webapp-testing"
+          ],
+          "toolProfile": "write",
+          "complexity": "MED",
+          "subtaskPromptTemplate": "Execute {{case.caseId}} from {{case.casePath}} in a fresh Pi session. Use exactly this browser start command prefix: playwright-cli open --browser=chrome --headed <base-url>. Do not put session flags before open. Every later playwright-cli command must use that same default browser session; must not use -s=<case-id>, -s=, or any named-session flag because no session binding is verified. For every sub-scenario, record fixture/reset, UI reset, and a fresh snapshot before using element references. If the isolated environment is missing, write blocked evidence before any browser command; do not open or connect to a browser. Before returning, always persist {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json. case-result.json must be JSON with matching caseId, status as passed, failed, or blocked, and evidencePaths array; a blocked result must include non-empty blockedReason and must never imply pass. Run a local deterministic validation before returning: node -e \"const fs=require('fs');const p='{{case.evidenceDir}}';const r=JSON.parse(fs.readFileSync(p+'case-result.json','utf8'));if(!fs.existsSync(p+'execution.md')||r.caseId!=='{{case.caseId}}'||!['passed','failed','blocked'].includes(r.status)||(r.status==='blocked'&&!(typeof r.blockedReason==='string'&&r.blockedReason.trim())))process.exit(1)\". Persist screenshots/trace/video/logs when actually available. execution.md must record the executed or blocked steps, base URL safety decision, fixture/reset and request-observation availability, and evidence file list. A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
+          "outputContract": "Compact JSON <=1200 chars.",
+          "writePolicy": "exclusive",
+          "allowedPaths": [
+            "testcase/frontend/cases/{{case.caseId}}.md",
+            "testcase/frontend/rag/context.md",
+            "testcase/frontend/rag/coverage-map.md",
+            "testcase/frontend/evidence/{{case.caseId}}/**"
+          ],
+          "forbiddenPaths": [
+            ".harness/**",
+            "artifacts/**"
+          ],
+          "writeSet": [
+            "testcase/frontend/evidence/{{case.caseId}}/**"
+          ]
+        }
+      }
+    },
+    {
+      "id": "validate-frontend-case-evidence-shell",
+      "depends_on": [
+        "execute-frontend-cases-map"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/cases/**",
+        "testcase/frontend/evidence/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Deterministic validation that every manifest case has execution.md and valid matching case-result.json; blocked results require blockedReason.",
+      "subtask_prompt": "Validate all frontend case evidence before evidence review; fail closed on missing or malformed records.",
+      "shell": {
+        "commands": [
+          "node -e \"const fs=require('fs'),path=require('path');const file='testcase/frontend/cases/manifest.json';if(!fs.existsSync(file))throw new Error('missing '+file);const manifest=JSON.parse(fs.readFileSync(file,'utf8'));const statuses=new Set(['passed','failed','blocked']);let failed=false;for(const c of manifest.cases||[]){const dir=c&&c.evidenceDir;const execution=path.join(dir||'','execution.md'),resultPath=path.join(dir||'','case-result.json');if(!c||typeof c.caseId!=='string'||typeof dir!=='string'||path.isAbsolute(dir)||dir.includes('..')||!fs.existsSync(execution)||!fs.existsSync(resultPath)){failed=true;continue;}let r;try{r=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch{failed=true;continue;}if(!r||r.caseId!==c.caseId||!statuses.has(r.status)||!Array.isArray(r.evidencePaths)||(r.status==='blocked'&&!(typeof r.blockedReason==='string'&&r.blockedReason.trim())))failed=true;}if(failed)process.exit(1);\""
+        ],
+        "cwd": ".",
+        "timeoutMs": 120000
+      }
+    },
+    {
+      "id": "finalize-frontend-test-result-shell",
+      "depends_on": [
+        "validate-frontend-case-evidence-shell"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/cases/**",
+        "testcase/frontend/evidence/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Run-owned hash-bound frontend-test-result-v1 from manifest and validated evidence.",
+      "subtask_prompt": "Materialize the authoritative frontend-test-result-v1; never consume Pi prose.",
+      "shell": {
+        "commands": [],
+        "jsonArtifactGate": {
+          "fromNodeId": "validate-frontend-case-evidence-shell",
+          "schemaId": "frontend-test-result-v1",
+          "artifactName": "frontend-test-result.json",
+          "outputDir": "contracts"
+        },
+        "cwd": ".",
+        "timeoutMs": 120000
+      }
+    },
+    {
+      "id": "frontend-outcome-gate-shell",
+      "depends_on": [
+        "finalize-frontend-test-result-shell"
+      ],
+      "executor": "shell",
+      "role": "verifier",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Pass only for a real passed frontend-test-result-v1.",
+      "subtask_prompt": "Fail closed unless the final frontend test result records a real pass.",
+      "shell": {
+        "commands": [
+          "test -n \"${HARNESS_DAG_RUN_DIR:-}\" || { echo \"missing HARNESS_DAG_RUN_DIR for frontend-test outcome gate\" >&2; exit 2; }; RESULT=\"${HARNESS_DAG_RUN_DIR}/contracts/frontend-test-result.json\"; test -f \"${RESULT}\" || { echo \"missing frontend-test result: ${RESULT}\" >&2; exit 2; }; node -e 'const fs=require(\"fs\");const r=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\"));const ok=r.outcome===\"passed\"&&r.integrationMode===\"real\"&&Number(r.totals?.failed||0)===0&&Number(r.totals?.blocked||0)===0&&Array.isArray(r.acceptanceCoverage?.missing)&&r.acceptanceCoverage.missing.length===0;if(!ok)process.exit(1);' \"${RESULT}\""
+        ],
+        "cwd": ".",
+        "timeoutMs": 60000
+      }
+    },
+    {
+      "id": "review-frontend-execution-pi",
+      "depends_on": [
+        "frontend-outcome-gate-shell"
+      ],
+      "executor": "pi",
+      "role": "reviewer",
+      "complexity": "HIGH",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/frontend/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "AC-to-case-to-browser-evidence review.",
+      "subtask_prompt_markdown": "./frontend-test-dag.review-execution.prompt.md"
+    },
+    {
+      "id": "frontend-test-retrospect-pi",
+      "depends_on": [
+        "review-frontend-execution-pi"
+      ],
+      "executor": "pi",
+      "role": "closeout",
+      "toolProfile": "write",
+      "complexity": "MED",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/reports/**"
+      ],
+      "allowedPaths": [
+        "testcase/frontend/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Write testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
+      "subtask_prompt": "Write the frontend test retrospective under testcase/frontend/reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed. Do not write docs/**."
+    }
   ]
 }

package/docs/templates/frontend-test-dag.retrospect.prompt.md

@@ -1,3 +1,3 @@
 # Frontend test retrospective
 
-Write a dated report under `docs/test-reports/` covering case coverage, passed/failed/blocked results, review findings, browser anomalies, residual risks, and an A/B/C/D maturity rating. Blocked cases never count as passed.
+Write a dated report under `testcase/frontend/reports/` covering case coverage, passed/failed/blocked results, review findings, browser anomalies, residual risks, and an A/B/C/D maturity rating. Cite the deterministic case-evidence validation outcome. Blocked cases never count as passed; a missing or malformed `execution.md` / `case-result.json` is a verification gap, not a pass. Do not write under `docs/**`.

package/docs/templates/frontend-test-dag.review-cases.prompt.md

@@ -1,3 +1,5 @@
 # Review frontend cases
 
-Read the RAG files and Markdown cases only. First line must be `VERDICT: pass` or `VERDICT: request-revision`. Report AC coverage, case independence, evidence completeness, unsafe environment/data dependencies, and manifest issues. The verdict is advisory and does not block browser execution.
+Read the RAG files and Markdown cases only. First line must be `VERDICT: pass` or `VERDICT: request-revision`. Report AC coverage, case independence, evidence completeness, unsafe environment/data dependencies, and manifest issues. This verdict is a deterministic safety gate: `request-revision` blocks manifest materialization and browser execution.
+
+Every case must retain the exact browser-start command prefix `playwright-cli open --browser=chrome --headed <base-url>`; session flags must not precede `open`, and subsequent commands must remain in its default session without `-s=` or assumed named-session binding. Verify every executable sub-scenario specifies fixture/reset, UI reset, fresh snapshot before element refs, and an evidence write point. Verify each case requires both `execution.md` and `case-result.json` under its own evidence directory. The JSON result must contain matching `caseId`, `status` (`passed`, `failed`, or `blocked`) and `evidencePaths`; blocked cases must name a non-empty `blockedReason` and cannot count as passed.

package/docs/templates/frontend-test-dag.review-execution.prompt.md

@@ -1,3 +1,3 @@
 # Review frontend execution evidence
 
-Review AC → case → browser-evidence traceability. A passed case needs assertions and screenshot or equivalent browser evidence. Failed and blocked cases need an explicit cause. Treat `token-budget-exhausted` as blocked; do not substitute model conclusions or static checks for browser evidence.
+Review AC → case → browser-evidence traceability only after deterministic evidence validation. Each manifest case must have `execution.md` and a valid `case-result.json` with matching `caseId`, `status`, and `evidencePaths`; `blocked` requires a non-empty `blockedReason`. A passed case additionally needs assertions and screenshot or equivalent browser evidence. Failed and blocked cases need an explicit cause. Treat `token-budget-exhausted` as blocked; do not substitute model conclusions or static checks for browser evidence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.16.15",
+  "version": "0.16.16",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",