@tea-agent/loop-agent 0.25.3 → 0.25.5

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { access, readdir, readFile, realpath, } from "node:fs/promises";
+import { access, readdir, readFile, realpath } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
@@ -896,8 +896,7 @@ function chooseFrontendVerifyCommands(input) {
     return { commandSource: "inline" };
 }
 function classifyFrontendVerifyCommand(command) {
-    return /\b(typecheck|check-types|lint|eslint|tsc|build|check)\b/i.test(command) ||
-        /\bscripts[\\/]+ci(?:-tests)?\.sh\b/i.test(command)
+    return /\b(typecheck|check-types|lint|eslint|tsc|build|check)\b/i.test(command) || /\bscripts[\\/]+ci(?:-tests)?\.sh\b/i.test(command)
         ? "static"
         : "behavior";
 }
@@ -925,16 +924,18 @@ function buildExplicitFrontendVerifyCommands(taskConfig, repoRoot) {
 function verifyCommandKey(command) {
     const normalizedArgs = normalizeVerifyCommandArgs(command.args);
     const normalizedCwd = path.resolve(command.cwd).replace(/\\/g, "/");
-    const cwdKey = process.platform === "win32"
-        ? normalizedCwd.toLowerCase()
-        : normalizedCwd;
+    const cwdKey = process.platform === "win32" ? normalizedCwd.toLowerCase() : normalizedCwd;
     const envKey = Object.entries(command.env ?? {})
         .filter((entry) => entry[1] !== undefined)
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([key, value]) => `${key}=${value}`)
         .join("\0");
-    return [cwdKey, normalizedArgs.join("\0"), envKey, command.timeoutMs ?? ""]
-        .join("\u0001");
+    return [
+        cwdKey,
+        normalizedArgs.join("\0"),
+        envKey,
+        command.timeoutMs ?? "",
+    ].join("\u0001");
 }
 function normalizeVerifyCommandArgs(args) {
     if (args.length === 3 &&
@@ -1008,7 +1009,10 @@ function isFullSuiteVerifyCommand(command) {
     let index = 0;
     while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(args[index] ?? ""))
         index += 1;
-    const executable = path.basename(args[index] ?? "").toLowerCase().replace(/\.(?:exe|cmd)$/, "");
+    const executable = path
+        .basename(args[index] ?? "")
+        .toLowerCase()
+        .replace(/\.(?:exe|cmd)$/, "");
     const rest = args.slice(index + 1);
     if (["npm", "pnpm", "yarn", "bun"].includes(executable)) {
         return ((rest.length === 1 && rest[0] === "test") ||
@@ -1017,7 +1021,8 @@ function isFullSuiteVerifyCommand(command) {
     if (["bash", "sh"].includes(executable) && rest.length === 1) {
         return /(?:^|\/)scripts\/ci\.sh$/i.test(rest[0].replace(/\\/g, "/"));
     }
-    return rest.length === 0 && /(?:^|\/)scripts\/ci\.sh$/i.test((args[index] ?? "").replace(/\\/g, "/"));
+    return (rest.length === 0 &&
+        /(?:^|\/)scripts\/ci\.sh$/i.test((args[index] ?? "").replace(/\\/g, "/")));
 }
 function resolveDagVerifyStrategy(taskConfig, defaultIntermediateQuotaWhenFull = "full") {
     const explicitIntermediateQuota = taskConfig.dagVerifyStrategy?.intermediateQuota;
@@ -1038,7 +1043,8 @@ function buildVerifyEvidence(input) {
         quota: input.quota,
         commandSource: input.commandSource,
         commandCount,
-        commandLabels: selectedCommands?.map((command) => command.label) ?? input.fallbackCommands,
+        commandLabels: selectedCommands?.map((command) => command.label) ??
+            input.fallbackCommands,
         commandTexts: input.commandTexts ?? [],
         commandTimeoutMs: input.commandTimeoutMs,
         totalTimeoutBudgetMs: commandCount * input.commandTimeoutMs,
@@ -1674,6 +1680,7 @@ export function buildStandardHybridDagFromTask(sources) {
             {
                 id: "closeout-pi",
                 depends_on: ["verify-pi"],
+                failureAwareDependsOn: ["verify-pi"],
                 role: "closeout",
                 executor: "pi",
                 complexity: "MED",
@@ -1685,6 +1692,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 outputContract: "Plain Markdown closeout summary; no file writes.",
                 subtask_prompt: [
                     "Return closeout summary: what changed, verification status, risks, and handoff notes.",
+                    "If upstream failure evidence or a failure-derived skip is present, report the run as failed/partial_failed and never infer a passing result.",
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
                     sourceContext,
                 ].join("\n\n"),
@@ -1874,7 +1882,8 @@ function buildBlockedFrontendMockDag(sources, readOnlyPaths, forbiddenPaths, glo
         },
         skillsByRole: FRONTEND_SKILLS_BY_ROLE,
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        tasks: [{
+        tasks: [
+            {
                 id: "frontend-mock-blocked-shell",
                 depends_on: [],
                 role: "verifier",
@@ -1892,7 +1901,8 @@ function buildBlockedFrontendMockDag(sources, readOnlyPaths, forbiddenPaths, glo
                     cwd: ".",
                     timeoutMs: 60000,
                 },
-            }],
+            },
+        ],
     };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
@@ -2156,7 +2166,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         constraintMarkdown: sources.constraintMarkdown,
     });
     const explicitFrontendVerifyCommands = buildExplicitFrontendVerifyCommands(taskConfig, sources.repoRoot);
-    const explicitCommandKeys = new Set([...explicitFrontendVerifyCommands.staticCommands, ...explicitFrontendVerifyCommands.behaviorCommands].map(verifyCommandKey));
+    const explicitCommandKeys = new Set([
+        ...explicitFrontendVerifyCommands.staticCommands,
+        ...explicitFrontendVerifyCommands.behaviorCommands,
+    ].map(verifyCommandKey));
     const adapterVerifyCommands = (sources.verifyCommands?.final ?? []).filter((command) => !explicitCommandKeys.has(verifyCommandKey(command)));
     const staticVerifyCommands = chooseFrontendVerifyCommands({
         explicitCommands: explicitFrontendVerifyCommands.staticCommands,
@@ -2285,10 +2298,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-plan-pi",
-                depends_on: [
-                    "frontend-contract-pi",
-                    "frontend-scout-pi",
-                ],
+                depends_on: ["frontend-contract-pi", "frontend-scout-pi"],
                 role: "planner",
                 executor: "pi",
                 complexity: "MED",
@@ -2337,10 +2347,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-plan-revision-pi",
-                depends_on: [
-                    "frontend-plan-pi",
-                    "frontend-design-review-pi",
-                ],
+                depends_on: ["frontend-plan-pi", "frontend-design-review-pi"],
                 runIf: "$.nodes['frontend-design-review-pi'].firstVerdictLine == 'VERDICT: request-revision'",
                 role: "planner",
                 executor: "pi",
@@ -2425,12 +2432,18 @@ async function buildFrontendHybridDagFromTask(sources) {
                             ? ["not-needed"]
                             : taskConfig.frontendMock?.policy === "required"
                                 ? ["native", "browser-intercept", "request-adapter"]
-                                : ["native", "browser-intercept", "request-adapter", "not-needed"],
+                                : [
+                                    "native",
+                                    "browser-intercept",
+                                    "request-adapter",
+                                    "not-needed",
+                                ],
                         artifactName: "frontend-implementation-contract.json",
                         outputDir: "contracts",
                         requireSourceFreshness: true,
                         implementationWriteSet: implementPaths.writeSet,
-                        openspecCandidatePaths: sources.frontendProjectCapability?.designEvidence.normativePaths ?? [],
+                        openspecCandidatePaths: sources.frontendProjectCapability?.designEvidence
+                            .normativePaths ?? [],
                     },
                     cwd: ".",
                     timeoutMs: 60000,
@@ -2482,7 +2495,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writerOutcomePolicy: {
                     type: "implementation-outcome-v1",
                 },
-                outputContract: "First non-empty line: IMPLEMENTATION_OUTCOME: changed | already-satisfied | blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
+                outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
                     "The canonical contract already contains the approved requirement, target-file, UI-state, verification, design, and Mock/API decisions. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat broad repository research. Inspect only contract target files and directly related local code needed to implement them.",
@@ -2547,7 +2560,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writerOutcomePolicy: {
                     type: "implementation-outcome-v1",
                 },
-                outputContract: "First non-empty line: IMPLEMENTATION_OUTCOME: changed | already-satisfied | blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
+                outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
                     "This node runs only for eligible=true. Apply the smallest fix for the classified repairable failure inside the original implement writeSet only.",
@@ -3454,55 +3467,106 @@ async function buildBackendTestHybridDag(sources) {
     const forbidden = commonForbiddenPaths(sources);
     const intake = await buildBackendTestIntakeContext(sources);
     const shellNode = (id, depends_on, pipeline, prompt, outputContract, commands = [], timeoutMs = 60000) => ({
-        id, depends_on, role: "verifier", executor: "shell", complexity: "LOW",
-        writePolicy: "read-only", allowedPaths: ro, forbiddenPaths: forbidden,
-        outputContract, subtask_prompt: prompt,
-        shell: { commands, backendTestPipeline: pipeline, cwd: ".", timeoutMs,
-            ...(commands.length ? { envAllowlist: collectBackendTestShellEnvAllowlist(sources) } : {}) },
+        id,
+        depends_on,
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract,
+        subtask_prompt: prompt,
+        shell: {
+            commands,
+            backendTestPipeline: pipeline,
+            cwd: ".",
+            timeoutMs,
+            ...(commands.length
+                ? { envAllowlist: collectBackendTestShellEnvAllowlist(sources) }
+                : {}),
+        },
     });
-    const environment = shellNode("validate-backend-test-environment-shell", [], "markdown-environment", "Fail fast before model work when Python/pytest cannot run in the clean shell. Inspect only bounded common config, conftest, test-root and server-entry candidates; never read .env values or credentials.", "Run-owned reports/backend-test-environment.md with PASS/FAIL runtime, bounded project discovery, fixture and HTML-renderer facts; no secret values.", ["python --version", "python -m pytest --version", "python -m pytest --help"]);
+    const environment = shellNode("validate-backend-test-environment-shell", [], "markdown-environment", "Fail fast before model work when Python/pytest cannot run in the clean shell. Inspect only bounded common config, conftest, test-root and server-entry candidates; never read .env values or credentials.", "Run-owned reports/backend-test-environment.md with PASS/FAIL runtime, bounded project discovery, fixture and HTML-renderer facts; no secret values.", [
+        "python --version",
+        "python -m pytest --version",
+        "python -m pytest --help",
+    ]);
     const generateCases = {
-        id: "generate-backend-md-cases-pi", depends_on: [environment.id], role: "implementer",
-        executor: "pi", toolProfile: "write", complexity: "MED", writePolicy: "exclusive",
-        writeSet: ["testcase/md/**"], allowedPaths: ["testcase/md/**"], forbiddenPaths: forbidden,
+        id: "generate-backend-md-cases-pi",
+        depends_on: [environment.id],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: forbidden,
         outputContract: "Write a Chinese, human-readable testcase/md/README.md plus module Markdown case cards using BE-<MODULE>-<NNN>; keep machine IDs/literals exact and do not execute pytest or modify production code/config.",
         subtask_prompt: [
             "Read the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.",
             "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
             "Create testcase/md/README.md as the concise entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in README.",
-            "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. The only sections required by the deterministic validator are `### 前置条件`, `### 操作步骤`, and `### 预期结果` (legacy English aliases remain accepted). Add `测试目的`, `验收标准`, `需求依据`, `测试数据`, and `自动化映射` when useful for human readability; every automatable case should explicitly name its target pytest script under `自动化映射` so traceability can scan only that script.",
+            "Before writing cases, build a mandatory machine-readable Coverage Matrix. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.",
+            "Each Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.",
+            "Coverage priority is strict: P0 product requirements/task hard constraints first; P1 exhaustively supplements documented API operations, fields, business rules, statuses and errors; P2 adds bounded protocol robustness only when it does not invent product behavior. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
+            "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
+            "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`) and never a bare number. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射`; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. Every automatable case explicitly names its target pytest script so traceability scans only that script.",
             "Name each module file with a stable lowercase business stem such as `testcase/md/health.md` or `testcase/md/resource_notes.md`. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
             "Place steps and their expected results in a compact readable table when that improves clarity; otherwise keep numbered executable steps and numbered/bulleted independently assertable results. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
             "In `自动化映射`, record the planned script path and pytest function name when known, and keep the script path identical to the module one-to-one path above. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
-            intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
+            intake.boundedSourceContext,
+            "## Authoritative reference index",
+            JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
             "Read only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
         ].join("\n\n"),
     };
     const reviewCases = {
-        id: "review-and-revise-backend-md-cases-pi", depends_on: [generateCases.id], role: "reviewer",
-        executor: "pi", toolProfile: "write", complexity: "MED", writePolicy: "exclusive",
-        writeSet: ["testcase/md/**"], allowedPaths: ["testcase/md/**"], forbiddenPaths: forbidden,
+        id: "review-and-revise-backend-md-cases-pi",
+        depends_on: [generateCases.id],
+        role: "reviewer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: forbidden,
         outputContract: "Review source fidelity and directly revise only testcase/md/**; return concise Markdown, never JSON.",
         subtask_prompt: [
             "Independently review generated Markdown cases against the task requirements and environment evidence. Treat the files as human-facing test documentation: require clear preconditions, executable steps and assertable expected results; improve names, purpose, metadata and automation mapping where useful while preserving exact machine IDs and technical literals.",
-            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), and missing or drifted script/function mapping where it can be derived.",
-            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, fix automation mappings so each case points at `testcase/test_<module>.py` derived from that module filename, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations exact. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
+            "Independently reconstruct P0 product scenarios and P1 documented API rules from authoritative sources before trusting the generated Coverage Matrix. Check every lifecycle/uniqueness state (including deleted-existing), every valid enum value, bounded invalid enum classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, endpoint, status/error codes, auth and state transitions. Directly add omissions; undefined expectations remain GAP/CONFLICT rather than invented behavior.",
+            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact unnumbered `## Coverage Matrix` heading, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Directly repair malformed headings/rows/keys rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), and missing or drifted script/function mapping where it can be derived.",
+            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`) consistently across headings/index/mappings, fix automation mappings so each case points at `testcase/test_<module>.py` derived from that module filename, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "Read only precise referenced source paths plus requirement sections needed for uncovered ACs. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
-            intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
+            intake.boundedSourceContext,
+            "## Authoritative reference index",
+            JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
         ].join("\n\n"),
     };
-    const validateCases = shellNode("validate-backend-md-cases-shell", [reviewCases.id], "markdown-cases", "Record advisory findings for missing/duplicate IDs, missing core sections (preconditions, steps, expected results), AC coverage, executable steps, assertable results or placeholders. Do not validate source-reference existence. Keep quality findings advisory, but fail closed after writing the report when secret-shaped values are detected so downstream pytest/report nodes cannot consume them.", "Run-owned reports/backend-md-case-validation.md with PASS/FAIL advisory findings; downstream execution continues.");
+    const validateCases = shellNode("validate-backend-md-cases-shell", [reviewCases.id], "markdown-cases", "Record advisory findings for Markdown structure and deterministically analyze the final README Coverage Matrix against final Case rule/test-point bindings. Detect missing product/API rules, enum values, invalid equivalence classes, boundaries, format classes, business lifecycle states, GAP/CONFLICT and bidirectional Matrix/Case drift. Do not validate source-reference existence. Write human and machine evidence from the same facts. Keep quality findings advisory, but fail closed after writing the report when secret-shaped values are detected. Coverage FAIL stays advisory.", "Run-owned reports/backend-md-case-validation.md, reports/backend-test-case-coverage-analysis.md and contracts/backend-test-case-coverage-facts.json with PASS/FAIL/UNAVAILABLE advisory facts; downstream execution continues.");
     const generatePytest = {
-        id: "generate-backend-pytest-pi", depends_on: [validateCases.id], role: "implementer",
-        executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive",
-        writeSet: ["testcase/**/test_*.py", "testcase/**/helpers/**", "testcase/**/factories/**"],
-        allowedPaths: Array.from(new Set([...ro, "testcase/**"])), forbiddenPaths: forbidden,
+        id: "generate-backend-pytest-pi",
+        depends_on: [validateCases.id],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet: [
+            "testcase/**/test_*.py",
+            "testcase/**/helpers/**",
+            "testcase/**/factories/**",
+        ],
+        allowedPaths: Array.from(new Set([...ro, "testcase/**"])),
+        forbiddenPaths: forbidden,
         outputContract: "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring. Each testcase/md/<module>.md (excluding README.md) maps one-to-one to testcase/test_<module>.py; never merge or split modules. No JSON and no pytest execution.",
         subtask_prompt: [
             "Convert testcase/md/** to pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.",
-            "Ensure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.",
+            "Ensure every final Markdown Case ID appears in exactly one primary pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. When a Case has multiple `测试点`, use one parameterized primary symbol with stable `pytest.param(..., id=\"TP-...\")` IDs matching every Markdown Test Point, or split the Markdown into independent Cases before generation; do not create duplicate symbols for one Case. Enumerate the exact IDs from that Case's `测试点` section before writing parameters: every Markdown Test Point must appear once and no parameter ID may be invented, renamed or omitted. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.",
             "Name each generated pytest file so it corresponds one-to-one with its source Markdown module file: for each `testcase/md/<module>.md` (excluding README.md), emit exactly one `testcase/test_<module>.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `testcase/md/resource_notes.md` maps to `testcase/test_resource_notes.py`, `testcase/md/health.md` maps to `testcase/test_health.py`, `testcase/md/BE-HEALTH.md` maps to `testcase/test_be_health.py`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes such as `test_be_*` unless the module filename itself normalizes to that stem. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
             "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.",
             "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
@@ -3510,51 +3574,80 @@ async function buildBackendTestHybridDag(sources) {
             "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
         ].join("\n\n"),
     };
-    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Record advisory findings when a real Markdown case heading has no associated pytest test function or class method in the script explicitly mapped by that Markdown case, or when a mapped HTTP test script lacks request parameters logging, response result logging, recursive redaction or bounded truncation evidence. Accept exact Case IDs in the function/method name or its decorator/body/docstring region. Do not scan unrelated test_*.py files and do not block pytest execution.", "Run-owned reports/backend-test-traceability.md with PASS/FAIL advisory findings for Markdown Case to mapped pytest script/symbol coverage.");
+    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Deterministically scan only Markdown-mapped pytest scripts. Keep the existing traceability/logging checks and also produce a bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol/parameter ID correspondence analysis. Report 1:1, 1:0, 1:N, 0:1, script mismatch, missing Case ID and missing/extra parameter IDs. Human and machine evidence must come from the same facts. Findings are advisory and never block pytest.", "Run-owned reports/backend-test-traceability.md, reports/backend-test-markdown-pytest-correspondence.md and contracts/backend-test-markdown-pytest-correspondence-facts.json with PASS/FAIL/UNAVAILABLE correspondence facts.");
+    const manifest = shellNode("backend-test-case-manifest-shell", [traceability.id], "markdown-manifest", "Materialize the canonical Backend Test Case Manifest only from contracts/backend-test-case-coverage-facts.json and contracts/backend-test-markdown-pytest-correspondence-facts.json. Validate schema, task binding, input hashes and freshness; never re-read source semantics, re-analyze Coverage Matrix, rescan pytest symbols or recompute a second set of metrics. Missing/stale/conflicting facts produce partial/unavailable diagnostics rather than fabricated zeros.", "Run-owned contracts/backend-test-case-manifest.json with materializationStatus, sourceFactsIssues, validated coverageSummary, ruleCoverageSummary and correspondenceSummary; this is the single machine input for L-5 and closeout.");
     const pytestCommand = [
         'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
         'echo "pytest targets are resolved at runtime from final Markdown 自动化映射"',
     ].join("; ");
-    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Prefer the deterministic module one-to-one path when a mapped script is missing but the module stem file exists. Generate a native pytest-html self-contained report, then render the primary self-contained Chinese HTML report from the same pytest-html plus final Markdown case metadata without rerun. Keep 测试结论, quality status, failure overview, and a polished per-case result card with concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over Markdown-mapped scripts producing a valid pytest-html report with per-case captured output, self-contained reports/backend-test.html, reports/backend-test.md, reports/backend-test-facts.md, a deterministic self-contained reports/backend-test-l5-dashboard.html (machine-computed L-5 metrics, no JSON), and an optional contracts/code-coverage-v1.json when jacocoCoverage is configured (JaCoCo TCP dump → jacoco.xml → parsed; failure-safe); exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [manifest.id], "markdown-execute-html", "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Prefer the deterministic module one-to-one path when a mapped script is missing but the module stem file exists. Generate a native pytest-html self-contained report, then render the primary self-contained Chinese HTML report from the same pytest-html plus final Markdown case metadata without rerun. Keep 测试结论 and quality status; make node 4 Markdown validation + case coverage and node 6 traceability + Markdown-to-pytest correspondence expandable to their full escaped details; show each failure overview item with its original pytest message plus deterministic evidence-based reason analysis; list failure/error case cards before the remaining cases while preserving stable order. Each polished per-case result card includes concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over Markdown-mapped scripts producing a valid pytest-html report with per-case captured output, self-contained reports/backend-test.html, reports/backend-test.md, reports/backend-test-facts.md, a deterministic self-contained reports/backend-test-l5-dashboard.html (machine-computed L-5 metrics, no JSON), and an optional contracts/code-coverage-v1.json when jacocoCoverage is configured (JaCoCo TCP dump → jacoco.xml → parsed; failure-safe); exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
     if (execute.shell) {
         execute.shell.envAllowlist = collectBackendTestShellEnvAllowlist(sources);
     }
     const canWriteReport = taskAllowsBackendTestReportWrite(sources);
     const report = {
-        id: "backend-test-report-and-l5-pi", depends_on: [execute.id], role: "closeout", executor: "pi", complexity: "MED",
+        id: "backend-test-report-and-l5-pi",
+        depends_on: [execute.id],
+        role: "closeout",
+        executor: "pi",
+        complexity: "MED",
         ...(canWriteReport
-            ? { toolProfile: "write", writePolicy: "exclusive", writeSet: ["docs/test-reports/**"], allowedPaths: ["docs/test-reports/**"] }
+            ? {
+                toolProfile: "write",
+                writePolicy: "exclusive",
+                writeSet: ["docs/test-reports/**"],
+                allowedPaths: ["docs/test-reports/**"],
+            }
             : { writePolicy: "read-only", allowedPaths: ro }),
         forbiddenPaths: forbidden,
-        outputContract: canWriteReport ? "Final Markdown report and L-5 conclusion under docs/test-reports/**; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked, not re-rendered; no JSON." : "Final Markdown report and L-5 conclusion in assistant output; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked; no JSON or writes.",
+        outputContract: canWriteReport
+            ? "Final Markdown report and L-5 conclusion under docs/test-reports/**; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked, not re-rendered; no JSON."
+            : "Final Markdown report and L-5 conclusion in assistant output; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked; no JSON or writes.",
         subtask_prompt: [
-            "Generate the final Markdown report from upstream facts and run-owned environment, advisory case-validation, advisory traceability, pytest-html and HTML evidence. Do not emit JSON.",
+            "Generate the final Markdown report only from authoritative run-owned artifacts. Read node 1 reports/backend-test-environment.md; node 4 backend-md-case-validation.md and backend-test-case-coverage-analysis.md; node 6 backend-test-traceability.md and backend-test-markdown-pytest-correspondence.md; node 7 contracts/backend-test-case-manifest.json; and node 8 backend-test-result.json, backend-test-facts.md, pytest-html/HTML and L-5 dashboard. Do not use node 2/3/5 assistant prose as facts. Do not emit JSON.",
             "Use this exact human-facing section order: 测试结论 → 执行概览 → 质量校验 → 失败分析 → 风险与建议 → 证据与 L-5. Put the decision and key numbers first, use compact tables/bullets, and keep headings concise. Do not paste entire upstream reports, duplicate per-case tables already present in facts, or repeat the same evidence in multiple sections; link to paths/hashes and quote only the findings needed for the conclusion.",
-            "The L-5 metrics and visualization are already produced deterministically by node 7 at reports/backend-test-l5-dashboard.html (rendered from computeL5ReportMetrics). Link to that dashboard as the authoritative L-5 view; do not recompute pass/AC/automation/coverage numbers or re-render an HTML dashboard yourself. Quote its L-5 decision verbatim.",
-            "Always state the exact PASS/FAIL status and findings from nodes 4 and 6. Their FAIL status does not block pytest, but it must remain visible as a quality/traceability risk and must never be rewritten as PASS.",
+            "The L-5 metrics and visualization are produced deterministically by node 8 at reports/backend-test-l5-dashboard.html. Link to that dashboard as the authoritative L-5 view. Pytest execution facts come from node 8; coverage/correspondence numbers and materializationStatus come from node 7; detailed coverage findings come from node 4; detailed mapping findings come from node 6. Never recompute these values. If machine manifest and human reports disagree, report evidence inconsistency rather than silently choosing.",
+            "Always state the exact PASS/FAIL/UNAVAILABLE status and findings from node 4 case validation + coverage and node 6 traceability + correspondence. Their FAIL status does not block pytest, but it must remain visible and must never be rewritten as PASS.",
             "Include environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage availability, and L-5 READY/NOT READY.",
             "Never override Shell/pytest-html facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.",
-            canWriteReport ? "Write only under docs/test-reports/**." : "Keep the full report in assistant output.",
+            canWriteReport
+                ? "Write only under docs/test-reports/**."
+                : "Keep the full report in assistant output.",
         ].join("\n\n"),
     };
     const spec = {
-        version: 3, title: `Backend test DAG: ${taskConfig.title}`,
+        version: 3,
+        title: `Backend test DAG: ${taskConfig.title}`,
         runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
         outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
         objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
         globalConstraints: [
-            ...taskConfig.hardConstraints, ...STANDARD_GLOBAL_CONSTRAINTS,
-            "backend-test-dag uses exactly 8 real top-level tasks and executes pytest exactly once over only the safe scripts explicitly mapped by final Markdown cases.",
+            ...taskConfig.hardConstraints,
+            ...STANDARD_GLOBAL_CONSTRAINTS,
+            "backend-test-dag uses exactly 9 real top-level tasks and executes pytest exactly once over only the safe scripts explicitly mapped by final Markdown cases.",
             "Model nodes produce Markdown and pytest assets, never backend-test business JSON envelopes.",
-            "Environment, advisory Markdown validation, advisory traceability, pytest-html, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8.",
+            "Environment, advisory Markdown validation/coverage, advisory traceability/correspondence, canonical manifest, pytest-html, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8; node 7 partial/unavailable does not block node 8.",
             "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
             "Functional case IDs use BE-<MODULE>-<NNN>; production code/config, skip/xfail, repair and rerun are forbidden.",
         ],
-        defaults: { ...BACKEND_TEST_DEFAULTS, contextProfile: taskConfig.contextProfile },
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
         skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        tasks: [environment, generateCases, reviewCases, validateCases, generatePytest, traceability, execute, report],
+        tasks: [
+            environment,
+            generateCases,
+            reviewCases,
+            validateCases,
+            generatePytest,
+            traceability,
+            manifest,
+            execute,
+            report,
+        ],
     };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
@@ -3604,7 +3697,8 @@ function buildFrontendTestHybridDag(sources) {
         "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 caseIdRe=/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;", ,
+        "const caseIdRe=/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;",
+        ,
         "const acIdRe=/^AC(?:-[A-Z0-9]+)+$/i;",
         "for(const c of manifest.cases){",
         " const id=c&&c.caseId||'?';",
@@ -3614,7 +3708,8 @@ function buildFrontendTestHybridDag(sources) {
         " if(!casePath||!fs.existsSync(casePath)){issues.push({ruleId:'case-file-missing',caseId:id,detail:String(casePath)});continue;}",
         " if(typeof c.caseId==='string'&&casePath!=='testcase/frontend/cases/'+c.caseId+'.md')issues.push({ruleId:'case-path-mismatch',caseId:id,detail:casePath+' must equal testcase/frontend/cases/'+c.caseId+'.md'});",
         " 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>; playwright-cli is strongly recommended for browser execution'});", ,
+        " if(!openRe.test(body))issues.push({ruleId:'open-prefix',caseId:id,detail:'missing playwright-cli open --browser=chrome --headed <absolute-url>; playwright-cli is strongly recommended for browser execution'});",
+        ,
         " 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(!Array.isArray(c.acIds)||c.acIds.length===0)issues.push({ruleId:'ac-mapping',caseId:id,detail:'acIds required (AC-FE-* acceptance ids, not caseId)'});",
@@ -3729,7 +3824,7 @@ function buildFrontendTestHybridDag(sources) {
                 commands: [
                     [
                         "node -e",
-                        JSON.stringify("const fs=require('fs');const {spawnSync}=require('child_process');const p='testcase/frontend/rag/context.md';const probePath='testcase/frontend/rag/environment-probe.json';function writeProbe(obj){try{fs.mkdirSync('testcase/frontend/rag',{recursive:true});fs.writeFileSync(probePath,JSON.stringify(obj,null,2)+'\\n');let ctx=fs.existsSync(p)?fs.readFileSync(p,'utf8'):'';const line='environmentProbe: '+obj.status+(obj.blockedReason?(' ('+obj.blockedReason+')'):'');if(/environmentProbe\\s*[:=]/i.test(ctx)){ctx=ctx.replace(/environmentProbe\\s*[:=]\\s*.*/i,line);}else{ctx=ctx.trimEnd()+'\\n\\n'+line+'\\n';}fs.writeFileSync(p,ctx);}catch(e){console.error('probe-write-failed',e&&e.message||e);}}function redactUrl(u){try{const x=new URL(u);x.username='';x.password='';if(x.search){x.search='';}return x.toString();}catch(_){return String(u).replace(/\\/\\/[^@\\s]+@/g,'//');}}function failBlocked(reason,extra){const payload=Object.assign({status:'unreachable',blockedReason:reason,baseUrlRedacted:extra&&extra.baseUrlRedacted||null,httpStatus:extra&&extra.httpStatus||null,method:extra&&extra.method||null,curlExit:extra&&extra.curlExit||null,errorClass:extra&&extra.errorClass||null},extra||{});writeProbe(payload);console.error('frontend-test preflight blocked: '+JSON.stringify({blockedReason:reason,baseUrl:payload.baseUrlRedacted,httpStatus:payload.httpStatus,errorClass:payload.errorClass}));throw new Error('frontend-test preflight blocked: '+reason);}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);const safe=redactUrl(baseUrl);const curlCheck=spawnSync('curl',['--version'],{encoding:'utf8'});if(curlCheck.error||curlCheck.status!==0){failBlocked('curl-unavailable',{baseUrlRedacted:safe,errorClass:'curl-missing'});}function probe(method){const args=['-sS','-o','/dev/null','-w','%{http_code}','--connect-timeout','3','--max-time','8','-X',method,'-L','--max-redirs','3','--http1.1','--proto-redir','=http,https',safe];const r=spawnSync('curl',args,{encoding:'utf8'});return r;}let used='HEAD';let r=probe('HEAD');let code=String(r.stdout||'').trim();let statusNum=parseInt(code,10);const headRejected=r.status!==0||!statusNum||statusNum===405||statusNum===501;if(headRejected){used='GET';r=probe('GET');code=String(r.stdout||'').trim();statusNum=parseInt(code,10);}const ok=statusNum>=200&&statusNum<400;if(!ok){const errClass=r.error?'spawn-error':(r.status!==0?'curl-exit-'+r.status:('http-'+statusNum));failBlocked('frontend-base-url-unreachable',{baseUrlRedacted:safe,httpStatus:statusNum||null,method:used,curlExit:r.status,errorClass:errClass});}writeProbe({status:'reachable',blockedReason:null,baseUrlRedacted:safe,httpStatus:statusNum,method:used,curlExit:r.status});console.log('frontend-test-execution-v1 validated baseUrl='+safe+' probe=reachable method='+used+' httpStatus='+statusNum);"),
+                        JSON.stringify("const fs=require('fs');const {spawnSync}=require('child_process');const p='testcase/frontend/rag/context.md';const probePath='testcase/frontend/rag/environment-probe.json';function writeProbe(obj){try{fs.mkdirSync('testcase/frontend/rag',{recursive:true});fs.writeFileSync(probePath,JSON.stringify(obj,null,2)+'\\n');let ctx=fs.existsSync(p)?fs.readFileSync(p,'utf8'):'';const line='environmentProbe: '+obj.status+(obj.blockedReason?(' ('+obj.blockedReason+')'):'');if(/environmentProbe\\s*[:=]/i.test(ctx)){ctx=ctx.replace(/environmentProbe\\s*[:=]\\s*.*/i,line);}else{ctx=ctx.trimEnd()+'\\n\\n'+line+'\\n';}fs.writeFileSync(p,ctx);}catch(e){console.error('probe-write-failed',e&&e.message||e);}}function redactUrl(u){try{const x=new URL(u);x.username='';x.password='';if(x.search){x.search='';}return x.toString();}catch(_){return String(u).replace(/\\/\\/[^@\\s]+@/g,'//');}}function failBlocked(reason,extra){const payload=Object.assign({status:'unreachable',blockedReason:reason,baseUrlRedacted:extra&&extra.baseUrlRedacted||null,httpStatus:extra&&extra.httpStatus||null,method:extra&&extra.method||null,curlExit:extra&&extra.curlExit||null,errorClass:extra&&extra.errorClass||null},extra||{});writeProbe(payload);console.error('frontend-test preflight blocked: '+JSON.stringify({blockedReason:reason,baseUrl:payload.baseUrlRedacted,httpStatus:payload.httpStatus,errorClass:payload.errorClass}));throw new Error('frontend-test preflight blocked: '+reason);}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(/[)\\}\\],.\\\"'\\x60]+$/,'');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);const safe=redactUrl(baseUrl);const curlCheck=spawnSync('curl',['--version'],{encoding:'utf8'});if(curlCheck.error||curlCheck.status!==0){failBlocked('curl-unavailable',{baseUrlRedacted:safe,errorClass:'curl-missing'});}function probe(method){const args=['-sS','-o','/dev/null','-w','%{http_code}','--connect-timeout','3','--max-time','8','-X',method,'-L','--max-redirs','3','--http1.1','--proto-redir','=http,https',safe];const r=spawnSync('curl',args,{encoding:'utf8'});return r;}let used='HEAD';let r=probe('HEAD');let code=String(r.stdout||'').trim();let statusNum=parseInt(code,10);const headRejected=r.status!==0||!statusNum||statusNum===405||statusNum===501;if(headRejected){used='GET';r=probe('GET');code=String(r.stdout||'').trim();statusNum=parseInt(code,10);}const ok=statusNum>=200&&statusNum<400;if(!ok){const errClass=r.error?'spawn-error':(r.status!==0?'curl-exit-'+r.status:('http-'+statusNum));failBlocked('frontend-base-url-unreachable',{baseUrlRedacted:safe,httpStatus:statusNum||null,method:used,curlExit:r.status,errorClass:errClass});}writeProbe({status:'reachable',blockedReason:null,baseUrlRedacted:safe,httpStatus:statusNum,method:used,curlExit:r.status});console.log('frontend-test-execution-v1 validated baseUrl='+safe+' probe=reachable method='+used+' httpStatus='+statusNum);"),
                     ].join(" "),
                 ],
                 cwd: ".",
@@ -3847,7 +3942,12 @@ function buildFrontendTestHybridDag(sources) {
         forbiddenPaths: forbidden,
         outputContract: "Mechanical checklist: manifest/case paths, Case ID, non-production playwright-cli open prefix, and AC mapping; alternative executable tool commands are not inspected or blocked.",
         subtask_prompt: "Scan generated cases/manifest for structural and safety rules only. Strongly recommend playwright-cli for browser execution, but do not inspect or reject alternative executable tool commands and do not use free-form LLM verdicts.",
-        shell: { commands: [checklistValidation], cwd: ".", timeoutMs: 120000 },
+        shell: {
+            commands: [],
+            frontendTestCaseChecklist: {},
+            cwd: ".",
+            timeoutMs: 120000,
+        },
     }, {
         id: "materialize-frontend-case-manifest-shell",
         depends_on: ["frontend-case-checklist-shell"],
@@ -3923,7 +4023,12 @@ function buildFrontendTestHybridDag(sources) {
         forbiddenPaths: forbidden,
         outputContract: "Deterministic evidence gate: missing/malformed evidence is advisory; only unsafe evidenceDir or evidence paths hard-fail. Does not block retrospect.",
         subtask_prompt: "Validate frontend case evidence before result materialization. Keep missing or malformed evidence as advisory findings; only path-escape failures abort the node.",
-        shell: { commands: [], frontendTestEvidenceValidation: {}, cwd: ".", timeoutMs: 120000 },
+        shell: {
+            commands: [],
+            frontendTestEvidenceValidation: {},
+            cwd: ".",
+            timeoutMs: 120000,
+        },
     }, {
         id: "materialize-frontend-test-result-shell",
         depends_on: ["validate-frontend-case-evidence-shell"],
@@ -3947,10 +4052,24 @@ function buildFrontendTestHybridDag(sources) {
             timeoutMs: 120000,
         },
     });
+    tasks.push({
+        id: "frontend-test-l5-report-shell",
+        depends_on: ["materialize-frontend-test-result-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/frontend/reports/**"],
+        allowedPaths: ["testcase/frontend/**"],
+        forbiddenPaths: forbidden,
+        outputContract: "Deterministic frontend L-5 Markdown and self-contained HTML dashboard derived only from frontend-test-result-v1.",
+        subtask_prompt: "Render the authoritative frontend L-5 report from frontend-test-result-v1. Do not use Pi prose or invent code coverage. Missing line/branch coverage remains unavailable and makes L-5 NOT READY.",
+        shell: { frontendTestL5Report: {}, commands: [], cwd: ".", timeoutMs: 120000 },
+    });
     if (strictOutcomeGate) {
         tasks.push({
             id: "frontend-test-result-outcome-gate-shell",
-            depends_on: ["materialize-frontend-test-result-shell"],
+            depends_on: ["materialize-frontend-test-result-shell", "frontend-test-l5-report-shell"],
             role: "verifier",
             executor: "shell",
             complexity: "LOW",
@@ -3968,7 +4087,7 @@ function buildFrontendTestHybridDag(sources) {
     }
     tasks.push({
         id: "frontend-test-retrospect-pi",
-        depends_on: ["materialize-frontend-test-result-shell"],
+        depends_on: ["materialize-frontend-test-result-shell", "frontend-test-l5-report-shell"],
         role: "closeout",
         executor: "pi",
         toolProfile: "write",
@@ -3978,10 +4097,10 @@ function buildFrontendTestHybridDag(sources) {
         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.",
+        subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/ after result materialization and L-5 report generation. Combine AC→case→browser-evidence review with the closeout report: coverage, the exact L-5 READY/NOT READY decision, 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 recompute L-5 metrics or replace browser evidence with model conclusions. Do not write docs/**. Pipeline success is report production, not case full green.",
     });
     tasks.push({
-        id: "frontend-test-quality-report-html-shell",
+        id: "frontend-test-html-report-shell",
         depends_on: ["frontend-test-retrospect-pi"],
         role: "verifier",
         executor: "shell",
@@ -3990,9 +4109,14 @@ function buildFrontendTestHybridDag(sources) {
         writeSet: ["testcase/frontend/reports/**"],
         allowedPaths: ["testcase/frontend/**"],
         forbiddenPaths: forbidden,
-        outputContract: "Write a user-readable HTML advisory report after the final Markdown retrospective; findings never block the workflow.",
-        subtask_prompt: "Generate the frontend case quality advisory Markdown and HTML report after the final test report. Record content findings only and never fail because findings exist.",
-        shell: { commands: [frontendCaseQualityAdvisory], cwd: ".", timeoutMs: 120000 },
+        outputContract: "Write testcase/frontend/reports/frontend-test-report.md and frontend-test-report.html from frontend-test-result-v1, containing only case execution results, case content, and failed/blocked error analysis.",
+        subtask_prompt: "Render the formal frontend test Markdown and HTML report from the current run frontend-test-result-v1. Do not include evidence chains, evidence paths or hashes, advisory findings, quality suggestions, improvement suggestions, or ratings.",
+        shell: {
+            commands: [],
+            frontendTestHtmlReport: {},
+            cwd: ".",
+            timeoutMs: 120000,
+        },
     });
     const globalConstraints = [
         ...sources.taskConfig.hardConstraints,
@@ -5114,7 +5238,7 @@ function cloneTask(task, patch = {}) {
 }
 /**
  * Apply the default read-only Pi retry policy to safe planner/scout/reviewer/
- * verifier/closeout Pi nodes in the generated DAG. Writers, supervisors,
+ * verifier/supervisor/closeout Pi nodes in the generated DAG. Writers,
  * dynamic, shell, static, and decision-gate nodes are skipped. Idempotent:
  * never overwrites an explicit retryPolicy a task already declares.
  */
@@ -5233,6 +5357,14 @@ function buildReviewGateNode(sources) {
 }
 function enableProjectGovernanceOnNode(task) {
     task.governanceStandardReview = true;
+    task.outputProtocol = REVIEW_VERDICT_OUTPUT_PROTOCOL;
+    task.retryPolicy = PROTOCOL_AWARE_PI_RETRY_POLICY;
+    task.outputContract =
+        "Plain Markdown whose first non-empty line is exactly VERDICT: pass or VERDICT: request-revision; unresolved mandatory governance violations force request-revision. No file writes.";
+    const protocolInstruction = "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.";
+    if (!task.subtask_prompt.includes(protocolInstruction)) {
+        task.subtask_prompt = `${protocolInstruction}\n\n${task.subtask_prompt}`;
+    }
 }
 /**
  * Apply governance only to general implementation DAGs, and only when the
@@ -5309,6 +5441,7 @@ function insertGovernanceStandardGate(spec, sources) {
     const closeoutIndex = spec.tasks.findIndex((task) => task.id === "closeout-pi");
     spec.tasks.splice(closeoutIndex, 0, gate);
     closeout.depends_on = ["governance-standard-gate-shell"];
+    closeout.failureAwareDependsOn = ["governance-standard-gate-shell"];
 }
 function buildReviewGatedHybridDag(standard, sources) {
     const spec = {
@@ -5322,7 +5455,10 @@ function buildReviewGatedHybridDag(standard, sources) {
         tasks: standard.tasks.map((task) => ({ ...task })),
     };
     const closeout = getTaskOrThrow(spec, "closeout-pi");
-    replaceTask(spec, cloneTask(closeout, { depends_on: ["review-gate-shell"] }));
+    replaceTask(spec, cloneTask(closeout, {
+        depends_on: ["review-gate-shell"],
+        failureAwareDependsOn: ["review-gate-shell"],
+    }));
     spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewVerdictRecoveryNode(sources), buildReviewGateNode(sources));
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     applyDefaultReadOnlyRetryPolicy(spec);
@@ -5528,6 +5664,7 @@ function buildProcessSupervisorNode(sources) {
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
         outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by a REPAIR_ARTIFACT_JSON fenced block. Audit writeSet coverage, boundary drift, verification gaps, repair scope. No file writes.",
+        outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
         subtask_prompt: [
             "Supervise the implementation process after soft verification.",
             "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
@@ -5663,6 +5800,53 @@ function buildDecisionNode(sources) {
         decisionGate: { enabled: true, schemaVersion: 1, mode: "record-only" },
     };
 }
+/**
+ * Supervised convergence chain node ids. Extends the controller default
+ * (process-supervisor → process-gate → repair → hard-verify) with the review
+ * chain so that a legitimate review `request-revision` re-enters the same
+ * bounded repair-reverify-review loop instead of only blocking closeout.
+ */
+export const SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS = [
+    "process-supervisor-pi",
+    "process-gate-shell",
+    "repair-pi",
+    "hard-verify-shell",
+    "review-pi",
+    "review-verdict-recovery-pi",
+    "review-gate-shell",
+];
+/**
+ * Derive the supervised DAG convergence spec from `maxFixLoops`. Unlike the
+ * task-level `convergence` config (which stays opt-in / disabled by default
+ * until smoke evidence is stronger), the supervised path uses `maxFixLoops`
+ * as the authoritative bounded-repair budget:
+ * - `maxFixLoops > 0` ⇒ convergence enabled, `maxPasses = maxFixLoops + 1`
+ *   (initial execution + repair budget), with the full supervised chain.
+ * - `maxFixLoops === 0` ⇒ convergence disabled (no automatic repair).
+ * An explicit user `convergence.enabled: true` does not override `maxFixLoops`;
+ * the budget still wins so total pass count stays consistent (AC1/AC2).
+ */
+function resolveSupervisedConvergence(taskConfig) {
+    const maxFixLoops = taskConfig.maxFixLoops;
+    if (maxFixLoops <= 0) {
+        return {
+            enabled: false,
+            maxPasses: 1,
+            stopOnVerdictPass: true,
+            stopOnHardVerifyPass: true,
+            pauseOnRegression: true,
+            chainNodeIds: [...SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS],
+        };
+    }
+    return {
+        enabled: true,
+        maxPasses: maxFixLoops + 1,
+        stopOnVerdictPass: true,
+        stopOnHardVerifyPass: true,
+        pauseOnRegression: taskConfig.convergence?.pauseOnRegression ?? true,
+        chainNodeIds: [...SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS],
+    };
+}
 function buildSupervisedHybridDag(standard, sources) {
     const contract = getTaskOrThrow(standard, "contract-pi");
     const scoutSrc = getTaskOrThrow(standard, "scout-src");
@@ -5687,7 +5871,7 @@ function buildSupervisedHybridDag(standard, sources) {
         title: `Supervised ${standard.title}`,
         objective: `${standard.objective ?? ""}\n\nRoute: supervised implementation DAG selected by workflowPolicy/governanceProfile or explicit CLI profile.`.trim(),
         globalConstraints: supervisedConstraints,
-        convergence: sources.taskConfig.convergence,
+        convergence: resolveSupervisedConvergence(sources.taskConfig),
         verifyStrategy: resolveDagVerifyStrategy(sources.taskConfig, "1"),
         tasks: [
             cloneTask(contract),
@@ -5732,7 +5916,10 @@ function buildSupervisedHybridDag(standard, sources) {
             buildReviewVerdictRecoveryNode(sources),
             buildReviewGateNode(sources),
             buildDecisionNode(sources),
-            cloneTask(closeout, { depends_on: ["decision-pi"] }),
+            cloneTask(closeout, {
+                depends_on: ["decision-pi"],
+                failureAwareDependsOn: ["decision-pi"],
+            }),
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());