@tea-agent/loop-agent 0.16.23 → 0.16.24

package/CHANGELOG.md

@@ -1,20 +1,9 @@
-# 更新日志
-
 ## [Unreleased]
 
-### 修复
-
-- Backend-test 唯一 JSON object 提取器在扫描裸对象前会等长忽略完整 Markdown 行内代码中的对象形状示例（如 `{error:{code,message,type}}`）；唯一真实 envelope 可正常物化，多个真实 JSON、fence 外额外对象与未闭合对象继续 fail-closed。
-
-- Backend-test 节点 10 `backend-test-semantic-gate-shell` 不再用 Markdown `first-verdict-line` 读取 raw Pi 输出；改为同一 `semantic-initial` pipeline 按 task id 只读 `contracts/backend-test-semantic-review.json`，仅 `verdict=pass` 放行 pytest，`request-revision`/缺失/malformed 清晰 fail-closed；节点 09 仍只负责 materialize+trace，15 节点与单次 pytest 不变。
-- 公开 Case Manifest schema（`docs/templates/backend-test-case-manifest.schema.json`）对齐 materializer dual-scope coverage：`coverageSummary` 在 `additionalProperties:false` 下 required 并声明 `global`/`inScope`（`total`/`covered`/`gapped`/`ratio`）与 `crossDomainGapCount`；回归测试以无依赖轻量 contract 锁定 schema↔canonical 一致性；不改 materializer/15 节点。
-- Backend-test Case Manifest materializer 将模型顶层 `coverageSummary` 视为非权威：secret 扫描后剥离，再 strict parse 其余字段，并始终 `computeCaseManifestCoverageSummary` 写入 canonical summary；my-webapp 自定义/部分 summary 不再导致 invalid-output；prompt 禁止模型输出 coverageSummary；15 节点与单次 pytest 不变。
-- Backend-test 裸 object 路径现消费 scanner 的 `unclosedObject`：当文本含一个完整裸 JSON object，且其前或后仍有未闭合裸 object 时一律 fail-closed，不再因 `spans.length === 1` 错误接受完整对象；Semantic Review / Classification / contracts envelope 共用该行为。
-- Backend-test contracts composite pipeline （`validate-backend-test-contracts-shell`） 使用唯一确定性 envelope 提取：接受 pure JSON、唯一 fenced json、prose+唯一 fence、prose+唯一括号平衡裸 object；对无 JSON、多候选、未闭合、非 object、缺 `analysis`/`execution` fail-closed。提取后仍走 Analysis v2 / Execution v1 schema、source-binding 与 secret 门禁；不引入全局 Pi output rewrite，不将 `invalid-output` 加入自动 retry，不改 15 节点拓扑。
-- Backend-test Semantic Review（08→09）与 Classification（12→13）materializer 复用同一 `extractUniqueJsonObject` scanner：接受 pure / whole-fence / prose+唯一 fence / prose+唯一裸 object；多候选、未闭合、非 object 与 strict schema 错误继续 fail-closed；不改 Case Manifest、Pi SDK/retry 或 15 节点拓扑。
-
 ### 改进
 
+- GitHub Actions CI 降低私有仓分钟消耗：合并为单 job（避免两次 `npm ci`）、同分支/`PR` concurrency 取消旧 run、Draft PR 跳过完整 CI，且仅忽略 `docs/reports/**`、`docs/progress/**`、`docs/design/archive/**`、`docs/exec-plans/completed/**` 等纯运营文档路径；治理文档与代码门禁仍全量跑。
+- 明确 **Compatibility / Operator Assist**：openCode 等主会话只编排已发布 `loop-agent` / `agent-worker` CLI 与只读诊断，不得绕过 CLI 直接改业务实现，失败只走 doctor / reconcile / human gate / CLI 重跑。`loop-agent init` 写入的 `AGENTS.md` managed block、包内 skills 与 website 快速开始/治理说明已对齐；架构决策见 `docs/decisions/0005-governed-operator-surface.md`（accepted）。已有目标项目用 `loop-agent init check-update` / `init update --apply-safe` 或 `init reconcile` 刷新 managed block。
 - 前端测试 DAG 收紧体验：execution preflight 仅硬校验绝对非生产 `baseUrl`；用例 map 缩短为优先用 `playwright-cli` 执行；复盘合并执行证据审查且不依赖 outcome=pass，失败也能出报告。
 - 前端测试用例生成现在会解析明确 `baseUrl`：优先读取任务源 `config.md` 中的前端 URL，缺失时默认 `http://localhost:5173`，并写入 RAG `context.md`；生成命令不得再保留 `<base-url>` 占位符。
 - 前端浏览器测试 DAG 的复盘报告现写入 `testcase/frontend/reports/**`，不再要求 `docs/test-reports/**` 权限；任务执行约束可以安全禁止整个 `docs/**`，同时仍保留可审计的测试资产。
@@ -26,6 +15,15 @@
 
 ### 修复
 
+- Backend-test Analysis v2 intake 现在可确定性归一化模型常见的外部依赖 `type` / `target` 与风险 `type` 字段：dependency `target` 映射为 canonical `name`，扩展字段不落盘；dependency/risk 仍使用类别化白名单，未知字段和 `risks[].target` 继续 fail-closed，避免节点 02 因合法近似形态过早中断。
+
+- Backend-test 唯一 JSON object 提取器在扫描裸对象前会等长忽略完整 Markdown 行内代码中的对象形状示例（如 `{error:{code,message,type}}`）；唯一真实 envelope 可正常物化，多个真实 JSON、fence 外额外对象与未闭合对象继续 fail-closed。
+- Backend-test 节点 10 `backend-test-semantic-gate-shell` 不再用 Markdown `first-verdict-line` 读取 raw Pi 输出；改为同一 `semantic-initial` pipeline 按 task id 只读 `contracts/backend-test-semantic-review.json`，仅 `verdict=pass` 放行 pytest，`request-revision`/缺失/malformed 清晰 fail-closed；节点 09 仍只负责 materialize+trace，15 节点与单次 pytest 不变。
+- 公开 Case Manifest schema（`docs/templates/backend-test-case-manifest.schema.json`）对齐 materializer dual-scope coverage：`coverageSummary` 在 `additionalProperties:false` 下 required 并声明 `global`/`inScope`（`total`/`covered`/`gapped`/`ratio`）与 `crossDomainGapCount`；回归测试以无依赖轻量 contract 锁定 schema↔canonical 一致性；不改 materializer/15 节点。
+- Backend-test Case Manifest materializer 将模型顶层 `coverageSummary` 视为非权威：secret 扫描后剥离，再 strict parse 其余字段，并始终 `computeCaseManifestCoverageSummary` 写入 canonical summary；my-webapp 自定义/部分 summary 不再导致 invalid-output；prompt 禁止模型输出 coverageSummary；15 节点与单次 pytest 不变。
+- Backend-test 裸 object 路径现消费 scanner 的 `unclosedObject`：当文本含一个完整裸 JSON object，且其前或后仍有未闭合裸 object 时一律 fail-closed，不再因 `spans.length === 1` 错误接受完整对象；Semantic Review / Classification / contracts envelope 共用该行为。
+- Backend-test contracts composite pipeline （`validate-backend-test-contracts-shell`） 使用唯一确定性 envelope 提取：接受 pure JSON、唯一 fenced json、prose+唯一 fence、prose+唯一括号平衡裸 object；对无 JSON、多候选、未闭合、非 object、缺 `analysis`/`execution` fail-closed。提取后仍走 Analysis v2 / Execution v1 schema、source-binding 与 secret 门禁；不引入全局 Pi output rewrite，不将 `invalid-output` 加入自动 retry，不改 15 节点拓扑。
+- Backend-test Semantic Review（08→09）与 Classification（12→13）materializer 复用同一 `extractUniqueJsonObject` scanner：接受 pure / whole-fence / prose+唯一 fence / prose+唯一裸 object；多候选、未闭合、非 object 与 strict schema 错误继续 fail-closed；不改 Case Manifest、Pi SDK/retry 或 15 节点拓扑。
 - 节点检查器「执行过程」中的事件时间戳现在同时显示本地日期与 24 小时制 `HH:mm:ss`（例如 `2026/7/16 08:09:10`），不再被裁掉时间部分；缺少时间戳时仍显示「未记录时间」，事件字段优先级（`timestamp` → `at` → `recordedAt`）保持不变。
 - `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，避免模型猜测字段导致契约门禁失败。
@@ -37,6 +35,17 @@
 - Pi SDK 执行长推理或大段结构化输出时不再把高频流式增量事件无界累积到内存；同一响应在多个生命周期事件中重复出现的 Token 用量只统计一次，避免 `Invalid string length` 和成本数据虚高。
 - 后端测试复合执行节点继续保持 clean environment、失败分类和 fail-closed outcome，并为唯一 JUnit/initial Result、canonical Result、traceability 与 Observe 投影保留结构化运行证据。
 
+## [0.16.24] - 2026-07-21
+
+### 改进
+
+- frontend-test 默认改为**短链 RAG**：`reviewMode` 默认 `off`（机械 `frontend-case-checklist-shell` 放行，不再默认双轮 LLM review 硬门）；`strictOutcomeGate` 默认 `false`（outcome 全绿门 opt-in）。**流程验收=最终 retrospect 报告**，不以 case 100% 通过为条件。map 仅在 `dynamicExpansion.tolerateChildFailures=true`（frontend-test 默认开启）时将 child auth/timeout/executor 错误落 case-level blocked/failed evidence 且不炸 map closeout；其它 map 仍 fail-closed。
+- Shell `verdictGate` 改为纯 `node -e` 单次调用，降低 Windows Git Bash 复合脚本崩溃风险。
+
+### 修复
+
+- Windows DAG Shell/verification 的 clean environment 现在保留 `APPDATA`，使 Python 3.12/pip 可按系统规则发现用户级 `site-packages` 与其中的 pytest；仍不会继承完整宿主环境或透传未授权 token/credential，backend-test 无需硬编码用户路径。
+
 ## [0.16.23] - 2026-07-21
 
 ### 修复

package/dist/executors/shell-presets.js

@@ -12,13 +12,6 @@ export function expandShellPreset(preset) {
 function escapeShellSingleQuoted(value) {
     return value.replace(/'/g, "'\\''");
 }
-const VERDICT_GATE_NODE_PARSER_FIRST_NON_EMPTY = 'node -e \'const fs=require("fs"); const raw=JSON.parse(fs.readFileSync(process.argv[1], "utf8")); const text=raw.assistantText ?? raw.stdout ?? ""; const line=String(text).split(/\\r?\\n/).find((value) => value.trim().length > 0) ?? ""; process.stdout.write(line);\' "${FILE}" || true';
-const VERDICT_GATE_NODE_PARSER_FIRST_VERDICT_LINE = 'node -e \'const fs=require("fs"); const raw=JSON.parse(fs.readFileSync(process.argv[1], "utf8")); const text=raw.assistantText ?? raw.stdout ?? ""; const normalize=(value) => { const trimmed=String(value).trim(); const emphasized=trimmed.match(/^\\*{1,3}\\s*(VERDICT:[^*]+?)\\s*\\*{1,3}$/); return (emphasized ? emphasized[1] : trimmed).trim(); }; const line=String(text).split(/\\r?\\n/).map(normalize).find((value) => /^VERDICT:/.test(value)) ?? ""; process.stdout.write(line);\' "${FILE}" || true';
-function verdictGateNodeParser(lineMode) {
-    return lineMode === "first-verdict-line"
-        ? VERDICT_GATE_NODE_PARSER_FIRST_VERDICT_LINE
-        : VERDICT_GATE_NODE_PARSER_FIRST_NON_EMPTY;
-}
 /**
  * Build a single shell command that reads `$HARNESS_DAG_RUN_DIR/<fromNodeId>.json`
  * (injected by the shell executor from runtime meta), parses a single candidate
@@ -27,33 +20,41 @@ function verdictGateNodeParser(lineMode) {
  * - first-non-empty: first non-empty line
  * - first-verdict-line: first line matching /^VERDICT:/ after trim and optional whole-line Markdown emphasis normalization
  *
- * Must stay one command so `shell.commands[]` process isolation cannot drop state variables.
+ * Implemented as one pure `node -e` invocation (no bash state/subshell chaining) so Windows
+ * Git Bash cannot crash the gate with STATUS_DLL_INIT_FAILED on long compound scripts.
  */
 export function buildVerdictGateShellCommand(gate) {
     const gateLabel = gate.label ?? `${gate.fromNodeId} verdict`;
     const lineMode = gate.lineMode ?? "first-non-empty";
-    const parser = verdictGateNodeParser(lineMode);
     const candidateNodeIds = [
         gate.fromNodeId,
         ...(gate.fallbackFromNodeIds ?? []).filter((id) => id !== gate.fromNodeId),
     ];
-    const resolveFile = candidateNodeIds.length === 1
-        ? `FILE="\${HARNESS_DAG_RUN_DIR}/${candidateNodeIds[0]}.json"; test -f "\${FILE}" || { echo "missing ${gateLabel} JSON output: \${FILE}" >&2; exit 1; }`
-        : [
-            "FILE=\"\"",
-            ...candidateNodeIds.map((id) => `if test -z "\${FILE}" && test -f "\${HARNESS_DAG_RUN_DIR}/${id}.json"; then FILE="\${HARNESS_DAG_RUN_DIR}/${id}.json"; fi`),
-            `test -n "\${FILE}" || { echo "missing ${gateLabel} JSON output (tried: ${candidateNodeIds.join(", ")})" >&2; exit 1; }`,
-        ].join("; ");
-    const preamble = `test -n "\${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for ${gateLabel} gate" >&2; exit 1; }; ${resolveFile}; FIRST=$(${parser})`;
-    const blockedMessage = `${gateLabel} gate blocked: \${FIRST:-missing VERDICT line}`;
-    if (gate.accept.length === 1) {
-        const expected = escapeShellSingleQuoted(gate.accept[0]);
-        return `${preamble}; test "\${FIRST}" = '${expected}' || { echo "${blockedMessage}" >&2; exit 1; }`;
-    }
-    const acceptPattern = gate.accept
-        .map((value) => `'${escapeShellSingleQuoted(value)}'`)
-        .join("|");
-    return `${preamble}; case "\${FIRST}" in ${acceptPattern}) exit 0 ;; *) echo "${blockedMessage}" >&2; exit 1 ;; esac`;
+    const config = {
+        label: gateLabel,
+        lineMode,
+        accept: gate.accept,
+        candidateNodeIds,
+    };
+    const configLiteral = escapeShellSingleQuoted(JSON.stringify(config));
+    const program = [
+        'const fs=require("fs");',
+        'const path=require("path");',
+        'const cfg=JSON.parse(process.argv[1]);',
+        'const runDir=process.env.HARNESS_DAG_RUN_DIR;',
+        'if(!runDir){console.error("missing HARNESS_DAG_RUN_DIR for "+cfg.label+" gate");process.exit(1);}',
+        'let file="";',
+        'for(const id of cfg.candidateNodeIds){const candidate=path.join(runDir,id+".json");if(fs.existsSync(candidate)){file=candidate;break;}}',
+        'if(!file){console.error("missing "+cfg.label+" JSON output (tried: "+cfg.candidateNodeIds.join(", ")+")");process.exit(1);}',
+        'const raw=JSON.parse(fs.readFileSync(file,"utf8"));',
+        'const text=String(raw.assistantText ?? raw.stdout ?? "");',
+        'const normalize=(value)=>{const trimmed=String(value).trim();const emphasized=trimmed.match(/^\\*{1,3}\\s*(VERDICT:[^*]+?)\\s*\\*{1,3}$/);return (emphasized?emphasized[1]:trimmed).trim();};',
+        'const lines=text.split(/\\r?\\n/).map(normalize);',
+        'const first=cfg.lineMode==="first-verdict-line"? (lines.find((value)=>/^VERDICT:/.test(value))??"") : (lines.find((value)=>value.length>0)??"");',
+        'if(!cfg.accept.includes(first)){console.error(cfg.label+" gate blocked: "+(first||"missing VERDICT line"));process.exit(1);}',
+        'process.stdout.write(first+"\\n");',
+    ].join("");
+    return `node -e '${escapeShellSingleQuoted(program)}' '${configLiteral}'`;
 }
 /** Build a deterministic current-run gate over exact REQ-/BR-/AC- ids in node facts. */
 export function buildRequirementCoverageGateShellCommand(gate) {

package/dist/executors/shell-verification.js

@@ -27,6 +27,8 @@ const VERIFY_ENV_ALLOWLIST = [
     "WINDIR",
     "ComSpec",
     "PATHEXT",
+    // Python/pip and other Windows per-user tools discover user installs here.
+    "APPDATA",
 ];
 export function buildVerifyProcessEnv(mode = "clean") {
     if (mode === "inherit") {

package/dist/task/config-types.js

@@ -65,12 +65,24 @@ export const frontendMockConfigSchema = z.object({
     serviceRoot: z.string().min(1).optional(),
     verifyCommands: z.array(frontendMockVerifyCommandSchema).optional().default([]),
 });
-/** Batch limits for the browser-driven frontend test DAG. These are post-case
- * stop thresholds, not model-provider hard token caps. */
+/** Batch limits and gate profile for the browser-driven frontend test DAG.
+ * Token fields are post-case stop thresholds, not model-provider hard caps. */
 export const frontendTestConfigSchema = z.object({
-    maxCasesPerBatch: z.number().int().min(1).max(50).optional().default(20),
+    maxCasesPerBatch: z.number().int().min(1).max(50).optional(),
     maxTokensPerCase: z.number().int().positive().optional(),
     maxTotalTokens: z.number().int().positive().optional(),
+    /**
+     * Case review topology:
+     * - off (default): mechanical checklist-shell only; no LLM review hard gate
+     * - advisory: reserved (same default path as off for now; LLM notes non-blocking)
+     * - blocking: legacy dual-review + final VERDICT: pass gate before materialize
+     */
+    reviewMode: z.enum(["off", "advisory", "blocking"]).optional(),
+    /**
+     * When true, include quality outcome gate (all cases passed, 0 blocked).
+     * Default false: pipeline success is result materialize + retrospect report, not full green.
+     */
+    strictOutcomeGate: z.boolean().optional(),
 });
 export const convergenceConfigSchema = z.object({
     enabled: z.boolean().optional().default(false),

package/dist/workflows/dag/backend-test-analysis-contract.js

@@ -299,7 +299,7 @@ function coerceBoundary(value) {
         return null;
     return { field, constraint, sourceRef: firstSourceRef(record) };
 }
-const OPTIONAL_EVIDENCE_KNOWN_KEYS = new Set([
+const OPTIONAL_EVIDENCE_BASE_KEYS = [
     "name",
     "id",
     "description",
@@ -308,21 +308,33 @@ const OPTIONAL_EVIDENCE_KNOWN_KEYS = new Set([
     "title",
     "sourceRef",
     "sourceRefs",
+];
+const EXTERNAL_DEPENDENCY_INPUT_KEYS = new Set([
+    ...OPTIONAL_EVIDENCE_BASE_KEYS,
+    "type",
+    "target",
+    "kind",
+    "required",
+]);
+const RISK_INPUT_KEYS = new Set([
+    ...OPTIONAL_EVIDENCE_BASE_KEYS,
+    "type",
     "severity",
     "mitigation",
     "level",
     "impact",
-    "kind",
-    "required",
 ]);
-function coerceOptionalEvidence(value) {
+function coerceOptionalEvidence(value, kind) {
     const record = asRecord(value);
     if (!record)
         return null;
+    const knownKeys = kind === "external-dependency"
+        ? EXTERNAL_DEPENDENCY_INPUT_KEYS
+        : RISK_INPUT_KEYS;
     // Fail closed on unknown keys so near-schema payloads cannot strip extras and pass.
     for (const key of Object.keys(record)) {
-        if (!OPTIONAL_EVIDENCE_KNOWN_KEYS.has(key)) {
-            throw new Error(`optional evidence has unrecognized key: ${key}`);
+        if (!knownKeys.has(key)) {
+            throw new Error(`${kind} evidence has unrecognized key: ${key}`);
         }
     }
     const description = (typeof record.description === "string" && record.description.trim()) ||
@@ -334,6 +346,7 @@ function coerceOptionalEvidence(value) {
         return null;
     const out = { description };
     const name = (typeof record.name === "string" && record.name.trim()) ||
+        (kind === "external-dependency" && typeof record.target === "string" && record.target.trim()) ||
         (typeof record.id === "string" && record.id.trim()) ||
         "";
     if (name)
@@ -385,10 +398,10 @@ export function coerceBackendTestAnalysisInput(value) {
         .map(coerceBoundary)
         .filter((item) => item !== null);
     next.externalDependencies = asArray(record.externalDependencies)
-        .map(coerceOptionalEvidence)
+        .map((item) => coerceOptionalEvidence(item, "external-dependency"))
         .filter((item) => item !== null);
     next.risks = asArray(record.risks)
-        .map(coerceOptionalEvidence)
+        .map((item) => coerceOptionalEvidence(item, "risk"))
         .filter((item) => item !== null);
     next.evidenceGaps = asArray(record.evidenceGaps)
         .map(coerceEvidenceGap)

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

@@ -81,27 +81,77 @@ export function resolveRunLocalPath(runDir, ref, label) {
     }
     return resolved;
 }
+function resolveCaseIdFromItem(item) {
+    if (typeof item === "object" &&
+        item !== null &&
+        typeof item.caseId === "string") {
+        return item.caseId;
+    }
+    return String(item);
+}
+async function materializeBlockedCaseEvidence(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 = resolveCaseIdFromItem(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 finished a business result.
+    }
+    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: blocked\n\nReason: ${input.reason}\n`, "utf-8");
+    await writeFile(resultPath, `${JSON.stringify({
+        caseId,
+        status: "blocked",
+        blockedReason: input.reason,
+        evidencePaths: ["execution.md"],
+    }, null, 2)}\n`, "utf-8");
+}
 async function materializeTokenBudgetBlockedEvidence(input) {
+    await materializeBlockedCaseEvidence({
+        ...input,
+        reason: "token-budget-exhausted",
+    });
+}
+async function materializeFailedCaseEvidence(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);
+    const caseId = resolveCaseIdFromItem(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"))
+            (existing.status === "passed" ||
+                existing.status === "failed" ||
+                existing.status === "blocked"))
             return;
     }
     catch {
-        // Missing or malformed evidence is replaced only for a child that never started.
+        // Missing or malformed evidence is replaced only when the child never finished a business result.
     }
-    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");
+    await writeFile(path.join(workspace, "execution.md"), `# ${caseId}\n\nStatus: failed\n\nReason: ${input.reason}\n`, "utf-8");
+    await writeFile(resultPath, `${JSON.stringify({
+        caseId,
+        status: "failed",
+        errorSummary: input.reason,
+        evidencePaths: ["execution.md"],
+    }, null, 2)}\n`, "utf-8");
+}
+/** Provider auth/timeout on a FE case child is infrastructure, not a product fail; keep the map aggregate. */
+function isInfrastructureCaseChildFailure(record) {
+    if (!record || record.status === "FINISHED")
+        return false;
+    return record.failureCategory === "auth" || record.failureCategory === "timeout";
 }
 export async function executeDynamicMapExpansion(input) {
     const started = Date.now();
@@ -264,15 +314,64 @@ export async function executeDynamicMapExpansion(input) {
             tokenBudgetExhausted = true;
         }
     }
+    // Opt-in (frontend-test via tolerateChildFailures): materialize case-level
+    // failed/blocked evidence and keep the map barrier green so validate /
+    // result / retrospect can still run. Default maps stay fail-closed on child ERROR.
+    const tolerateChildFailures = input.expansion.tolerateChildFailures === true;
+    const caseOutcomeNotes = [];
+    if (tolerateChildFailures) {
+        for (let index = 0; index < childNodeIds.length; index += 1) {
+            const nodeId = childNodeIds[index];
+            const record = input.state.nodes[nodeId];
+            if (!record || record.status === "FINISHED")
+                continue;
+            if (isBudgetBlockedRecord(record))
+                continue;
+            const infra = isInfrastructureCaseChildFailure(record);
+            const reason = infra
+                ? record?.failureCategory === "timeout"
+                    ? "executor-timeout"
+                    : "executor-auth-unavailable"
+                : `executor-error:${record.failureCategory || record.status || "unknown"}`;
+            const outcomeStatus = infra ? "blocked" : "failed";
+            try {
+                if (outcomeStatus === "blocked") {
+                    await materializeBlockedCaseEvidence({
+                        cwd: input.cwd,
+                        workspaceRef: workspaceRefs[index],
+                        item: items[index],
+                        reason,
+                    });
+                }
+                else {
+                    await materializeFailedCaseEvidence({
+                        cwd: input.cwd,
+                        workspaceRef: workspaceRefs[index],
+                        item: items[index],
+                        reason,
+                    });
+                }
+            }
+            catch (error) {
+                throw new Error(`failed to materialize case outcome evidence for ${nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            caseOutcomeNotes.push({ nodeId, reason, status: outcomeStatus });
+            record.status = "FINISHED";
+            record.stderr = `${outcomeStatus}: ${reason}`;
+            record.failureCategory = "success";
+        }
+    }
     const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
-    const failedChildren = childNodeIds.filter((nodeId) => {
-        const record = input.state.nodes[nodeId];
-        if (!record || record.status === "FINISHED")
-            return false;
-        if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
-            return false;
-        return true;
-    });
+    const failedChildren = tolerateChildFailures
+        ? []
+        : childNodeIds.filter((nodeId) => {
+            const record = input.state.nodes[nodeId];
+            if (!record || record.status === "FINISHED")
+                return false;
+            if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
+                return false;
+            return true;
+        });
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
@@ -285,21 +384,29 @@ export async function executeDynamicMapExpansion(input) {
             output: parseJsonFromText(input.state.nodes[nodeId]?.stdout),
             assistantText: input.state.nodes[nodeId]?.assistantText,
             blocked: blockedChildren.find((child) => child.nodeId === nodeId)?.reason ??
+                caseOutcomeNotes.find((child) => child.nodeId === nodeId && child.status === "blocked")
+                    ?.reason ??
                 (isBudgetBlockedRecord(input.state.nodes[nodeId])
                     ? "token-budget-exhausted"
                     : undefined),
+            failed: caseOutcomeNotes.find((child) => child.nodeId === nodeId && child.status === "failed")
+                ?.reason,
         })),
         tokensUsed: totalTokensUsed,
+        caseOutcomeNotes: caseOutcomeNotes.length > 0 ? caseOutcomeNotes : undefined,
     };
     return {
-        // A post-case token stop is an expected bounded outcome; downstream review
-        // must receive its aggregate rather than be skipped with the map barrier.
-        // Real child failures remain fail-closed even when later cases are budget-blocked.
+        // With tolerateChildFailures: barrier always succeeds; product outcomes live in
+        // case evidence + result materialization. Without it: real child failures fail-close.
         ok: failedChildren.length === 0,
         stdout: JSON.stringify(aggregate),
-        stderr: failedChildren.length > 0
-            ? `dynamic map children failed: ${failedChildren.join(", ")}`
-            : "",
+        stderr: caseOutcomeNotes.length > 0
+            ? `map children recorded as case outcomes: ${caseOutcomeNotes
+                .map((entry) => `${entry.nodeId}=${entry.status}:${entry.reason}`)
+                .join(", ")}`
+            : failedChildren.length > 0
+                ? `dynamic map children failed: ${failedChildren.join(", ")}`
+                : "",
         failureCategory: failedChildren.length > 0 ? "dynamic-expansion-child-failed" : "success",
         durationMs: Date.now() - started,
     };

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

@@ -2546,6 +2546,7 @@ function buildAnalyzeInputsNode(sources) {
             "For every endpoint, explicitly set responseBody.kind=array|object|scalar|empty|unknown and ordering=specified|unspecified|not-applicable. Add itemSchemaRef for arrays when documented.",
             "For response fields, use comparison=exact|parseable-only|semantic when the source defines assertion semantics; date-time fields whose precision is unspecified should use parseable-only, not string equality.",
             "Endpoint sourceRefs and field sourceRefs must cite only requirement/reference evidence actually read. Empty sourceRefs are allowed only when normalizing legacy v1 input; newly generated v2 should cite evidence.",
+            "For externalDependencies and risks, emit canonical items with exactly description plus optional name and sourceRef. For a dependency target, put the target value in name. Do not emit type, target, kind, required, severity, mitigation, level, impact, sourceRefs, or custom keys in newly generated v2 output.",
             "Use empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.",
             "Required top-level keys: schemaVersion=2, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.",
             "Read-only: do not modify code, docs, artifacts, or repository files.",
@@ -3312,7 +3313,17 @@ function buildBackendTestHybridDag(sources) {
 // Frontend browser-test RAG DAG template
 // ---------------------------------------------------------------------------
 function buildFrontendTestHybridDag(sources) {
-    const config = sources.taskConfig.frontendTest ?? { maxCasesPerBatch: 20 };
+    const rawFrontendTest = sources.taskConfig.frontendTest;
+    const config = {
+        maxCasesPerBatch: rawFrontendTest?.maxCasesPerBatch ?? 20,
+        maxTokensPerCase: rawFrontendTest?.maxTokensPerCase,
+        maxTotalTokens: rawFrontendTest?.maxTotalTokens,
+        reviewMode: rawFrontendTest?.reviewMode ?? "off",
+        strictOutcomeGate: rawFrontendTest?.strictOutcomeGate === true,
+    };
+    const reviewMode = config.reviewMode;
+    const blockingReview = reviewMode === "blocking";
+    const strictOutcomeGate = config.strictOutcomeGate;
     const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
         pattern === "testcase/**" ||
         pattern === "**");
@@ -3323,6 +3334,36 @@ function buildFrontendTestHybridDag(sources) {
     const ragWriteSet = ["testcase/frontend/rag/**"];
     const casesWriteSet = ["testcase/frontend/cases/**"];
     const evidenceRoot = "testcase/frontend/evidence";
+    const checklistValidation = [
+        "node -e",
+        JSON.stringify([
+            "const fs=require('fs'),path=require('path');",
+            "const root='testcase/frontend/cases';",
+            "const draft=path.join(root,'manifest.draft.json');",
+            "const final=path.join(root,'manifest.json');",
+            "const manifestPath=fs.existsSync(draft)?draft:(fs.existsSync(final)?final:null);",
+            "if(!manifestPath)throw new Error('checklist: missing manifest.draft.json or manifest.json');",
+            "const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));",
+            "if(!Array.isArray(manifest.cases)||manifest.cases.length===0)throw new Error('checklist: empty cases');",
+            "const issues=[];",
+            "const openRe=/playwright-cli\\s+open\\s+--browser=chrome\\s+--headed\\s+https?:\\/\\/\\S+/i;",
+            "const prodRe=/(?:^|\\/\\/)(?:www\\.)?[^\\s\\/]*(?:prod|production)/i;",
+            "const codeRe=/\\b(pytest|playwright\\.test|@playwright\\/test)\\b/i;",
+            "for(const c of manifest.cases){",
+            " const id=c&&c.caseId||'?';",
+            " const casePath=typeof c.casePath==='string'?c.casePath:null;",
+            " if(!casePath||!fs.existsSync(casePath)){issues.push({ruleId:'case-file-missing',caseId:id,detail:String(casePath)});continue;}",
+            " const body=fs.readFileSync(casePath,'utf8');",
+            " if(!openRe.test(body))issues.push({ruleId:'open-prefix',caseId:id,detail:'missing playwright-cli open --browser=chrome --headed <absolute-url>'});",
+            " const m=body.match(/playwright-cli\\s+open\\s+--browser=chrome\\s+--headed\\s+(https?:\\/\\/\\S+)/i);",
+            " if(m){const url=m[1].replace(/[)\\]},.\"']+$/,''); if(prodRe.test(url))issues.push({ruleId:'production-url',caseId:id,detail:url});}",
+            " if(codeRe.test(body))issues.push({ruleId:'no-test-source',caseId:id,detail:'pytest/playwright test source forbidden'});",
+            " if(!Array.isArray(c.acIds)||c.acIds.length===0)issues.push({ruleId:'ac-mapping',caseId:id,detail:'acIds required'});",
+            "}",
+            "if(issues.length){console.error('frontend-test checklist blocked: '+JSON.stringify(issues)); process.exit(1);}",
+            "console.log('frontend-test checklist ok cases='+manifest.cases.length+' source='+path.basename(manifestPath));",
+        ].join("")),
+    ].join(" ");
     const manifestValidation = [
         "node -e",
         JSON.stringify([
@@ -3338,7 +3379,6 @@ 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 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);",
@@ -3360,6 +3400,290 @@ function buildFrontendTestHybridDag(sources) {
         ].join("")),
     ].join(" ");
     const frontendTestOutcomeGate = buildFrontendTestOutcomeGateShellSnippet();
+    const tasks = [
+        {
+            id: "retrieve-frontend-test-context-pi",
+            depends_on: [],
+            role: "planner",
+            executor: "pi",
+            toolProfile: "write",
+            complexity: "MED",
+            writePolicy: "exclusive",
+            writeSet: ragWriteSet,
+            allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet],
+            forbiddenPaths: forbidden,
+            outputContract: "Write short testcase/frontend/rag/context.md and coverage-map.md with machine-readable baseUrl and capability notes.",
+            subtask_prompt: [
+                "Build the frontend test RAG package (keep it short).",
+                "Read task source, routes/components/API or Mock facts, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.",
+                "Prefer fixed fields: baseUrl, baseUrlSource, AC table, capability matrix (backend real/mock, pagination data, HTTP observation, error injection), risks, forbidden hosts. Do not paste large implementation dumps.",
+                "Base URL resolution (required): (1) Prefer absolute http(s) frontend URL from task source config.md. (2) Else default http://localhost:5173. (3) Never production hosts. (4) Write `baseUrl: <url>` and `baseUrlSource: config.md|<path>|default-localhost-5173`. (5) Include exact start prefix: playwright-cli open --browser=chrome --headed <resolved-base-url>.",
+                buildSourceContextBlock(sources),
+            ].join("\n\n"),
+        },
+        {
+            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: absolute non-production baseUrl required; fixture/reset not hard-gated.",
+            subtask_prompt: "Hard-validate only an absolute non-production baseUrl in RAG context (from config.md or default http://localhost:5173). Fixture/reset and other isolation details are soft guidance for later nodes, not preflight failures.",
+            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 patterns=[ /baseUrl\\s*[:=]\\s*(https?:\\/\\/\\S+)/i, /base[- ]url\\s*[:=]\\s*(https?:\\/\\/\\S+)/i, /playwright-cli open --browser=chrome --headed\\s+(https?:\\/\\/\\S+)/i, /(https?:\\/\\/(?:localhost|127\\.0\\.0\\.1)[^\\s)\\]},\"']*)/i ]; let baseUrl=null; for(const re of patterns){const m=s.match(re); if(m){baseUrl=m[1]; break;}} if(!baseUrl)throw new Error('frontend-test preflight missing absolute baseUrl (prefer config.md; default http://localhost:5173)'); baseUrl=baseUrl.replace(/[)\\]},.\"']+$/,''); if(!/^https?:\\/\\//i.test(baseUrl))throw new Error('baseUrl must be absolute http(s): '+baseUrl); if(/(?:^|\\/\\/)(?:www\\.)?[^\\s/]*(?:prod|production)/i.test(baseUrl))throw new Error('production URL forbidden: '+baseUrl); console.log('frontend-test-execution-v1 validated baseUrl='+baseUrl);"),
+                    ].join(" "),
+                ],
+                cwd: ".",
+                timeoutMs: 60000,
+            },
+        },
+        {
+            id: "generate-frontend-functional-cases-pi",
+            depends_on: ["materialize-frontend-test-execution-shell"],
+            role: "implementer",
+            executor: "pi",
+            toolProfile: "write",
+            complexity: "HIGH",
+            writePolicy: "exclusive",
+            writeSet: casesWriteSet,
+            allowedPaths: [...ragWriteSet, ...casesWriteSet],
+            forbiddenPaths: forbidden,
+            outputContract: "Write executable Markdown frontend cases, index.md, and manifest.draft.json schemaVersion 1; no test source code.",
+            subtask_prompt: [
+                "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.draft.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.",
+                "Prefer a small smoke suite (default max roughly 4–8 cases unless task frontendTest.maxCasesPerBatch is higher). Never invent unavailable API fields or credentials. Do not create pytest or Playwright source.",
+                "Copy the resolved absolute baseUrl from context.md (baseUrl field; resolved from config.md or default http://localhost:5173). Every browser start command must be: playwright-cli open --browser=chrome --headed <resolved-base-url-from-context.md> with that concrete URL — never leave a <base-url> placeholder. Use default browser session only; never write -s=<case-id>.",
+                "Each case must be independently reproducible with fixture/reset, UI reset, snapshot-before-ref, evidence write point under testcase/frontend/evidence/<case-id>/. If the isolated environment is unavailable, require writing blocked evidence before any browser command.",
+            ].join("\n\n"),
+        },
+    ];
+    if (blockingReview) {
+        tasks.push({
+            id: "review-frontend-cases-pi",
+            depends_on: ["generate-frontend-functional-cases-pi"],
+            role: "reviewer",
+            executor: "pi",
+            complexity: "HIGH",
+            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. request-revision blocks manifest materialization.",
+            subtask_prompt: "Review only the RAG package, frontend Markdown cases, and manifest.draft.json. 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: "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. HARD: Never delete case files; only edit in place or add missing cases. Preserve the full planned suite, index.md, and manifest.draft.json.",
+        }, {
+            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 checklist/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,
+            },
+        });
+    }
+    const checklistDependsOn = blockingReview
+        ? ["final-frontend-case-review-gate-shell"]
+        : ["generate-frontend-functional-cases-pi"];
+    tasks.push({
+        id: "frontend-case-checklist-shell",
+        depends_on: checklistDependsOn,
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: [...ragWriteSet, ...casesWriteSet],
+        forbiddenPaths: forbidden,
+        outputContract: "Mechanical checklist: open-prefix, non-prod absolute URL, acIds, no pytest/playwright test source; emit structured ruleId issues on failure.",
+        subtask_prompt: "Scan generated cases/manifest against the shared blocking checklist. Do not use free-form LLM verdicts.",
+        shell: { commands: [checklistValidation], cwd: ".", timeoutMs: 120000 },
+    }, {
+        id: "materialize-frontend-case-manifest-shell",
+        depends_on: ["frontend-case-checklist-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        writeSet: casesWriteSet,
+        allowedPaths: casesWriteSet,
+        forbiddenPaths: forbidden,
+        outputContract: "Validated frontend manifest payload { cases: [...] }; atomically materialize testcase/frontend/cases/manifest.json from manifest.draft.json; shell output may echo only the prefix before exactly one final JSON line.",
+        subtask_prompt: "Validate manifest.draft.json and materialize manifest.json after the mechanical checklist (and optional blocking review) passes.",
+        shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
+    }, {
+        id: "execute-frontend-cases-map",
+        depends_on: ["materialize-frontend-case-manifest-shell"],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Serial aggregate of case execution summaries, evidence paths, tokens, and token-budget or executor blocked/failed cases.",
+        subtask_prompt: "Expand and execute the validated frontend case manifest serially. Child executor failures become case-level failed/blocked evidence so closeout can still run.",
+        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: config.maxCasesPerBatch,
+            maxExpandedNodes: config.maxCasesPerBatch,
+            childIdPrefix: "execute-frontend-case",
+            workspaceTemplate: "{{case.evidenceDir}}",
+            tolerateChildFailures: true,
+            tokenBudget: {
+                maxTokensPerCase: config.maxTokensPerCase,
+                maxTotalTokens: config.maxTotalTokens,
+            },
+            childTask: {
+                executor: "pi",
+                role: "implementer",
+                skills: ["playwright-cli"],
+                toolProfile: "write",
+                complexity: "MED",
+                writePolicy: "exclusive",
+                allowedPaths: [
+                    "testcase/frontend/cases/{{case.caseId}}.md",
+                    "testcase/frontend/rag/context.md",
+                    "testcase/frontend/rag/coverage-map.md",
+                    `${evidenceRoot}/{{case.caseId}}/**`,
+                ],
+                forbiddenPaths: forbidden,
+                writeSet: [`${evidenceRoot}/{{case.caseId}}/**`],
+                outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, and tokens.",
+                subtaskPromptTemplate: [
+                    "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session; do not use /new). Prefer playwright-cli over prose review.",
+                    "1) Read baseUrl from testcase/frontend/rag/context.md (config.md preferred, else http://localhost:5173). 2) Start browser: playwright-cli open --browser=chrome --headed <resolved-base-url> (default session only; no -s=). 3) Follow the case steps with snapshot before element refs. 4) If env/CLI/baseUrl is unavailable, write blocked evidence and do not open a browser.",
+                    "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json (caseId, status passed|failed|blocked, evidencePaths; blocked needs blockedReason). Then validate: 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)\".",
+                    "Business failed/blocked is a recorded result, not a node failure. Close browser. Return compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
+                ].join("\n\n"),
+            },
+        },
+    }, {
+        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 result materialization; 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,
+        },
+    });
+    if (strictOutcomeGate) {
+        tasks.push({
+            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: "Optional quality gate: pass only when frontend-test-result-v1 is outcome=passed and integrationMode=real with 0 failed/blocked and no missing AC. Does not gate retrospective closeout.",
+            subtask_prompt: "Opt-in Delivery/Worker quality gate (frontendTest.strictOutcomeGate=true). Retrospective does not depend on this node.",
+            shell: { commands: [frontendTestOutcomeGate], cwd: ".", timeoutMs: 60000 },
+        });
+    }
+    tasks.push({
+        id: "frontend-test-retrospect-pi",
+        depends_on: ["materialize-frontend-test-result-shell"],
+        role: "closeout",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/frontend/reports/**"],
+        allowedPaths: ["testcase/frontend/**"],
+        forbiddenPaths: forbidden,
+        outputContract: "Write frontend-test retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, execution evidence review, risks, findings, and A/B/C/D rating — even when outcome is failed/incomplete. Pipeline acceptance = this report exists (not case 100% pass).",
+        subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/ after result materialization (do not wait for outcome=pass). Combine AC→case→browser-evidence review with the closeout report: coverage, passed/failed/blocked (including token-budget-exhausted / executor-auth-unavailable), evidence gaps, browser anomalies, residual risks, and A/B/C/D rating. Passed cases need assertion plus screenshot or equivalent evidence when available; failed/blocked need explicit reasons. Blocked cases never count as passed. Do not replace browser evidence with model conclusions. Do not write docs/**. Pipeline success is report production, not case full green.",
+    });
+    const globalConstraints = [
+        ...sources.taskConfig.hardConstraints,
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        "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 <resolved-base-url>; resolve baseUrl from task source config.md when present, otherwise default http://localhost:5173; generated operations stay in the default browser session and must not use unverified named-session flags.",
+        "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
+        "Pipeline acceptance for frontend-test is the final retrospect report under testcase/frontend/reports/; case pass rate and outcome=passed are quality signals, not the default pipeline success condition.",
+        blockingReview
+            ? "frontendTest.reviewMode=blocking: a frontend case review must emit VERDICT: pass before checklist/manifest materialization; request-revision blocks browser execution."
+            : "frontendTest.reviewMode is off|advisory by default: mechanical checklist-shell gates materialize/execute; LLM review is not a hard browser gate.",
+    ];
     const spec = {
         version: 3,
         title: `Frontend test DAG: ${sources.taskConfig.title}`,
@@ -3367,16 +3691,7 @@ function buildFrontendTestHybridDag(sources) {
         outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
         objective: extractObjective(sources.requirementMarkdown, sources.taskConfig.title),
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
-        globalConstraints: [
-            ...sources.taskConfig.hardConstraints,
-            ...STANDARD_GLOBAL_CONSTRAINTS,
-            "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 <resolved-base-url>; resolve baseUrl from task source config.md when present, otherwise default http://localhost:5173; 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.",
-        ],
+        globalConstraints,
         defaults: {
             ...HYBRID_DEFAULTS,
             skills: [],
@@ -3393,253 +3708,7 @@ function buildFrontendTestHybridDag(sources) {
             closeout: ["verification-before-completion"],
         },
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        tasks: [
-            {
-                id: "retrieve-frontend-test-context-pi",
-                depends_on: [],
-                role: "planner",
-                executor: "pi",
-                toolProfile: "write",
-                complexity: "HIGH",
-                writePolicy: "exclusive",
-                writeSet: ragWriteSet,
-                allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet],
-                forbiddenPaths: forbidden,
-                outputContract: "Write testcase/frontend/rag/context.md and coverage-map.md with traceable UI/API/test-environment facts.",
-                subtask_prompt: [
-                    "Build the frontend test RAG package.",
-                    "Read task source, relevant routes/components/API or Mock facts, existing tests, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.",
-                    "Record AC IDs, source paths, routes, states, roles, fixture/data prerequisites, API mapping status, risks, and isolated execution contract. Do not guess unavailable facts.",
-                    "Base URL resolution (required): (1) Prefer an absolute http(s) frontend URL from task source config.md (source/references/**/config.md or any attached config.md), including keys baseUrl/base_url/frontendBaseUrl/FRONTEND_BASE_URL/url or labeled frontend base URL text. (2) If config.md has no usable absolute URL, default to http://localhost:5173. (3) Never use production hosts. (4) Write both a human-readable base URL line and machine-readable lines `baseUrl: <url>` and `baseUrlSource: config.md|<path>` or `baseUrlSource: default-localhost-5173`. (5) Include the exact browser start prefix with the resolved URL: playwright-cli open --browser=chrome --headed <resolved-base-url>.",
-                    buildSourceContextBlock(sources),
-                ].join("\n\n"),
-            },
-            {
-                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: absolute non-production baseUrl required; fixture/reset not hard-gated.",
-                subtask_prompt: "Hard-validate only an absolute non-production baseUrl in RAG context (from config.md or default http://localhost:5173). Fixture/reset and other isolation details are soft guidance for later nodes, not preflight failures.",
-                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 patterns=[ /baseUrl\\s*[:=]\\s*(https?:\\/\\/\\S+)/i, /base[- ]url\\s*[:=]\\s*(https?:\\/\\/\\S+)/i, /playwright-cli open --browser=chrome --headed\\s+(https?:\\/\\/\\S+)/i, /(https?:\\/\\/(?:localhost|127\\.0\\.0\\.1)[^\\s)\\]},\"']*)/i ]; let baseUrl=null; for(const re of patterns){const m=s.match(re); if(m){baseUrl=m[1]; break;}} if(!baseUrl)throw new Error('frontend-test preflight missing absolute baseUrl (prefer config.md; default http://localhost:5173)'); baseUrl=baseUrl.replace(/[)\\]},.\"']+$/,''); if(!/^https?:\\/\\//i.test(baseUrl))throw new Error('baseUrl must be absolute http(s): '+baseUrl); if(/(?:^|\\/\\/)(?:www\\.)?[^\\s/]*(?:prod|production)/i.test(baseUrl))throw new Error('production URL forbidden: '+baseUrl); console.log('frontend-test-execution-v1 validated baseUrl='+baseUrl);")].join(" ")], cwd: ".", timeoutMs: 60000 },
-            },
-            {
-                id: "generate-frontend-functional-cases-pi",
-                depends_on: ["materialize-frontend-test-execution-shell"],
-                role: "implementer",
-                executor: "pi",
-                toolProfile: "write",
-                complexity: "HIGH",
-                writePolicy: "exclusive",
-                writeSet: casesWriteSet,
-                allowedPaths: [...ragWriteSet, ...casesWriteSet],
-                forbiddenPaths: forbidden,
-                outputContract: "Write executable Markdown frontend cases, index.md, and manifest.draft.json schemaVersion 1; no test source code.",
-                subtask_prompt: [
-                    "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.draft.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. Copy the resolved absolute baseUrl from context.md (baseUrl field; resolved from config.md or default http://localhost:5173). Every browser start command must be: playwright-cli open --browser=chrome --headed <resolved-base-url-from-context.md> with that concrete URL — never leave a <base-url> placeholder. 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"),
-            },
-            {
-                id: "review-frontend-cases-pi",
-                depends_on: ["generate-frontend-functional-cases-pi"],
-                role: "reviewer",
-                executor: "pi",
-                complexity: "HIGH",
-                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. request-revision blocks manifest materialization.",
-                subtask_prompt: "Review only the RAG package, frontend Markdown cases, and manifest.draft.json. 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: "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. HARD: Never delete case files; only edit in place or add missing cases. Preserve the full planned suite, index.md, and manifest.draft.json.",
-            },
-            {
-                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: "exclusive",
-                writeSet: casesWriteSet,
-                allowedPaths: casesWriteSet,
-                forbiddenPaths: forbidden,
-                outputContract: "Validated frontend manifest payload { cases: [...] }; after the review gate, atomically materialize testcase/frontend/cases/manifest.json from manifest.draft.json; shell output may echo only the prefix before exactly one final JSON line.",
-                subtask_prompt: "Validate manifest.draft.json and materialize manifest.json only after the effective frontend case review has passed.",
-                shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
-            },
-            {
-                id: "execute-frontend-cases-map",
-                depends_on: ["materialize-frontend-case-manifest-shell"],
-                role: "verifier",
-                executor: "static",
-                complexity: "LOW",
-                writePolicy: "none",
-                allowedPaths: [],
-                forbiddenPaths: forbidden,
-                outputContract: "Serial aggregate of case execution summaries, evidence paths, tokens, and token-budget blocked cases.",
-                subtask_prompt: "Expand and execute the validated frontend case manifest serially.",
-                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: config.maxCasesPerBatch,
-                    maxExpandedNodes: config.maxCasesPerBatch,
-                    childIdPrefix: "execute-frontend-case",
-                    workspaceTemplate: "{{case.evidenceDir}}",
-                    tokenBudget: {
-                        maxTokensPerCase: config.maxTokensPerCase,
-                        maxTotalTokens: config.maxTotalTokens,
-                    },
-                    childTask: {
-                        executor: "pi",
-                        role: "implementer",
-                        skills: ["playwright-cli"],
-                        toolProfile: "write",
-                        complexity: "MED",
-                        writePolicy: "exclusive",
-                        allowedPaths: [
-                            "testcase/frontend/cases/{{case.caseId}}.md",
-                            "testcase/frontend/rag/context.md",
-                            "testcase/frontend/rag/coverage-map.md",
-                            `${evidenceRoot}/{{case.caseId}}/**`,
-                        ],
-                        forbiddenPaths: forbidden,
-                        writeSet: [`${evidenceRoot}/{{case.caseId}}/**`],
-                        outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, and tokens.",
-                        subtaskPromptTemplate: [
-                            "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session; do not use /new). Prefer playwright-cli over prose review.",
-                            "1) Read baseUrl from testcase/frontend/rag/context.md (config.md preferred, else http://localhost:5173). 2) Start browser: playwright-cli open --browser=chrome --headed <resolved-base-url> (default session only; no -s=). 3) Follow the case steps with snapshot before element refs. 4) If env/CLI/baseUrl is unavailable, write blocked evidence and do not open a browser.",
-                            "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json (caseId, status passed|failed|blocked, evidencePaths; blocked needs blockedReason). Then validate: 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)\".",
-                            "Business failed/blocked is a recorded result, not a node failure. Close browser. Return compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
-                        ].join("\n\n"),
-                    },
-                },
-            },
-            {
-                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. Does not gate retrospective closeout.",
-                subtask_prompt: "Delivery/Worker gate for authoritative frontend-test result. Retrospective does not depend on this node so failed runs can still write reports.",
-                shell: { commands: [frontendTestOutcomeGate], cwd: ".", timeoutMs: 60000 },
-            },
-            {
-                id: "frontend-test-retrospect-pi",
-                depends_on: ["materialize-frontend-test-result-shell"],
-                role: "closeout",
-                executor: "pi",
-                toolProfile: "write",
-                complexity: "MED",
-                writePolicy: "exclusive",
-                writeSet: ["testcase/frontend/reports/**"],
-                allowedPaths: ["testcase/frontend/**"],
-                forbiddenPaths: forbidden,
-                outputContract: "Write frontend-test retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, execution evidence review, risks, findings, and A/B/C/D rating — even when outcome is failed/incomplete.",
-                subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/ after result materialization (do not wait for outcome=pass). Combine AC→case→browser-evidence review with the closeout report: coverage, passed/failed/blocked (including token-budget-exhausted), evidence gaps, browser anomalies, residual risks, and A/B/C/D rating. Passed cases need assertion plus screenshot or equivalent evidence when available; failed/blocked need explicit reasons. Blocked cases never count as passed. Do not replace browser evidence with model conclusions. Do not write docs/**.",
-            },
-        ],
+        tasks,
     };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);

package/dist/workflows/dag/types.js

@@ -201,6 +201,13 @@ export const dagDynamicExpansionSchema = z.object({
         maxTotalTokens: z.number().int().positive().optional(),
     })
         .optional(),
+    /**
+     * When true, map child ERROR/auth/timeout is recorded as case-level
+     * failed/blocked evidence and the map barrier still succeeds (frontend-test).
+     * Default false: any non-budget child failure fails the map aggregate
+     * (sharded migration and other map_agent workflows).
+     */
+    tolerateChildFailures: z.boolean().optional(),
 });
 export const dagDynamicReductionSchema = z.object({
     type: z.literal("verified_findings_report"),

package/docs/local-development-environment.md

@@ -45,6 +45,10 @@ git config commit.gpgsign false
 
 该设置只用于本地开发和测试稳定性，不应写入仓库代码、模板或发布包配置。
 
+## Windows clean Shell 与用户级 Python
+
+DAG Shell/verification 默认使用安全的 clean environment，不继承完整宿主环境。在 Windows 上，clean baseline 会保留 `APPDATA`，使 Python/pip 能按标准规则定位 `%APPDATA%/Python/PythonXY/site-packages` 中的用户级安装，同时 token、credential 与其他未授权变量仍被过滤。不要在仓库中硬编码用户目录、盘符、Python 版本或 `site-packages` 路径；业务环境变量仍应通过任务/DAG 的显式 `envAllowlist` 授权。
+
 ## 维护规则
 
 - 仅把可复现、会反复影响开发或验证的环境问题写入本文。

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

@@ -90,7 +90,7 @@
         "artifacts/**"
       ],
       "outputContract": "Pure JSON envelope {analysis: Backend Test Analysis v2, execution: Backend Test Execution Contract v1}; no prose or writes.",
-      "subtask_prompt": "Read the task source materials and return exactly one JSON object matching Backend Test Analysis v2.\n\nDo not wrap it in explanatory prose. A single fenced json block is tolerated, but pure JSON is preferred.\n\nCopy the sourceBinding object exactly from the JSON block below; do not infer, add, remove, or reclassify source paths.\n\nOnly kind=reference sources belong in referencePaths; kind=constraint sources MUST NOT be included in referencePaths.\n\n## Exact Backend Test Analysis sourceBinding JSON\n\n{\n  \"taskId\": \"backend-test-template\",\n  \"requirementPath\": \"source/需求.md\",\n  \"requirementSha256\": \"e33ab9d1d3d6a785b8f429d8581d015a299adc093b0c9a7c0f9057f968a71837\",\n  \"referencePaths\": [],\n  \"requirementIds\": [\n    \"AC-001\"\n  ]\n}\n\nFor every endpoint, explicitly set responseBody.kind=array|object|scalar|empty|unknown and ordering=specified|unspecified|not-applicable. Add itemSchemaRef for arrays when documented.\n\nFor response fields, use comparison=exact|parseable-only|semantic when the source defines assertion semantics; date-time fields whose precision is unspecified should use parseable-only, not string equality.\n\nEndpoint sourceRefs and field sourceRefs must cite only requirement/reference evidence actually read. Empty sourceRefs are allowed only when normalizing legacy v1 input; newly generated v2 should cite evidence.\n\nUse empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.\n\nRequired top-level keys: schemaVersion=2, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.\n\nRead-only: do not modify code, docs, artifacts, or repository files.\n\n## Task source: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Task config summary\n\n- taskId: backend-test-template\n\n- flow: auto\n\n- complexity: medium\n\n- contextProfile: full\n\n- allowedPaths: testcase/**, docs/test-reports/**\n\n- forbiddenPaths: (none)\n\n- Pi DAG nodes are read-only unless toolProfile=\"write\" is explicitly selected for a bounded writer node.\n\n- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.\n\n- source/references/* are immutable user/source facts; source/需求.md is the derived execution contract.\n\nAlso perform the read-only environment discovery described by Backend Test Execution Contract v1. Return exactly one JSON envelope with top-level keys analysis and execution; analysis must satisfy v2 and execution must satisfy v1.",
+      "subtask_prompt": "Read the task source materials and return exactly one JSON object matching Backend Test Analysis v2.\n\nDo not wrap it in explanatory prose. A single fenced json block is tolerated, but pure JSON is preferred.\n\nCopy the sourceBinding object exactly from the JSON block below; do not infer, add, remove, or reclassify source paths.\n\nOnly kind=reference sources belong in referencePaths; kind=constraint sources MUST NOT be included in referencePaths.\n\n## Exact Backend Test Analysis sourceBinding JSON\n\n{\n  \"taskId\": \"backend-test-template\",\n  \"requirementPath\": \"source/需求.md\",\n  \"requirementSha256\": \"e33ab9d1d3d6a785b8f429d8581d015a299adc093b0c9a7c0f9057f968a71837\",\n  \"referencePaths\": [],\n  \"requirementIds\": [\n    \"AC-001\"\n  ]\n}\n\nFor every endpoint, explicitly set responseBody.kind=array|object|scalar|empty|unknown and ordering=specified|unspecified|not-applicable. Add itemSchemaRef for arrays when documented.\n\nFor response fields, use comparison=exact|parseable-only|semantic when the source defines assertion semantics; date-time fields whose precision is unspecified should use parseable-only, not string equality.\n\nEndpoint sourceRefs and field sourceRefs must cite only requirement/reference evidence actually read. Empty sourceRefs are allowed only when normalizing legacy v1 input; newly generated v2 should cite evidence.\n\nFor externalDependencies and risks, emit canonical items with exactly description plus optional name and sourceRef. For a dependency target, put the target value in name. Do not emit type, target, kind, required, severity, mitigation, level, impact, sourceRefs, or custom keys in newly generated v2 output.\n\nUse empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.\n\nRequired top-level keys: schemaVersion=2, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.\n\nRead-only: do not modify code, docs, artifacts, or repository files.\n\n## Task source: 需求.md\n\n# Backend test\n- AC-001 proof\n\n## Task config summary\n\n- taskId: backend-test-template\n\n- flow: auto\n\n- complexity: medium\n\n- contextProfile: full\n\n- allowedPaths: testcase/**, docs/test-reports/**\n\n- forbiddenPaths: (none)\n\n- Pi DAG nodes are read-only unless toolProfile=\"write\" is explicitly selected for a bounded writer node.\n\n- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.\n\n- source/references/* are immutable user/source facts; source/需求.md is the derived execution contract.\n\nAlso perform the read-only environment discovery described by Backend Test Execution Contract v1. Return exactly one JSON envelope with top-level keys analysis and execution; analysis must satisfy v2 and execution must satisfy v1.",
       "retryPolicy": {
         "maxAttempts": 3,
         "backoff": "exponential",

package/docs/templates/frontend-test-case-checklist.md

@@ -0,0 +1,25 @@
+# Frontend-test case blocking checklist
+
+Shared mechanical rules for `frontend-case-checklist-shell` and generate prompts.
+LLM review (when `frontendTest.reviewMode=blocking`) must not invent blocking rules outside this list.
+
+## Blocking (fail closed)
+
+| ruleId | Rule |
+|---|---|
+| `open-prefix` | Each case body includes `playwright-cli open --browser=chrome --headed <absolute-http(s)-url>` |
+| `production-url` | Open URL must not look like a production host |
+| `ac-mapping` | Manifest entry has non-empty `acIds` |
+| `case-file-missing` | `casePath` exists |
+| `no-test-source` | Case text must not introduce pytest / Playwright test source (`pytest`, `playwright.test`, `@playwright/test`) |
+
+## Non-blocking (notes only)
+
+- Preferred extra evidence filenames not required by generate
+- Style / wording preferences
+- Additional network envelope proofs beyond capability matrix
+
+## Pipeline vs quality
+
+- **Pipeline acceptance**: final `testcase/frontend/reports/frontend-test-retrospect-*.md` exists after result materialize
+- **Quality**: `frontend-test-result-v1.outcome=passed` with 0 blocked/failed (opt-in via `frontendTest.strictOutcomeGate`)

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

@@ -7,14 +7,15 @@
     "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.",
+  "objective": "Build a frontend test RAG package, generate Markdown cases, mechanically checklist them (LLM review optional), execute each case serially through playwright-cli, materialize frontend-test-result-v1, and write retrospect report (pipeline acceptance).",
   "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 <resolved-base-url> (from task source config.md when present, else http://localhost:5173); 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."
+    "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.",
+    "Default pipeline acceptance is the final retrospect report under testcase/frontend/reports/; case full green is optional quality (frontendTest.strictOutcomeGate).",
+    "Default frontendTest.reviewMode=off uses mechanical checklist-shell before materialize; set reviewMode=blocking for legacy dual LLM review gate."
   ],
   "tasks": [
     {

package/package.json

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