@tea-agent/loop-agent 0.16.22 → 0.16.24

package/CHANGELOG.md

@@ -1,18 +1,9 @@
-# 更新日志
-
 ## [Unreleased]
 
-### 修复
-
-- 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/**`，同时仍保留可审计的测试资产。
@@ -24,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，避免模型猜测字段导致契约门禁失败。
@@ -35,6 +35,23 @@
 - 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
+
+### 修复
+
+- DAG runner 在归档到 `completed/` 前停止 heartbeat 并排空 state 写队列。避免 terminal 节点全 FINISHED 后仍因 completed-facts write guard 拒绝写 `state.json` 导致 `run-dag` 非零退出、Worker 记 `run-error`/Task Pool `Blocked`。
+
 ## [0.16.22] - 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/backend-test-contract-envelope.js

@@ -6,6 +6,44 @@
  * Semantic review / classification materializers reuse the same scanner.
  */
 const JSON_FENCE_RE = /```json\s*\r?\n([\s\S]*?)\r?\n```/gi;
+/**
+ * Mask complete Markdown inline-code spans without changing source offsets.
+ * Object-shaped examples inside backticks are prose, not JSON candidates.
+ * Unclosed delimiters stay visible so malformed output cannot hide conflicts.
+ */
+function maskMarkdownInlineCode(text) {
+    const chars = text.split("");
+    for (let index = 0; index < text.length;) {
+        if (text[index] !== "`") {
+            index += 1;
+            continue;
+        }
+        let delimiterLength = 1;
+        while (text[index + delimiterLength] === "`")
+            delimiterLength += 1;
+        if (delimiterLength >= 3) {
+            index += delimiterLength;
+            continue;
+        }
+        const delimiter = "`".repeat(delimiterLength);
+        let close = text.indexOf(delimiter, index + delimiterLength);
+        while (close >= 0 &&
+            (text[close - 1] === "`" || text[close + delimiterLength] === "`")) {
+            close = text.indexOf(delimiter, close + delimiterLength);
+        }
+        if (close < 0) {
+            index += delimiterLength;
+            continue;
+        }
+        const end = close + delimiterLength;
+        for (let cursor = index; cursor < end; cursor += 1) {
+            if (chars[cursor] !== "\n" && chars[cursor] !== "\r")
+                chars[cursor] = " ";
+        }
+        index = end;
+    }
+    return chars.join("");
+}
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -121,7 +159,7 @@ function findUniqueJsonObjectText(text) {
     if (fences.length === 1) {
         const fence = fences[0];
         const outsideScans = [trimmed.slice(0, fence.start), trimmed.slice(fence.end)]
-            .map((fragment) => scanBalancedObjectSpans(fragment));
+            .map((fragment) => scanBalancedObjectSpans(maskMarkdownInlineCode(fragment)));
         if (outsideScans.some((scan) => scan.unclosedObject)) {
             throw new Error("backend-test unique JSON object: unclosed JSON object outside fenced json block");
         }
@@ -131,7 +169,7 @@ function findUniqueJsonObjectText(text) {
         }
         return fence.body;
     }
-    const scan = scanBalancedObjectSpans(trimmed);
+    const scan = scanBalancedObjectSpans(maskMarkdownInlineCode(trimmed));
     if (scan.unclosedObject) {
         throw new Error("backend-test unique JSON object: unclosed JSON object; expected one unique balanced object");
     }

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,
     };