@tea-agent/loop-agent 0.29.0 → 0.29.2

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

@@ -3977,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 === "**");
@@ -4013,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-]*$/;",
         ,
@@ -4026,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 {",
@@ -4125,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,
@@ -4140,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"),
         },
@@ -4175,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):",
@@ -4191,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.",
@@ -4220,6 +4256,7 @@ function buildFrontendTestHybridDag(sources) {
             toolProfile: "write",
             complexity: "HIGH",
             writePolicy: "exclusive",
+            writeGuardPolicy: "tools-only",
             writeSet: caseDraftWriteSet,
             allowedPaths: [...ragWriteSet, ...caseDraftWriteSet],
             forbiddenPaths: forbidden,
@@ -4270,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",
@@ -4314,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,
@@ -4336,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",
@@ -4348,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",
@@ -4364,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.",
-        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.",
+        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: [],
-            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",
@@ -4405,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,
         },
@@ -4418,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",
@@ -4427,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: ".",
@@ -4436,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).",
@@ -4486,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.",

package/dist/workflows/dag/node-execution.js

@@ -8,6 +8,7 @@ import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry, } from "./backend-test-writer-completeness.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isWriterEmptyDiffRetryCandidate, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
@@ -125,7 +126,7 @@ export function buildNodePrompt(spec, task, upstream, options) {
         convergenceFeedback: options?.convergenceFeedback,
     });
 }
-function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason) {
+function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths) {
     if (attemptNumber <= 1)
         return basePrompt;
     if (previousFailureCategory === "protocol-invalid" &&
@@ -138,6 +139,22 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
         ].join("\n");
     }
     if (previousFailureCategory === "writer-empty-diff") {
+        const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
+        // When a completeness progress exists for this writer, fold the concrete
+        // target paths into the empty-diff retry so the model does not guess and
+        // does not need to read a forbidden `.harness/**` evidence file.
+        if (recoveryTargetPaths && recoveryTargetPaths.length > 0) {
+            return [
+                basePrompt,
+                "",
+                buildOutputLimitRecoverySection({
+                    attempt: attemptNumber,
+                    maxAttempts,
+                    reason: "T4",
+                    targetPaths: recoveryTargetPaths,
+                }),
+            ].join("\n");
+        }
         return [
             basePrompt,
             "",
@@ -150,6 +167,22 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
     }
     if (previousFailureCategory === "incomplete-write-set") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
+        // Embed concrete missing/broken paths from the run-owned progress facts
+        // so the continuation attempt is fully self-contained and never reads
+        // a forbidden `.harness/**` evidence file. When the loader finds no
+        // progress facts yet (rare), fall back to the path-pointing contract.
+        if (recoveryTargetPaths) {
+            return [
+                basePrompt,
+                "",
+                buildOutputLimitRecoverySection({
+                    attempt: attemptNumber,
+                    maxAttempts,
+                    reason: "T3_or_T5",
+                    targetPaths: recoveryTargetPaths,
+                }),
+            ].join("\n");
+        }
         return [
             basePrompt,
             "",
@@ -597,12 +630,18 @@ export async function executeDagNode(input) {
                 tasksById,
                 state,
             });
+            // For backend-test generation writers, load the most recent
+            // completeness progress from the run dir so the next attempt's
+            // prompt embeds concrete target paths. Undefined for non-writers
+            // or when no progress facts exist yet (no-op).
+            const recoveryProgress = await loadBackendTestWriterProgressForRetry(runDir, task.id);
+            const recoveryTargetPaths = recoveryProgress?.targetPaths;
             result = await executeNode({
                 task,
                 cwd,
                 model,
                 ...(thinking ? { thinking } : {}),
-                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason),
+                prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths),
                 attempt: attemptNumber,
                 reportActivity,
                 timeoutMs: livenessPolicy.absoluteMaxWallClockMs,

package/dist/workflows/dag/types.js

@@ -324,6 +324,8 @@ export const dagWritePolicySchema = z.enum([
     "exclusive",
     "none",
 ]);
+/** Git/post-diff write guard intensity for exclusive Pi writers. */
+export const dagWriteGuardPolicySchema = z.enum(["full", "tools-only"]);
 export const contextPolicyIdSchema = z.enum([
     "baseline-v1",
     "role-specialized-v1",
@@ -367,6 +369,38 @@ export const dagFrontendBrowserToolPreflightSchema = z.object({}).strict();
 export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
 export const dagFrontendTestCaseChecklistSchema = z.object({}).strict();
 export const dagFrontendTestHtmlReportSchema = z.object({}).strict();
+/**
+ * Combined checklist + manifest materialization gate (lean frontend-test DAG).
+ * Runs the mechanical frontend case checklist first, then atomically
+ * materializes testcase/frontend/cases/manifest.json from manifest.draft.json.
+ * Stdout is exactly one final JSON line {cases}.
+ */
+export const dagFrontendTestCaseManifestSchema = z
+    .object({
+    maxCases: z.number().int().min(1).optional(),
+    declaredAcIds: z.array(z.string()).optional(),
+})
+    .strict();
+/**
+ * Combined evidence validation + result materialization gate (lean frontend-test DAG).
+ * Runs deterministic evidence validation first (advisory on missing/malformed,
+ * hard-fail on path escape), then materializes frontend-test-result-v1.
+ */
+export const dagFrontendTestResultFinalizeSchema = z
+    .object({
+    declaredAcIds: z.array(z.string()).optional(),
+})
+    .strict();
+/**
+ * Combined reports gate (lean frontend-test DAG). Renders the deterministic
+ * frontend L-5 dashboard (when l5 is true, the default) and then the main
+ * frontend-test Markdown + self-contained HTML report from frontend-test-result-v1.
+ */
+export const dagFrontendTestReportsSchema = z
+    .object({
+    l5: z.boolean().optional(),
+})
+    .strict();
 export const dagFinalWriteSetApprovalGateSchema = z
     .object({
     writerNodeId: z
@@ -426,6 +460,9 @@ export const dagShellConfigSchema = z.object({
     finalWriteSetApprovalGate: dagFinalWriteSetApprovalGateSchema.optional(),
     frontendTestL5Report: z.object({}).strict().optional(),
     frontendTestHtmlReport: dagFrontendTestHtmlReportSchema.optional(),
+    frontendTestCaseManifest: dagFrontendTestCaseManifestSchema.optional(),
+    frontendTestResultFinalize: dagFrontendTestResultFinalizeSchema.optional(),
+    frontendTestReports: dagFrontendTestReportsSchema.optional(),
     backendTestPipeline: dagBackendTestPipelineSchema.optional(),
     /** JaCoCo coverage collection for backend-test (Java services). When set, node 7 dumps coverage over TCP from a JaCoCo tcpserver agent and feeds it to the L-5 dashboard. */
     jacocoCoverage: z
@@ -475,6 +512,7 @@ export const dagDynamicExpansionChildTaskSchema = z.object({
     allowedPaths: z.array(z.string()).optional().default([]),
     forbiddenPaths: z.array(z.string()).optional().default([]),
     writeSet: z.array(z.string()).optional(),
+    writeGuardPolicy: dagWriteGuardPolicySchema.optional(),
 });
 export const dagDynamicExpansionSchema = z.object({
     type: z.enum(["map_agent", "verify_agent"]),
@@ -657,6 +695,8 @@ export const dagTaskSchema = z.object({
      * run-attributed diff.
      */
     writerOutcomePolicy: dagWriterOutcomePolicySchema.optional(),
+    /** full (default): git baseline + post-diff write-guard. tools-only: keep tool sandbox, skip git baseline/post-diff hard fail (frontend-test). */
+    writeGuardPolicy: dagWriteGuardPolicySchema.optional(),
     /** Required for supervised writers that consume a final audited writeSet. */
     finalWriteSetApproval: dagFinalWriteSetApprovalBindingSchema.optional(),
     /** Runtime-only authorization facts injected after final approval validation. */

package/dist/workflows/dag/validate.js

@@ -468,7 +468,10 @@ function validateShellTaskConfig(task, spec, issues) {
         !shell.frontendTestCaseChecklist &&
         !shell.frontendTestEvidenceValidation &&
         !shell.frontendTestL5Report &&
-        !shell.frontendTestHtmlReport) {
+        !shell.frontendTestHtmlReport &&
+        !shell.frontendTestCaseManifest &&
+        !shell.frontendTestResultFinalize &&
+        !shell.frontendTestReports) {
         issues.push({
             type: "missing-shell-commands",
             message: `shell task ${task.id} requires a supported shell operation or non-empty shell.commands`,