@tea-agent/loop-agent 0.28.13 → 0.29.1

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

@@ -9,7 +9,7 @@ import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
@@ -3716,9 +3716,11 @@ async function buildBackendTestHybridDag(sources) {
             type: "implementation-outcome-v1",
             requireChangedFiles: true,
         },
+        retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
         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: [
             "This is a required file-generation node. After reading the bounded inputs, immediately use write/edit tools to create testcase/md/README.md and the module Markdown files. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists.",
+            "Output budget protocol (hard, max output <=16K per turn): Never paste full Matrix, case bodies, or source text into assistant chat. Each write/edit tool call touches at most one file. Order: README.md (Scope+Matrix+module index only) → one module file per turn → short IMPLEMENTATION_OUTCOME. Splitting modules preserves every in-scope rule/TP; it must not drop coverage. Compact tables/lists are required; omitting required sections or in-scope variants is forbidden. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.",
             "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the required files have been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.",
             "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.",
@@ -3754,6 +3756,8 @@ async function buildBackendTestHybridDag(sources) {
         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.",
+            "Output budget protocol: default to local edit per file; never dump full Matrix/case bodies into assistant chat. Review order is README (Scope/Matrix) then one module file per turn. When adding omitted in-scope cases, write one file per tool call and keep every required section. Do not bulk-delete in-scope cases to save tokens.",
+            "For every variant Test Point, ensure the Markdown scenario intent is machine-checkable: prefer an explicit line `场景意图: <empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal|custom-literal:V>; field=<name>; bound=<n optional>; example=<optional>` near 测试数据/操作步骤, and keep pytest params later aligned to that intent.",
             "Independently reconstruct the change classification, affected operations/rules, P0 product scenarios and applicable P1 documented API rules from authoritative sources before trusting the generated Coverage Scope or Coverage Matrix. Perform an explicit coverage-scope review: reject `new-operation` when the task only optimizes an existing implementation without contract change; reject narrow optimization scope when shared validator/helper/DTO/query builder evidence directly affects more operations; reject full-contract expansion across unrelated operations. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Directly add in-scope omissions; undefined impact remains 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 `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in `testcase/md/README.md`, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, 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`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol, assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, ensure every binding-list Test Point is also present in that Case's `### 测试点`, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. 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. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
@@ -3780,9 +3784,16 @@ async function buildBackendTestHybridDag(sources) {
         ],
         allowedPaths: Array.from(new Set([...ro, "testcase/**"])),
         forbiddenPaths: forbidden,
+        retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+        writerOutcomePolicy: {
+            type: "implementation-outcome-v1",
+            requireChangedFiles: true,
+        },
         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.",
+            "Output budget protocol (hard, max output <=16K per turn): Write helpers/factories first, then exactly one test_<module>.py per write/edit tool call following MD stems. Never paste full Python modules into assistant chat. Do not merge modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.",
+            "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them.",
             'Ensure every final Markdown Case ID appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id="TP-...")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task\'s explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. 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.",
@@ -3822,6 +3833,7 @@ async function buildBackendTestHybridDag(sources) {
             "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution.",
             "Fix only collection-proven generated testcase-local defects: create the exact safe missing mapped test_*.py paths listed by the initial facts, or repair syntax, module path, missing symbol, circular import, fixture-name, decorator or parameterization inconsistencies. Inspect all affected importers and providers so the repair is cross-file consistent; do not create unrelated pytest scripts.",
             "Preserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.",
+            "Use local edit only on assessment-listed paths; keep summaries short; never rewrite unrelated modules.",
             "Do not read task source/** or reinterpret requirements. Do not modify Markdown, conftest, pytest config, production code or dependencies.",
             "Do not add skip/skipif/xfail, remove tests, reduce collected items, loosen assertions, swallow exceptions, use try/except ImportError fallback, mutate sys.path/PYTHONPATH, or replace the real API with mocks.",
             "Do not execute pytest; the deterministic effective collection gate owns the final collection attempt.",
@@ -3829,7 +3841,7 @@ async function buildBackendTestHybridDag(sources) {
     };
     const collectionEffective = shellNode("effective-backend-pytest-collection-gate-shell", [collectionAssess.id, repairPytest.id], "markdown-collection-effective", "If initial collection passed, verify unchanged asset hashes and reuse it without another collection. If the single repair ran, collect the final mapped scripts once and fail closed unless it passes. BLOCKED initial facts, repair failure, final collection failure or hash drift must prevent business pytest execution.", "Run-owned reports/backend-test-pytest-collection-effective.md and contracts/backend-test-pytest-collection-effective.json proving the exact final assets are collectable; initial PASS is reused, repair path records attempt=1.", [], 120000);
     collectionEffective.dependsPolicy = "all-or-condition-skip";
-    const traceability = shellNode("backend-test-traceability-gate-shell", [collectionEffective.id], "markdown-traceability", "Deterministically scan only Markdown-mapped pytest scripts after the effective hash-bound collection gate. Keep the existing traceability/logging checks and produce a bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol correspondence analysis. Map variant Test Points from stable parameter IDs, assertion Test Points from the primary symbol docstring, and cross-cutting Test Points from the primary symbol evidence binding. Report 1:1, 1:0, 1:N, 0:1, script/primary-symbol mismatch, missing Case ID, missing variant parameter IDs, missing assertion/cross-cutting bindings, duplicate modes and extra bindings. 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 bound after effective collection.");
+    const traceability = shellNode("backend-test-traceability-gate-shell", [collectionEffective.id], "markdown-traceability", "Deterministically scan only Markdown-mapped pytest scripts after the effective hash-bound collection gate. Keep the existing traceability/logging checks and produce a bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol correspondence analysis. Map variant Test Points from stable parameter IDs, assertion Test Points from the primary symbol docstring, and cross-cutting Test Points from the primary symbol evidence binding. Report 1:1, 1:0, 1:N, 0:1, script/primary-symbol mismatch, missing Case ID, missing variant parameter IDs, missing assertion/cross-cutting bindings, duplicate modes and extra bindings. In the same shell, assess scenario-intent vs pytest.param literal features, apply at most one deterministic pre-execution scenario-param repair for repairable MISMATCH entries, reassess final consistency, and bind asset hashes for execute. Findings for correspondence remain advisory; residual scenario-param MISMATCH is advisory unless strictScenarioParamGate is enabled. Never block pytest solely on correspondence FAIL.", "Run-owned reports/backend-test-traceability.md, reports/backend-test-markdown-pytest-correspondence.md, contracts/backend-test-markdown-pytest-correspondence-facts.json, reports/backend-test-scenario-param-consistency.md and contracts/backend-test-scenario-param-consistency-facts.json (initial+final) with optional repair audit; PASS/FAIL/UNAVAILABLE correspondence facts bound after effective collection.");
     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 coverageScope, coverageSummary, ruleCoverageSummary and correspondenceSummary; this is the single machine input for L-5 and closeout.");
     const pytestCommand = [
         'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
@@ -3859,8 +3871,9 @@ async function buildBackendTestHybridDag(sources) {
             ? "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 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; nodes 6/8 backend-test-pytest-collection initial/effective reports and facts; node 9 backend-test-traceability.md and backend-test-markdown-pytest-correspondence.md; node 10 contracts/backend-test-case-manifest.json; and node 11 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.",
+            "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; nodes 6/8 backend-test-pytest-collection initial/effective reports and facts; node 9 backend-test-traceability.md, backend-test-markdown-pytest-correspondence.md and backend-test-scenario-param-consistency.md; node 10 contracts/backend-test-case-manifest.json; and node 11 backend-test-result.json, backend-test-facts.md, backend-test-failure-analysis.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. Prefer linking reports/backend-test-failure-analysis.md for structured failure analysis rather than inventing classifications.",
+            "Output budget: list evidence paths first, then write a short fixed six-section report; never paste upstream full text into chat.",
             "The L-5 metrics and visualization are produced deterministically by node 11 at reports/backend-test-l5-dashboard.html. Link to that dashboard as the authoritative L-5 view. Pytest execution facts come from node 11; coverage/correspondence numbers and materializationStatus come from node 10; collection authorization comes from nodes 6/8; detailed coverage findings come from node 4; detailed mapping findings come from node 9. Never recompute these values. If machine manifest and human reports disagree, report evidence inconsistency rather than silently choosing.",
             "Always state the exact Coverage Scope classification, policy, affected operations, regression floor, completeness claim, PASS/FAIL/UNAVAILABLE status and findings from node 4 case validation + coverage, plus node 9 traceability + correspondence. Affected-scope or affected-operations-full coverage must never be described as whole-API completeness unless every operation is explicitly listed. 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. Distinguish Markdown Case count, primary pytest symbol count, collected pytest item count, variant/assertion/cross-cutting Test Point counts and execution amplification; never describe pytest item count as the number of business scenarios.",
@@ -3882,9 +3895,10 @@ async function buildBackendTestHybridDag(sources) {
             ...STANDARD_GLOBAL_CONSTRAINTS,
             "backend-test-dag uses exactly 12 real top-level tasks. Pytest collection runs once on the green path and at most twice only when one bounded pre-execution repair is eligible; business pytest test bodies execute exactly once over 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/coverage, collection initial/effective facts, advisory traceability/correspondence, canonical manifest, pytest-html, HTML and execution facts are deterministic evidence. Node 4 quality findings stay advisory; nodes 6/8 form the fail-closed collection authorization; node 9 traceability findings stay advisory; node 10 partial/unavailable manifest does not block node 11 when effective collection remains fresh.",
+            "Environment, advisory Markdown validation/coverage, collection initial/effective facts, advisory traceability/correspondence, pre-execution scenario-param consistency (with at most one deterministic param repair), canonical manifest, pytest-html, HTML, failure-analysis and execution facts are deterministic evidence. Node 4 quality findings stay advisory; nodes 6/8 form the fail-closed collection authorization; node 9 traceability/scenario-param findings stay advisory by default; node 10 partial/unavailable manifest does not block node 11 when effective collection remains fresh.",
             "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
-            "Functional case IDs use canonical BE-<MODULE>-<NNN> with exactly three digits and no alphabetic suffix. Every Test Point has exactly one variant/assertion/cross-cutting binding; only variant bindings create pytest parameter items. Production code/config, skip/xfail, execution-result repair and business pytest rerun are forbidden; the only repair is one pre-execution collection-proven generated-test asset repair.",
+            "Functional case IDs use canonical BE-<MODULE>-<NNN> with exactly three digits and no alphabetic suffix. Every Test Point has exactly one variant/assertion/cross-cutting binding; only variant bindings create pytest parameter items. Production code/config, skip/xfail, execution-result repair and business pytest rerun are forbidden; pre-execution repairs are limited to one collection-proven generated-test asset repair and one scenario-param payload repair (deterministic preferred).",
+            "Writer nodes must obey multi-file output-budget protocol under 16K max tokens: one file per write/edit, no chat dumps; Completeness Gate may trigger bounded incomplete-write-set recovery without lowering coverage quality.",
         ],
         defaults: {
             ...BACKEND_TEST_DEFAULTS,
@@ -3963,12 +3977,25 @@ function buildFrontendTestHybridDag(sources) {
         maxTotalTokens: rawFrontendTest?.maxTotalTokens,
         reviewMode: rawFrontendTest?.reviewMode ?? "off",
         strictOutcomeGate: rawFrontendTest?.strictOutcomeGate === true,
+        maxRerunAttempts: (() => {
+            const raw = rawFrontendTest?.maxRerunAttempts;
+            if (raw === undefined || raw === null || Number.isNaN(Number(raw)))
+                return 2;
+            return Math.min(4, Math.max(0, Math.trunc(Number(raw))));
+        })(),
+        reports: {
+            retrospect: rawFrontendTest?.reports?.retrospect === true,
+            l5: rawFrontendTest?.reports?.l5 !== false,
+        },
     };
     const declaredRequirementIds = buildDagSourceBinding(sources).requirementIds;
     const declaredAcIds = declaredRequirementIds.filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
     const reviewMode = config.reviewMode;
     const blockingReview = reviewMode === "blocking";
     const strictOutcomeGate = config.strictOutcomeGate;
+    const maxRerunAttempts = config.maxRerunAttempts ?? 2;
+    const enableRetrospect = config.reports?.retrospect === true;
+    const enableL5Report = config.reports?.l5 !== false;
     const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
         pattern === "testcase/**" ||
         pattern === "**");
@@ -3999,7 +4026,7 @@ function buildFrontendTestHybridDag(sources) {
         "if(!Array.isArray(manifest.cases)||manifest.cases.length===0)throw new Error('checklist: empty cases');",
         `const declaredAc=new Set(${declaredAcIdsLiteral});`,
         "const issues=[];",
-        "const openRe=/playwright-cli\\s+open\\s+--browser=chrome\\s+--headed\\s+https?:\\/\\/\\S+/i;",
+        "const openRe=/playwright-cli\\s+open\\s+--browser=chrome\\s+--headless\\s+https?:\\/\\/\\S+/i;",
         "const prodRe=/(?:^|\\/\\/)(?:www\\.)?[^\\s\\/]*(?:prod|production)/i;",
         "const caseIdRe=/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;",
         ,
@@ -4012,9 +4039,9 @@ 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 --headless <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);",
+        " const m=body.match(/playwright-cli\\s+open\\s+--browser=chrome\\s+--headless\\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)'});",
         " else {",
@@ -4111,13 +4138,34 @@ function buildFrontendTestHybridDag(sources) {
             },
         },
         {
-            id: "retrieve-frontend-test-context-pi",
+            id: "prepare-frontend-test-package-shell",
             depends_on: ["preflight-frontend-browser-tool-shell"],
+            role: "verifier",
+            executor: "shell",
+            complexity: "LOW",
+            writePolicy: "exclusive",
+            writeSet: ragWriteSet,
+            allowedPaths: [...ragWriteSet],
+            forbiddenPaths: forbidden,
+            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
+            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package.",
+            shell: {
+                commands: [
+                    ["node -e", JSON.stringify("const fs=require('fs'),path=require('path');const dest='testcase/frontend/rag/standard-scenarios.v1.json';const candidates=[path.join('docs','templates','frontend-test-standard-scenarios.v1.json')];let src=null;for(const c of candidates){if(fs.existsSync(c)){src=c;break;}}fs.mkdirSync(path.dirname(dest),{recursive:true});if(src){fs.copyFileSync(src,dest);process.stdout.write(JSON.stringify({status:'copied',from:src,to:dest}));}else{const minimal={schemaVersion:1,id:'frontend-test-standard-scenarios-v1',scenarios:[{id:'STD-FE-SMOKE-ENTRY',title:'入口可打开',category:'smoke',priority:'must',testPoints:['open'],minCases:1}]};fs.writeFileSync(dest,JSON.stringify(minimal,null,2)+'\n');process.stdout.write(JSON.stringify({status:'fallback',to:dest}));}")].join(" "),
+                ],
+                cwd: ".",
+                timeoutMs: 60_000,
+            },
+        },
+        {
+            id: "retrieve-frontend-test-context-pi",
+            depends_on: ["prepare-frontend-test-package-shell"],
             role: "planner",
             executor: "pi",
             toolProfile: "write",
             complexity: "MED",
             writePolicy: "exclusive",
+            writeGuardPolicy: "tools-only",
             writeSet: ragWriteSet,
             allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet],
             forbiddenPaths: forbidden,
@@ -4126,7 +4174,7 @@ function buildFrontendTestHybridDag(sources) {
                 "Build the frontend test RAG package (keep it short).",
                 "Read task source, routes/components/API or Mock facts, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.",
                 "Prefer fixed fields: baseUrl, baseUrlSource, environmentProbe, AC table, capability matrix (backend real/mock, pagination data, HTTP observation, error injection), risks, forbidden hosts. Do not paste large implementation dumps.",
-                `Controller-frozen origin (required, not model-selectable): write exactly \`baseUrl: ${controllerFrontend.baseUrl}\` and \`baseUrlSource: ${controllerFrontend.baseUrlSource}\`. Do not derive, replace, or override the origin from model reasoning or other repository text. Write \`environmentProbe: pending\`. Include exact start prefix: playwright-cli open --browser=chrome --headed ${controllerFrontend.baseUrl}.`,
+                `Controller-frozen origin (required, not model-selectable): write exactly \`baseUrl: ${controllerFrontend.baseUrl}\` and \`baseUrlSource: ${controllerFrontend.baseUrlSource}\`. Do not derive, replace, or override the origin from model reasoning or other repository text. Write \`environmentProbe: pending\`. Include exact start prefix: playwright-cli open --browser=chrome --headless ${controllerFrontend.baseUrl}.`,
                 buildSourceContextBlock(sources),
             ].join("\n\n"),
         },
@@ -4161,12 +4209,14 @@ function buildFrontendTestHybridDag(sources) {
             toolProfile: "write",
             complexity: "HIGH",
             writePolicy: "exclusive",
+            writeGuardPolicy: "tools-only",
             writeSet: caseDraftWriteSet,
             allowedPaths: [...ragWriteSet, ...caseDraftWriteSet],
             forbiddenPaths: forbidden,
             outputContract: "Write executable Markdown frontend cases, index.md, and manifest.draft.json schemaVersion 1 only; the exclusive shell materializer promotes the validated draft to manifest.json. Do not write manifest.json or test source code.",
             subtask_prompt: [
                 "Use skill playwright-cli-case-generator.",
+                "Read testcase/frontend/rag/standard-scenarios.v1.json and cover priority=must scenarios (or record GAP in coverage-map). Include ## 测试点 and ## 测试步骤 in each case.",
                 "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and the draft case paths testcase/frontend/cases/FE-*.md, testcase/frontend/cases/index.md, and testcase/frontend/cases/manifest.draft.json. Write only those same draft paths. Do not write testcase/frontend/cases/manifest.json.",
                 "Generate Markdown cases, index.md and manifest.draft.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir).",
                 "HARD ID CONTRACT (do not confuse these):",
@@ -4177,7 +4227,7 @@ function buildFrontendTestHybridDag(sources) {
                 "dimensions: core|boundary|flow|backend only.",
                 "Prefer a small smoke suite (default max roughly 4-8 cases unless task frontendTest.maxCasesPerBatch is higher). Never invent unavailable API fields or credentials. Do not create pytest or Playwright source.",
                 "HARD playwright-cli-only: every browser step must use repo skill playwright-cli declared commands only. Forbidden: bare `playwright`, `npx playwright`, `playwright test`, `@playwright/test`, Node Playwright API, or generating Playwright/Pytest source. No fallback when playwright-cli is unavailable - case must instruct blocked evidence playwright-cli-unavailable.",
-                `Use only the controller-frozen baseUrl ${controllerFrontend.baseUrl} from ${controllerFrontend.baseUrlSource}; context.md may reference it but cannot establish or override it. Every browser start command must be exactly: playwright-cli open --browser=chrome --headed ${controllerFrontend.baseUrl}. Never leave a base-url placeholder. Use default browser session only; never write -s=<case-id>.`,
+                `Use only the controller-frozen baseUrl ${controllerFrontend.baseUrl} from ${controllerFrontend.baseUrlSource}; context.md may reference it but cannot establish or override it. Every browser start command must be exactly: playwright-cli open --browser=chrome --headless ${controllerFrontend.baseUrl}. Never leave a base-url placeholder. Use default browser session only; never write -s=<case-id>.`,
                 "HARD dynamic refs: executable playwright-cli lines must never contain an angle-bracket token such as <fresh-ref> or descriptive <...> placeholder. Use only shell-safe documentation placeholders `eX`, `eY`, ...; each means the real `eNN` ref parsed from the immediately preceding latest `snapshot`. Write a fresh snapshot before every element reference. eX/eY are never literal structured-tool arguments; a later snapshot invalidates prior refs, so never reuse stale refs.",
                 "HARD file-output argv: use canonical `--filename` only. Screenshot uses `playwright-cli screenshot --filename final.png` (a real ref may precede the flag); PDF uses `playwright-cli pdf --filename final.pdf`; snapshot without filename is response-only and a snapshot file uses `playwright-cli snapshot --filename snapshot.txt`. Never generate `playwright-cli screenshot <path>`, use `--path`, `--output`, or `--file`, or pass an output path as a positional target.",
                 "Each case must be independently reproducible with fixture/reset, UI reset, snapshot-before-ref, evidence write point under testcase/frontend/evidence/<case-id>/. If the isolated environment is unavailable, require writing blocked evidence before any browser command.",
@@ -4206,6 +4256,7 @@ function buildFrontendTestHybridDag(sources) {
             toolProfile: "write",
             complexity: "HIGH",
             writePolicy: "exclusive",
+            writeGuardPolicy: "tools-only",
             writeSet: caseDraftWriteSet,
             allowedPaths: [...ragWriteSet, ...caseDraftWriteSet],
             forbiddenPaths: forbidden,
@@ -4256,38 +4307,28 @@ function buildFrontendTestHybridDag(sources) {
         ? ["final-frontend-case-review-gate-shell"]
         : ["generate-frontend-functional-cases-pi"];
     tasks.push({
-        id: "frontend-case-checklist-shell",
+        id: "checklist-and-materialize-manifest-shell",
         depends_on: checklistDependsOn,
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
-        writePolicy: "read-only",
+        writePolicy: "exclusive",
+        writeSet: casesWriteSet,
         allowedPaths: [...ragWriteSet, ...casesWriteSet],
         forbiddenPaths: forbidden,
-        outputContract: "Mechanical checklist: manifest/case paths, Case ID, non-production playwright-cli open prefix, AC mapping, and executable command gate; rejects alternative executable instructions and non-allowlisted playwright-cli commands with ruleId-tagged location evidence.",
-        subtask_prompt: "Inspect and reject alternative executable instructions in fenced command code, list/indented steps, and explicit shell/terminal command lines. Only allowlisted playwright-cli command instructions may pass; ordinary prose and explicit blocked reasons may describe prohibitions. Run the native deterministic checklist without spawning Bash, PowerShell, or node -e and do not use free-form LLM verdicts.",
+        outputContract: "Mechanical checklist then atomic manifest.json materialization; stdout one final JSON line {cases}.",
+        subtask_prompt: "Run deterministic checklist then materialize manifest.json from draft after optional blocking review.",
         shell: {
             commands: [],
-            frontendTestCaseChecklist: {},
+            frontendTestCaseManifest: {
+                maxCases: config.maxCasesPerBatch,
+            },
             cwd: ".",
             timeoutMs: 120000,
         },
-    }, {
-        id: "materialize-frontend-case-manifest-shell",
-        depends_on: ["frontend-case-checklist-shell"],
-        role: "verifier",
-        executor: "shell",
-        complexity: "LOW",
-        writePolicy: "exclusive",
-        writeSet: casesWriteSet,
-        allowedPaths: casesWriteSet,
-        forbiddenPaths: forbidden,
-        outputContract: "Validated frontend manifest payload { cases: [...] }; ruleId-tagged fail-closed validation; atomically materialize testcase/frontend/cases/manifest.json via temp+rename then delete draft; stdout is exactly one final JSON line {cases}.",
-        subtask_prompt: "Validate manifest.draft.json and materialize manifest.json after the mechanical checklist (and optional blocking review) passes.",
-        shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
     }, {
         id: "execute-frontend-cases-map",
-        depends_on: ["materialize-frontend-case-manifest-shell"],
+        depends_on: ["checklist-and-materialize-manifest-shell"],
         role: "verifier",
         executor: "static",
         complexity: "LOW",
@@ -4300,7 +4341,7 @@ function buildFrontendTestHybridDag(sources) {
         dynamicExpansion: {
             type: "map_agent",
             workflowNodeId: "execute-frontend-cases-map",
-            itemsFrom: "$.nodes['materialize-frontend-case-manifest-shell'].output.cases",
+            itemsFrom: "$.nodes['checklist-and-materialize-manifest-shell'].output.cases",
             itemName: "case",
             maxItems: config.maxCasesPerBatch,
             maxExpandedNodes: config.maxCasesPerBatch,
@@ -4322,6 +4363,7 @@ function buildFrontendTestHybridDag(sources) {
                 },
                 complexity: "MED",
                 writePolicy: "exclusive",
+                writeGuardPolicy: "tools-only",
                 allowedPaths: [
                     "testcase/frontend/cases/{{case.caseId}}.md",
                     "testcase/frontend/rag/context.md",
@@ -4334,15 +4376,93 @@ function buildFrontendTestHybridDag(sources) {
                 subtaskPromptTemplate: [
                     "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session; do not use /new). playwright-cli-only: never bare Playwright CLI/API/test runner; no fallback.",
                     "Use the structured playwright_cli tool for every browser action. Do not request or search for bash. Do not execute raw shell commands. Translate each playwright-cli line in the case Markdown into one playwright_cli tool call ({command, args?, timeoutSeconds?}).",
-                    `1) The controller-frozen baseUrl is ${controllerFrontend.baseUrl} from ${controllerFrontend.baseUrlSource}; model-authored context/case text cannot establish or override it. 2) Start browser ONLY via playwright_cli command=open with args [--browser=chrome, --headed, ${controllerFrontend.baseUrl}] (default session only; no -s=). 3) Dynamic refs: eX/eY in case Markdown are documentation placeholders, never tool args. Immediately before every structured playwright_cli call that references an element, parse the current real eNN from the immediately preceding latest snapshot and pass only that real eNN; never send literal \`eX\`/\`eY\`. A new snapshot invalidates prior refs, so never reuse stale refs. File outputs are canonical: screenshot args [--filename, final.png] (or [e5, --filename, final.png] for a real target), PDF args [--filename, final.pdf], and snapshot writes a file only with [--filename, snapshot.txt]; snapshot without filename is response-only. Never use --path, --output, --file, or any output path as a positional target. Follow case steps with snapshot before element refs using only playwright_cli. A passed case requires this same child receipt order: successful open → successful find → controller post-execution cleanup. Only successful find is a meaningful assertion; snapshot, goto, screenshot, request/console, click/fill and other ordinary interactions cannot establish passed authority. 4) Only when preflight or playwright_cli tool explicitly fails may you write blocked evidence (blockedReason playwright-cli-unavailable | frontend-base-url-unreachable); never invent CLI-unavailable solely because bash is absent. 5) For U/D: enforce current-user ownership / create-or-mock-or-blocked; never mutate other users' data.`,
+                    `1) The controller-frozen baseUrl is ${controllerFrontend.baseUrl} from ${controllerFrontend.baseUrlSource}; model-authored context/case text cannot establish or override it. 2) Start browser ONLY via playwright_cli command=open with args [--browser=chrome, --headless, ${controllerFrontend.baseUrl}] (default session only; no -s=). 3) Dynamic refs: eX/eY in case Markdown are documentation placeholders, never tool args. Immediately before every structured playwright_cli call that references an element, parse the current real eNN from the immediately preceding latest snapshot and pass only that real eNN; never send literal \`eX\`/\`eY\`. A new snapshot invalidates prior refs, so never reuse stale refs. File outputs are canonical: screenshot args [--filename, final.png] (or [e5, --filename, final.png] for a real target), PDF args [--filename, final.pdf], and snapshot writes a file only with [--filename, snapshot.txt]; snapshot without filename is response-only. Never use --path, --output, --file, or any output path as a positional target. Follow case steps with snapshot before element refs using only playwright_cli. A passed case requires this same child receipt order: successful open → successful find → controller post-execution cleanup. Only successful find is a meaningful assertion; snapshot, goto, screenshot, request/console, click/fill and other ordinary interactions cannot establish passed authority. 4) Only when preflight or playwright_cli tool explicitly fails may you write blocked evidence (blockedReason playwright-cli-unavailable | frontend-base-url-unreachable); never invent CLI-unavailable solely because bash is absent. 5) For U/D: enforce current-user ownership / create-or-mock-or-blocked; never mutate other users' data.`,
                     "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json with caseId={{case.caseId}}, status passed|failed|blocked, evidencePaths (relative under evidenceDir). blocked needs non-empty blockedReason. After writing, self-check the same contract; if self-check fails, rewrite both files as status=blocked blockedReason=invalid-evidence-shape (never leave missing/malformed evidence).",
                     "Business failed/blocked is a recorded result, not a node failure. Close browser via playwright_cli command=close. Return compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
                 ].join("\n\n"),
             },
         },
-    }, {
-        id: "validate-frontend-case-evidence-shell",
-        depends_on: ["execute-frontend-cases-map"],
+    });
+    if (maxRerunAttempts > 0) {
+        tasks.push({
+            id: "select-frontend-rerun-candidates-shell",
+            depends_on: ["execute-frontend-cases-map"],
+            role: "verifier",
+            executor: "shell",
+            complexity: "LOW",
+            writePolicy: "exclusive",
+            writeSet: ["testcase/frontend/evidence/**"],
+            allowedPaths: [...casesWriteSet, "testcase/frontend/evidence/**"],
+            forbiddenPaths: forbidden,
+            outputContract: "Stdout JSON {cases} for blocked or missing-result-file cases with rerunAttempt < maxRerunAttempts.",
+            subtask_prompt: "Select frontend-test cases eligible for bounded rerun.",
+            shell: {
+                commands: [
+                    ["node -e", JSON.stringify("const fs=require('fs'),path=require('path');const manifestPath='testcase/frontend/cases/manifest.json';if(!fs.existsSync(manifestPath)){process.stdout.write(JSON.stringify({cases:[]}));process.exit(0);}const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));const cases=[];for(const c of (manifest.cases||[])){const evidenceDir=(c.evidenceDir||('testcase/frontend/evidence/'+c.caseId+'/')).replace(/\\/+$/,'')+'/';const resultPath=path.join(evidenceDir,'case-result.json');const execPath=path.join(evidenceDir,'execution.md');let reason=null;let attempt=0;let missing=false;if(!fs.existsSync(resultPath)){missing=true;reason='missing-result-files';}else{try{const r=JSON.parse(fs.readFileSync(resultPath,'utf8'));attempt=Number(r.rerunAttempt||0)||0;if(r.status==='blocked')reason='blocked';if(!r.status){missing=true;reason='missing-result-files';}}catch(e){missing=true;reason='missing-result-files';}}if(!fs.existsSync(execPath)&&reason!=='blocked'){missing=true;reason=reason||'missing-result-files';}const should=(reason==='blocked'||missing)&&attempt<" + maxRerunAttempts + ";if(should){cases.push({caseId:c.caseId,casePath:c.casePath||('testcase/frontend/cases/'+c.caseId+'.md'),evidenceDir,dimension:c.dimension||'core',acIds:c.acIds||[],rerunAttempt:attempt+1,reason:reason||'blocked'});}}fs.mkdirSync('testcase/frontend/evidence',{recursive:true});fs.writeFileSync('testcase/frontend/evidence/rerun-candidates.json',JSON.stringify({schemaVersion:1,cases},null,2)+'\\n');process.stdout.write(JSON.stringify({cases}));")].join(" "),
+                ],
+                cwd: ".",
+                timeoutMs: 120_000,
+            },
+        }, {
+            id: "rerun-frontend-cases-map",
+            depends_on: ["select-frontend-rerun-candidates-shell"],
+            role: "verifier",
+            executor: "static",
+            complexity: "LOW",
+            writePolicy: "none",
+            allowedPaths: [],
+            forbiddenPaths: forbidden,
+            outputContract: "Serial rerun of blocked/missing-result frontend cases.",
+            subtask_prompt: "Expand rerun candidates into serial browser case children.",
+            static: { resultMarkdown: "Frontend case rerun map expansion barrier." },
+            dynamicExpansion: {
+                type: "map_agent",
+                workflowNodeId: "rerun-frontend-cases-map",
+                itemsFrom: "$.nodes['select-frontend-rerun-candidates-shell'].output.cases",
+                itemName: "case",
+                maxItems: config.maxCasesPerBatch,
+                maxExpandedNodes: config.maxCasesPerBatch,
+                childIdPrefix: "rerun-frontend-case",
+                workspaceTemplate: "{{case.evidenceDir}}",
+                tolerateChildFailures: true,
+                tokenBudget: {
+                    maxTokensPerCase: config.maxTokensPerCase,
+                    maxTotalTokens: config.maxTotalTokens,
+                },
+                childTask: {
+                    executor: "pi",
+                    role: "implementer",
+                    skills: ["playwright-cli"],
+                    toolProfile: "write",
+                    commandPolicy: {
+                        mode: "capability-allowlist",
+                        capabilities: ["playwright-cli"],
+                    },
+                    complexity: "MED",
+                    writePolicy: "exclusive",
+                    writeGuardPolicy: "tools-only",
+                    allowedPaths: [
+                        "testcase/frontend/cases/{{case.caseId}}.md",
+                        "testcase/frontend/rag/context.md",
+                        "testcase/frontend/rag/coverage-map.md",
+                        `${evidenceRoot}/{{case.caseId}}/**`,
+                    ],
+                    forbiddenPaths: forbidden,
+                    writeSet: [`${evidenceRoot}/{{case.caseId}}/**`],
+                    outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, tokens, and rerunAttempt.",
+                    subtaskPromptTemplate: [
+                        "RERUN attempt {{case.rerunAttempt}} for {{case.caseId}} (reason={{case.reason}}). Rewrite authoritative evidence; set rerunAttempt={{case.rerunAttempt}}.",
+                        "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session). Use structured playwright_cli only; headless open.",
+                        `Start via playwright_cli command=open with args [--browser=chrome, --headless, ${controllerFrontend.baseUrl}]. Passed requires open → find → cleanup receipts.`,
+                        "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json with caseId, status, evidencePaths, rerunAttempt={{case.rerunAttempt}}.",
+                    ].join("\n\n"),
+                },
+            },
+        });
+    }
+    tasks.push({
+        id: "finalize-frontend-test-result-shell",
+        depends_on: [maxRerunAttempts > 0 ? "rerun-frontend-cases-map" : "execute-frontend-cases-map"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
@@ -4350,40 +4470,18 @@ function buildFrontendTestHybridDag(sources) {
         writeSet: [`${evidenceRoot}/**`],
         allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
         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.",
+        outputContract: "Evidence validation (advisory missing/malformed does not fail the node; hard-fail only path escape) then hash-bound frontend-test-result-v1. Node success means result-v1 was written, not that all cases passed.",
+        subtask_prompt: "Validate case evidence then materialize authoritative frontend-test-result-v1. Missing/malformed case evidence is advisory; only unsafe evidence paths hard-fail. Do not use Pi prose as input.",
         shell: {
             commands: [],
-            frontendTestEvidenceValidation: {},
-            cwd: ".",
-            timeoutMs: 120000,
-        },
-    }, {
-        id: "materialize-frontend-test-result-shell",
-        depends_on: ["validate-frontend-case-evidence-shell"],
-        role: "verifier",
-        executor: "shell",
-        complexity: "LOW",
-        writePolicy: "read-only",
-        allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
-        forbiddenPaths: forbidden,
-        outputContract: "Run-owned hash-bound frontend-test-result-v1 derived only from the manifest and validated case evidence.",
-        subtask_prompt: "Materialize the authoritative frontend-test-result-v1. Do not use Pi prose or retrospective output as input.",
-        shell: {
-            commands: [],
-            jsonArtifactGate: {
-                fromNodeId: "validate-frontend-case-evidence-shell",
-                schemaId: "frontend-test-result-v1",
-                artifactName: "frontend-test-result.json",
-                outputDir: "contracts",
-            },
+            frontendTestResultFinalize: {},
             cwd: ".",
             timeoutMs: 120000,
         },
     });
     tasks.push({
-        id: "frontend-test-l5-report-shell",
-        depends_on: ["materialize-frontend-test-result-shell"],
+        id: "frontend-test-reports-shell",
+        depends_on: ["finalize-frontend-test-result-shell"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
@@ -4391,11 +4489,11 @@ function buildFrontendTestHybridDag(sources) {
         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.",
+        outputContract: "Deterministic L-5 (optional) plus main frontend-test-report.md/html from frontend-test-result-v1. Pipeline acceptance = result-v1 + main HTML.",
+        subtask_prompt: "Render operational reports from frontend-test-result-v1 only. Do not invent coverage. Main HTML is required; L-5 follows frontendTest.reports.l5.",
         shell: {
-            frontendTestL5Report: {},
             commands: [],
+            frontendTestReports: { l5: enableL5Report },
             cwd: ".",
             timeoutMs: 120000,
         },
@@ -4404,8 +4502,8 @@ function buildFrontendTestHybridDag(sources) {
         tasks.push({
             id: "frontend-test-result-outcome-gate-shell",
             depends_on: [
-                "materialize-frontend-test-result-shell",
-                "frontend-test-l5-report-shell",
+                "finalize-frontend-test-result-shell",
+                "frontend-test-reports-shell",
             ],
             role: "verifier",
             executor: "shell",
@@ -4413,8 +4511,8 @@ function buildFrontendTestHybridDag(sources) {
             writePolicy: "read-only",
             allowedPaths: [],
             forbiddenPaths: forbidden,
-            outputContract: "Optional quality gate: pass only when frontend-test-result-v1 is outcome=passed and integrationMode=real with 0 failed/blocked and no missing AC. Does not gate retrospective closeout.",
-            subtask_prompt: "Opt-in Delivery/Worker quality gate (frontendTest.strictOutcomeGate=true). Retrospective does not depend on this node.",
+            outputContract: "Optional quality gate: pass only when frontend-test-result-v1 is outcome=passed and integrationMode=real with 0 failed/blocked and no missing AC. Does not gate reports closeout.",
+            subtask_prompt: "Opt-in Delivery/Worker quality gate (frontendTest.strictOutcomeGate=true). Main reports do not depend on this node.",
             shell: {
                 commands: [frontendTestOutcomeGate],
                 cwd: ".",
@@ -4422,49 +4520,30 @@ function buildFrontendTestHybridDag(sources) {
             },
         });
     }
-    tasks.push({
-        id: "frontend-test-retrospect-pi",
-        depends_on: [
-            "materialize-frontend-test-result-shell",
-            "frontend-test-l5-report-shell",
-        ],
-        role: "closeout",
-        executor: "pi",
-        toolProfile: "write",
-        complexity: "MED",
-        writePolicy: "exclusive",
-        writeSet: ["testcase/frontend/reports/**"],
-        allowedPaths: ["testcase/frontend/**"],
-        forbiddenPaths: forbidden,
-        outputContract: "Write frontend-test retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, execution evidence review, risks, findings, and A/B/C/D rating — even when outcome is failed/incomplete. Pipeline acceptance = this report exists (not case 100% pass).",
-        subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/ after result materialization 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-html-report-shell",
-        depends_on: ["frontend-test-retrospect-pi"],
-        role: "verifier",
-        executor: "shell",
-        complexity: "LOW",
-        writePolicy: "exclusive",
-        writeSet: ["testcase/frontend/reports/**"],
-        allowedPaths: ["testcase/frontend/**"],
-        forbiddenPaths: forbidden,
-        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,
-        },
-    });
+    if (enableRetrospect) {
+        tasks.push({
+            id: "frontend-test-retrospect-pi",
+            depends_on: ["finalize-frontend-test-result-shell", "frontend-test-reports-shell"],
+            role: "closeout",
+            executor: "pi",
+            toolProfile: "write",
+            complexity: "MED",
+            writePolicy: "exclusive",
+            writeGuardPolicy: "tools-only",
+            writeSet: ["testcase/frontend/reports/**"],
+            allowedPaths: ["testcase/frontend/**"],
+            forbiddenPaths: forbidden,
+            outputContract: "Optional retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md. Not required for pipeline acceptance.",
+            subtask_prompt: "Write optional frontend-test retrospective after result + reports. Do not recompute L-5. Pipeline success does not require this file.",
+        });
+    }
     const globalConstraints = [
         ...sources.taskConfig.hardConstraints,
         ...STANDARD_GLOBAL_CONSTRAINTS,
         "frontend-test-dag generates Markdown cases and browser evidence only; it must not generate pytest or Playwright test source code.",
         "Each browser case runs serially in a fresh Pi execution boundary. Persist its evidence before starting the next case.",
         "Use only the declared isolated test environment. Production URLs, real credentials, and unauthorized data are blocked.",
-        `Browser startup for generated cases must be playwright-cli open --browser=chrome --headed ${controllerFrontend.baseUrl}; this origin is frozen by the controller from ${controllerFrontend.baseUrlSource}, and model-authored files cannot establish or override it; generated operations stay in the default browser session and must not use unverified named-session flags.`,
+        `Browser startup for generated cases must be playwright-cli open --browser=chrome --headless ${controllerFrontend.baseUrl}; this origin is frozen by the controller from ${controllerFrontend.baseUrlSource}, and model-authored files cannot establish or override it; generated operations stay in the default browser session and must not use unverified named-session flags.`,
         "Browser-tool preflight runs before any frontend-test Pi node; cli-only rollback, missing/incompatible Pi SDK custom-tool capability, missing verified playwright-cli launcher, or incompatible --help fails with zero Pi calls.",
         "Browser case children use commandPolicy capability-allowlist playwright-cli and structured playwright_cli tool; ordinary writers remain without Bash.",
         "Passed cases require same-child ordered controller receipts: successful open → successful find → successful post-execution cleanup. Pre-start cleanup, snapshot/goto/screenshot/request/console and ordinary interactions are insufficient; missing or unordered receipts convert to blocked (browser-command-evidence-missing).",
@@ -4472,7 +4551,7 @@ function buildFrontendTestHybridDag(sources) {
         "Environment preflight must curl-probe the frozen non-production baseUrl before generate; unreachable or curl-unavailable ends preflight as blocked (frontend-base-url-unreachable|curl-unavailable) so generate/map do not run.",
         "U/D cases must prove current-user data ownership or create cleanable current-user data or authorized Mock; otherwise blocked (current-user-data-unavailable|data-ownership-unverifiable|safe-test-data-setup-unavailable) without cross-user mutation.",
         "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
-        "Pipeline acceptance for frontend-test is the final retrospect report under testcase/frontend/reports/; case pass rate and outcome=passed are quality signals, not the default pipeline success condition.",
+        "Pipeline acceptance for frontend-test is frontend-test-result-v1 plus the main report under testcase/frontend/reports/frontend-test-report.html; case pass rate and outcome=passed are quality signals; retrospect is opt-in (frontendTest.reports.retrospect).",
         blockingReview
             ? "frontendTest.reviewMode=blocking: a frontend case review must emit VERDICT: pass before checklist/manifest materialization; request-revision blocks browser execution."
             : "frontendTest.reviewMode is off|advisory by default: mechanical checklist-shell gates materialize/execute; LLM review is not a hard browser gate.",