@tea-agent/loop-agent 0.16.23 → 0.16.25

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/**`，同时仍保留可审计的测试资产。
@@ -23,9 +12,22 @@
 - Backend Test Analysis、Case Manifest、Semantic Review 与 Classification 的严格 JSON 契约进一步对齐，生成节点明确字段白名单、`sourceBinding` 与 evidence gap 约束，避免模型自定义字段导致确定性门禁失败。
 - 新增升级后 init surface notifier：普通安全仓库命令结束后，当目标项目存在有效 `.harness/init-surface.json` 且 `controllerVersion` 与当前包版本不同时自动检测。surface 缺失/损坏、源仓库、未初始化目录与版本一致时直接跳过；`checkInitUpdate().ok` 时仅在无活跃运行时静默刷新 state；非 TTY 只向 stderr 输出 `loop-agent init reconcile --repo-root ...` 提示且不写入目标；TTY 且无 human decisions、无活跃 DAG/Worker 时可经明确 `y/yes` 同意后应用 deterministic safe actions；只有 model merge 时直接输出有边界指引，不询问“应用 0 个动作”。notifier 遵循全局 `--repo-root`、不写 stdout、不改变原命令退出码，CI、禁用环境变量、help/version、`--json`/`--markdown`、`init`、`run-dag`、`dag`、`loop`、`delegate`、`pi-prompt`、`cursor-prompt` 均跳过。
 - 新增统一命令 `loop-agent init reconcile --repo-root <target>`：surface 缺失返回 `needs-baseline` 且零写入，存在 human decisions 返回 `needs-human-decision` 且零写入，活跃 DAG/Worker 或 Worker 状态无法确认时返回 `blocked-active-runtime` 且零写入；其余情况复用现有 `applyInitUpdate({ applySafe: true })` 并复查返回 `clean`/`needs-model-merge`/`needs-safe-update`，支持 `--json`/`--markdown`。
+- 测试报告新增 L-5 指标消费与 Python coverage.py JSON、Java JaCoCo XML 的统一 Code Coverage v1 报告入口，覆盖通过率、AC/自动化覆盖率、稳定性、失败原因、缺陷、风险和回归建议；缺失覆盖率证据保持 `unavailable`，不改变 backend-test outcome gate。
+- 现有 backend-test DAG 在 retrospective 之后新增独立的 `l5-metrics-pi` 指标节点；它基于前序测试报告和 run-owned 证据输出 `L-5 ready/not-ready`，不创建独立 L-5 DAG，也不改变 Result v1 outcome gate。
+- 后端测试 DAG 从 38 个收敛为 24 个真实顶层节点；使用 fail-closed `runIf` 和复合 Shell capability 减少调度，同时保留双合同、Manifest、语义评审、JUnit、Result、分类、修复安全、追踪和最终 outcome 证据。三条可选修订/修复分支仍各最多执行一次。
+- Backend Test Analysis、Case Manifest、Semantic Review 与 Classification 的严格 JSON 契约进一步对齐，生成和修订节点明确字段白名单、`sourceBinding` 与 evidence gap 约束，避免模型自定义字段导致确定性门禁失败。
 
 ### 修复
 
+- 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 +39,24 @@
 - Pi SDK 执行长推理或大段结构化输出时不再把高频流式增量事件无界累积到内存；同一响应在多个生命周期事件中重复出现的 Token 用量只统计一次，避免 `Invalid string length` 和成本数据虚高。
 - 后端测试复合执行节点继续保持 clean environment、失败分类和 fail-closed outcome，并为唯一 JUnit/initial Result、canonical Result、traceability 与 Observe 投影保留结构化运行证据。
 
+## [0.16.25] - 2026-07-22
+
+### 修复
+
+- Backend-test pytest preflight 与执行体改为 `&&` fail-closed：preflight 失败不再因 `;` 继续跑 pytest（I27 曾出现 preflight 报 `WELCOME_BASE_URL`/testRoot 错配仍执行用例）。
+- 本地 `npm start` / `node server.js` 类 `managed-command` 在 materialize 时降级为 `in-process`，清空 requiredEnv、seed server fixture，并把 scout `testRoot` 收敛到冻结根 `testcase/`；generate-pytest 提示要求 fixture 内启动服务，不再依赖 clean-env 注入 base URL。
+
+## [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/cli/command-definitions.js

@@ -3,6 +3,7 @@ import { runDocsArchive } from "../commands/docs-archive.js";
 import { runDocsAudit } from "../commands/docs-audit.js";
 import { runEval } from "../commands/eval.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
+import { runCoverageReport } from "../commands/coverage-report.js";
 import { runExamples } from "../commands/examples.js";
 import { runCloseout } from "../commands/closeout.js";
 import { runHandoffCheck } from "../commands/handoff-check.js";
@@ -101,6 +102,7 @@ const PLAN_SUBCOMMANDS = ["list", "create", "complete", "check"];
 const SPINE_SUBCOMMANDS = ["audit"];
 const HANDOFF_SUBCOMMANDS = ["check", "coverage"];
 const HANDOFF_USAGE = "handoff <check|coverage> [taskId]";
+const COVERAGE_SUBCOMMANDS = ["report"];
 const REFERENCE_SUBCOMMANDS = ["index"];
 const STUDY_SUBCOMMANDS = ["init"];
 const WORKTREE_SUBCOMMANDS = ["create", "list", "remove"];
@@ -378,6 +380,17 @@ export const COMMAND_DEFINITIONS = [
             throw new Error(`usage: ${HANDOFF_USAGE}`);
         },
     },
+    {
+        name: "coverage",
+        adapter: "required",
+        tier: "operator",
+        intent: "Normalize Python coverage.py JSON or Java JaCoCo XML for test reports.",
+        usage: "coverage report --language python|java --input <path> [options]",
+        subcommands: [...COVERAGE_SUBCOMMANDS],
+        handler: async ({ repoRoot, subcommand, rest }) => {
+            await runCoverageReport(repoRoot, [subcommand, ...rest].filter(Boolean));
+        },
+    },
     {
         name: "goal",
         adapter: "required",

package/dist/cli/program.js

@@ -5,6 +5,7 @@ import { readPackageVersion } from "../shared/package-metadata.js";
 import { resolveAdapter } from "../adapters/index.js";
 import { runCloseout } from "../commands/closeout.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
+import { runCoverageReport } from "../commands/coverage-report.js";
 import { parseCursorPromptArgs, printCursorPromptUsage, runCursorPrompt, } from "../commands/cursor-prompt.js";
 import { runDagApprove } from "../commands/dag-approve.js";
 import { runDagFinalVerification } from "../commands/dag-final-verification.js";
@@ -205,6 +206,9 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
                 return;
             }
             throw new Error("usage: handoff <check|coverage> [taskId]");
+        case "coverage":
+            await runCoverageReport(ctx.repoRoot, compactArgs([subcommand, ...rest]));
+            return;
         case "goal":
             await runGoal(ctx.repoRoot, subcommand, rest);
             return;

package/dist/commands/coverage-report.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { formatCoverageMarkdown, readCoverageArtifact } from "../workflows/dag/backend-test-coverage-contract.js";
+function value(args, flag) {
+    const index = args.findIndex((arg) => arg === flag || arg.startsWith(`${flag}=`));
+    if (index < 0)
+        return undefined;
+    const token = args[index];
+    return token.startsWith(`${flag}=`) ? token.slice(flag.length + 1) : args[index + 1];
+}
+function values(args, flag) {
+    return args.flatMap((arg, index) => {
+        if (arg === flag)
+            return args[index + 1] ? [args[index + 1]] : [];
+        return arg.startsWith(`${flag}=`) ? [arg.slice(flag.length + 1)] : [];
+    });
+}
+export async function runCoverageReport(repoRoot, args) {
+    if (args[0] !== "report" || args.includes("--help")) {
+        console.log("usage: coverage report --language python|java --input <coverage.json|jacoco.xml> [--output <path>] [--json|--markdown] --requirement-id <AC-id> --source-scope <path[,path]> [--commit <sha>] [--expected-sha256 <sha256>]");
+        return;
+    }
+    const input = value(args, "--input");
+    const language = value(args, "--language");
+    if (!input || (language !== "python" && language !== "java"))
+        throw new Error("coverage report requires --language python|java and --input");
+    const expectedSha = value(args, "--expected-sha256");
+    const sourcePaths = (value(args, "--source-scope") ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+    const contract = await readCoverageArtifact(path.resolve(repoRoot, input), {
+        sourceScope: { requirementIds: values(args, "--requirement-id"), paths: sourcePaths },
+        commitSha: value(args, "--commit") ?? null,
+        toolVersion: value(args, "--tool-version") ?? null,
+        artifactPath: input,
+    });
+    if ((language === "python" && contract.language !== "python") || (language === "java" && contract.language !== "java"))
+        throw new Error("coverage artifact format does not match --language");
+    if (expectedSha && expectedSha !== contract.artifact.sha256)
+        throw new Error(`artifact SHA-256 mismatch: expected ${expectedSha}, got ${contract.artifact.sha256}`);
+    const markdown = args.includes("--markdown");
+    const output = value(args, "--output");
+    const rendered = markdown ? formatCoverageMarkdown(contract) : `${JSON.stringify(contract, null, 2)}\n`;
+    if (output) {
+        const outputPath = path.resolve(repoRoot, output);
+        await mkdir(path.dirname(outputPath), { recursive: true });
+        await writeFile(outputPath, rendered, "utf8");
+    }
+    else {
+        process.stdout.write(rendered);
+    }
+}

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-coverage-contract.js

@@ -0,0 +1,202 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+export const CODE_COVERAGE_SCHEMA_ID = "code-coverage-v1";
+const relativePath = z.string().min(1).refine((value) => !path.posix.isAbsolute(value) &&
+    !value.includes("\\") &&
+    !value.split("/").some((part) => part === "" || part === "." || part === ".."), "path must be a relative POSIX path");
+export const coverageMetricSchema = z.object({
+    status: z.enum(["available", "unavailable"]),
+    covered: z.number().int().min(0).nullable(),
+    total: z.number().int().min(0).nullable(),
+    ratio: z.number().min(0).max(1).nullable(),
+    reason: z.string().min(1).nullable(),
+}).strict();
+export const codeCoverageContractSchema = z.object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(CODE_COVERAGE_SCHEMA_ID),
+    language: z.enum(["python", "java"]),
+    format: z.enum(["coverage.py-json", "jacoco-xml"]),
+    tool: z.string().min(1),
+    toolVersion: z.string().min(1).nullable(),
+    sourceScope: z.object({
+        requirementIds: z.array(z.string().regex(/^(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/)),
+        paths: z.array(relativePath),
+    }).strict(),
+    commitSha: z.string().regex(/^[a-f0-9]{7,64}$/).nullable(),
+    metrics: z.object({
+        line: coverageMetricSchema,
+        branch: coverageMetricSchema,
+        function: coverageMetricSchema,
+    }).strict(),
+    artifact: z.object({
+        path: relativePath,
+        sha256: z.string().regex(/^[a-f0-9]{64}$/),
+    }).strict(),
+    missingData: z.array(z.string().min(1)),
+}).strict();
+function metric(covered, total, reason) {
+    if (covered === null || total === null || total === 0) {
+        return { status: "unavailable", covered, total, ratio: null, reason: reason ?? (total === 0 ? "denominator-is-zero" : "metric-missing") };
+    }
+    return { status: "available", covered, total, ratio: covered / total, reason: null };
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function safeArtifactPath(value) {
+    const normalized = value.replaceAll(path.sep, "/");
+    if (path.posix.isAbsolute(normalized) || normalized.split("/").some((part) => part === "" || part === "." || part === "..")) {
+        throw new Error("artifact path must be a safe relative POSIX path");
+    }
+    return normalized;
+}
+function scopeMissing(scope) {
+    return scope.requirementIds.length === 0 ? ["source-scope-requirement-id-missing"] : [];
+}
+function baseContract(options, common) {
+    return {
+        schemaVersion: 1,
+        schemaId: CODE_COVERAGE_SCHEMA_ID,
+        ...common,
+        sourceScope: {
+            requirementIds: [...options.sourceScope.requirementIds],
+            paths: [...options.sourceScope.paths],
+        },
+        commitSha: options.commitSha,
+        artifact: { path: safeArtifactPath(options.artifactPath), sha256: options.artifactSha256 },
+    };
+}
+function parsePythonTotals(input, sourceScope) {
+    if (!input || typeof input !== "object")
+        throw new Error("coverage.py JSON must be an object");
+    const root = input;
+    const totals = root.totals;
+    if (!totals || typeof totals !== "object")
+        throw new Error("coverage.py JSON missing totals");
+    const files = root.files;
+    const scopedFiles = sourceScope.paths.length > 0 && files
+        ? Object.entries(files).filter(([file]) => sourceScope.paths.includes(file.replaceAll("\\", "/")))
+        : [];
+    const usesScopedFiles = sourceScope.paths.length > 0;
+    const values = usesScopedFiles ? scopedFiles.map(([, value]) => value) : null;
+    const get = (key) => {
+        if (values) {
+            let sum = 0;
+            for (const file of values) {
+                const data = file && typeof file === "object" ? file : {};
+                const value = numberValue(data[key]);
+                if (value !== null)
+                    sum += value;
+            }
+            return sum;
+        }
+        if (usesScopedFiles)
+            return null;
+        return numberValue(totals[key]);
+    };
+    return {
+        line: metric(get("covered_lines"), get("num_statements"), null),
+        branch: metric(get("covered_branches"), get("num_branches"), "coverage.py branch data missing"),
+        function: { status: "unavailable", covered: null, total: null, ratio: null, reason: "coverage.py JSON has no function coverage" },
+    };
+}
+function parseJacocoCounters(xml) {
+    const report = xml.match(/<report\b[^>]*>([\s\S]*?)<\/report>/i)?.[1];
+    if (report === undefined)
+        throw new Error("JaCoCo XML missing report root");
+    const reportLevel = report.split(/<(?:group|package)\b/i)[0] ?? "";
+    const counters = new Map();
+    for (const match of reportLevel.matchAll(/<counter\s+[^>]*type="([A-Z]+)"[^>]*missed="(\d+)"[^>]*covered="(\d+)"[^>]*\/>/gi)) {
+        const missed = Number(match[2]);
+        const covered = Number(match[3]);
+        counters.set(match[1].toUpperCase(), { covered, total: covered + missed });
+    }
+    return counters;
+}
+export function parseCoveragePyJson(input, options) {
+    const root = input;
+    const totals = parsePythonTotals(input, options.sourceScope);
+    const missingData = [...scopeMissing(options.sourceScope)];
+    const files = input && typeof input === "object" ? input.files : undefined;
+    if (options.sourceScope.paths.length > 0 && (!files || !options.sourceScope.paths.some((file) => Object.hasOwn(files, file))))
+        missingData.push("source-scope-not-found-in-artifact");
+    if (totals.branch.status === "unavailable")
+        missingData.push("branch-coverage-unavailable");
+    missingData.push("function-coverage-unavailable");
+    return codeCoverageContractSchema.parse({
+        ...baseContract(options, {
+            language: "python",
+            format: "coverage.py-json",
+            tool: "coverage.py",
+            toolVersion: typeof root?.meta?.version === "string" ? root.meta.version : options.toolVersion ?? null,
+        }),
+        metrics: totals,
+        missingData,
+    });
+}
+export function parseJacocoXml(xml, options) {
+    if (!/<report\b/i.test(xml))
+        throw new Error("JaCoCo XML missing report root");
+    const counters = parseJacocoCounters(xml);
+    const line = counters.get("LINE");
+    const branch = counters.get("BRANCH");
+    const method = counters.get("METHOD");
+    const missingData = [...scopeMissing(options.sourceScope)];
+    if (!line)
+        missingData.push("line-coverage-unavailable");
+    if (!branch)
+        missingData.push("branch-coverage-unavailable");
+    if (!method)
+        missingData.push("method-coverage-unavailable");
+    return codeCoverageContractSchema.parse({
+        ...baseContract(options, {
+            language: "java",
+            format: "jacoco-xml",
+            tool: "JaCoCo",
+            toolVersion: options.toolVersion ?? null,
+        }),
+        metrics: {
+            line: line ? metric(line.covered, line.total, null) : metric(null, null, "JaCoCo LINE counter missing"),
+            branch: branch ? metric(branch.covered, branch.total, null) : metric(null, null, "JaCoCo BRANCH counter missing"),
+            function: method ? metric(method.covered, method.total, null) : metric(null, null, "JaCoCo METHOD counter missing"),
+        },
+        missingData,
+    });
+}
+export async function readCoverageArtifact(inputPath, options) {
+    const raw = await readFile(inputPath, "utf8");
+    const artifactSha256 = createHash("sha256").update(raw).digest("hex");
+    const artifactPath = options.artifactPath ?? path.basename(inputPath);
+    const parseOptions = { ...options, artifactPath, artifactSha256 };
+    if (options.sourceScope.paths.some((value) => value.includes("..")))
+        throw new Error("unsafe source scope path");
+    if (inputPath.toLowerCase().endsWith(".xml"))
+        return parseJacocoXml(raw, parseOptions);
+    return parseCoveragePyJson(JSON.parse(raw), parseOptions);
+}
+export function formatCoverageMarkdown(contract) {
+    const row = (name, value) => `| ${name} | ${value.covered ?? "—"} | ${value.total ?? "—"} | ${value.ratio === null ? "unavailable" : `${(value.ratio * 100).toFixed(2)}%`} | ${value.status} | ${value.reason ?? "—"} |`;
+    return [
+        "# Code Coverage Report",
+        "",
+        `- Schema: ${contract.schemaId} v${contract.schemaVersion}`,
+        `- Language: ${contract.language}`,
+        `- Tool: ${contract.tool}${contract.toolVersion ? ` ${contract.toolVersion}` : ""}`,
+        `- Commit: ${contract.commitSha ?? "unavailable"}`,
+        `- Requirement IDs: ${contract.sourceScope.requirementIds.join(", ") || "unavailable"}`,
+        `- Source scope: ${contract.sourceScope.paths.join(", ") || "unavailable"}`,
+        `- Artifact: ${contract.artifact.path}`,
+        `- Artifact SHA-256: ${contract.artifact.sha256}`,
+        "",
+        "| Metric | Covered | Total | Ratio | Status | Reason |",
+        "|---|---:|---:|---:|---|---|",
+        row("Line", contract.metrics.line),
+        row("Branch", contract.metrics.branch),
+        row("Function/Method", contract.metrics.function),
+        "",
+        `Missing data: ${contract.missingData.length ? contract.missingData.join(", ") : "none"}`,
+        "",
+    ].join("\n");
+}