@tea-agent/loop-agent 0.29.0 → 0.29.1

package/docs/templates/frontend-test-dag.json

@@ -7,14 +7,14 @@
     "agentRuntime": "pi-only",
     "repairWriterProtocol": "explicit-node-v1"
   },
-  "objective": "Build a frontend test RAG package, generate Markdown cases, mechanically checklist them (LLM review optional), execute each case serially through playwright-cli, materialize frontend-test-result-v1, and write retrospect report (pipeline acceptance).",
+  "objective": "Build frontend test RAG package, generate Markdown cases, checklist+manifest, execute serially via playwright-cli, finalize frontend-test-result-v1, and write main HTML report (pipeline acceptance).",
   "globalConstraints": [
     "Do not generate pytest or Playwright source code.",
     "Only use declared isolated test environments; production URLs and real credentials are blocked.",
-    "Every generated browser start command uses playwright-cli open --browser=chrome --headed followed by the concrete controller-resolved URL (from task source config.md when present, else http://localhost:5173); executable case lines never retain an angle-bracket URL/ref placeholder; subsequent commands stay in that default session and must not use unverified named-session flags.",
+    "Every generated browser start command uses playwright-cli open --browser=chrome --headless followed by the concrete controller-resolved URL (from task source config.md when present, else http://localhost:5173); executable case lines never retain an angle-bracket URL/ref placeholder; subsequent commands stay in that default session and must not use unverified named-session flags.",
     "Case children execute serially. Persist each case result, logs and browser evidence before the next child starts.",
     "A token threshold is a post-case stop check, not a model hard token cap; unstarted cases must be recorded as blocked: token-budget-exhausted.",
-    "Default pipeline acceptance is the final retrospect report under testcase/frontend/reports/; case full green is optional quality (frontendTest.strictOutcomeGate).",
+    "Default pipeline acceptance is the final frontend-test-result-v1 plus testcase/frontend/reports/frontend-test-report.html",
     "Default frontendTest.reviewMode=off uses mechanical checklist-shell before materialize; set reviewMode=blocking for legacy dual LLM review gate.",
     "playwright-cli-only: generators and executors may call only skill-declared playwright-cli commands; bare playwright / npx playwright / @playwright/test / Playwright source are forbidden with no native Playwright fallback.",
     "Browser-tool preflight (preflight-frontend-browser-tool-shell) must reject CODE_AGENT_PI_BACKEND=cli-only, verify the Pi SDK structured custom-tool surface, freeze baseUrl from hash-bound task source config.md (or controller default localhost), and confirm the verified playwright-cli launcher + --help contract before any frontend-test Pi node; missing capability/CLI fails with zero Pi calls.",
@@ -47,34 +47,10 @@
       }
     },
     {
-      "id": "retrieve-frontend-test-context-pi",
+      "id": "prepare-frontend-test-package-shell",
       "depends_on": [
         "preflight-frontend-browser-tool-shell"
       ],
-      "executor": "pi",
-      "role": "planner",
-      "toolProfile": "write",
-      "complexity": "MED",
-      "writePolicy": "exclusive",
-      "writeSet": [
-        "testcase/frontend/rag/**"
-      ],
-      "allowedPaths": [
-        "REPLACE/WITH/SOURCE/PATH/**",
-        "testcase/frontend/rag/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "RAG context.md and coverage-map.md with baseUrl, baseUrlSource, environmentProbe=pending.",
-      "subtask_prompt_markdown": "./frontend-test-dag.retrieve-context.prompt.md"
-    },
-    {
-      "id": "materialize-frontend-test-execution-shell",
-      "depends_on": [
-        "retrieve-frontend-test-context-pi"
-      ],
       "executor": "shell",
       "role": "verifier",
       "complexity": "LOW",
@@ -89,101 +65,75 @@
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
-      "subtask_prompt": "Parse frozen baseUrl from context.md (config.md preferred, else http://localhost:5173). Reject production / non-http(s). Probe with curl (HEAD then GET fallback; connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Runtime hybrid generator embeds the authoritative probe script.",
+      "outputContract": "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
+      "subtask_prompt": "Materialize frontend-test standard scenarios v1 into the RAG package.",
       "shell": {
         "commands": [
-          "node -e \"console.log('template placeholder: runtime hybrid DAG embeds curl preflight; do not use this static command as source of truth')\""
+          "node -e \"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}));}"
         ],
         "cwd": ".",
         "timeoutMs": 60000
       }
     },
     {
-      "id": "generate-frontend-functional-cases-pi",
+      "id": "retrieve-frontend-test-context-pi",
       "depends_on": [
-        "materialize-frontend-test-execution-shell"
+        "prepare-frontend-test-package-shell"
       ],
       "executor": "pi",
-      "role": "implementer",
+      "role": "planner",
       "toolProfile": "write",
-      "complexity": "HIGH",
+      "complexity": "MED",
       "writePolicy": "exclusive",
       "writeSet": [
-        "testcase/frontend/cases/FE-*.md",
-        "testcase/frontend/cases/index.md",
-        "testcase/frontend/cases/manifest.draft.json"
-      ],
-      "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "Markdown cases, index.md and manifest.draft.json schemaVersion 1 only; the exclusive materializer promotes the validated draft to manifest.json, and this generator must not write manifest.json; no test source code.",
-      "subtask_prompt_markdown": "./frontend-test-dag.generate-cases.prompt.md"
-    },
-    {
-      "id": "review-frontend-cases-pi",
-      "depends_on": [
-        "generate-frontend-functional-cases-pi"
+        "testcase/frontend/rag/**"
       ],
-      "executor": "pi",
-      "role": "reviewer",
-      "complexity": "HIGH",
-      "writePolicy": "read-only",
       "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
+        "REPLACE/WITH/SOURCE/PATH/**",
+        "testcase/frontend/rag/**"
       ],
       "forbiddenPaths": [
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "First line VERDICT: pass or VERDICT: request-revision; request-revision blocks manifest materialization; no writes.",
-      "subtask_prompt_markdown": "./frontend-test-dag.review-cases.prompt.md"
+      "outputContract": "RAG context.md and coverage-map.md with baseUrl, baseUrlSource, environmentProbe=pending.",
+      "subtask_prompt_markdown": "./frontend-test-dag.retrieve-context.prompt.md",
+      "writeGuardPolicy": "tools-only"
     },
     {
-      "id": "review-frontend-cases-gate-shell",
+      "id": "materialize-frontend-test-execution-shell",
       "depends_on": [
-        "review-frontend-cases-pi"
+        "retrieve-frontend-test-context-pi"
       ],
       "executor": "shell",
       "role": "verifier",
       "complexity": "LOW",
-      "writePolicy": "read-only",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/rag/**"
+      ],
       "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
+        "testcase/frontend/rag/**"
       ],
       "forbiddenPaths": [
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Deterministic gate: block manifest materialization and browser execution unless review-frontend-cases-pi emits VERDICT: pass.",
-      "subtask_prompt": "Enforce the frontend case review verdict before manifest materialization.",
+      "outputContract": "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
+      "subtask_prompt": "Parse frozen baseUrl from context.md (config.md preferred, else http://localhost:5173). Reject production / non-http(s). Probe with curl (HEAD then GET fallback; connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Runtime hybrid generator embeds the authoritative probe script.",
       "shell": {
-        "commands": [],
-        "verdictGate": {
-          "fromNodeId": "review-frontend-cases-pi",
-          "accept": [
-            "VERDICT: pass"
-          ],
-          "label": "frontend case review",
-          "lineMode": "first-verdict-line"
-        },
+        "commands": [
+          "node -e \"console.log('template placeholder: runtime hybrid DAG embeds curl preflight; do not use this static command as source of truth')\""
+        ],
         "cwd": ".",
         "timeoutMs": 60000
       }
     },
     {
-      "id": "revise-frontend-cases-pi",
+      "id": "generate-frontend-functional-cases-pi",
       "depends_on": [
-        "review-frontend-cases-pi"
+        "materialize-frontend-test-execution-shell"
       ],
-      "runIf": "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
       "executor": "pi",
       "role": "implementer",
       "toolProfile": "write",
@@ -202,119 +152,35 @@
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Apply the one permitted frontend case revision to FE-*.md, index.md, and manifest.draft.json only; must not write manifest.json; no browser execution or evidence writes.",
-      "subtask_prompt": "Apply the sole allowed case revision from the first review. Change only testcase/frontend/cases/FE-*.md, testcase/frontend/cases/index.md, and testcase/frontend/cases/manifest.draft.json; preserve AC traceability. Do not write manifest.json, execute browsers, or write evidence."
-    },
-    {
-      "id": "review-frontend-cases-final-pi",
-      "depends_on": [
-        "revise-frontend-cases-pi"
-      ],
-      "runIf": "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
-      "executor": "pi",
-      "role": "reviewer",
-      "complexity": "HIGH",
-      "writePolicy": "read-only",
-      "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "First line VERDICT: pass or VERDICT: request-revision after the single allowed revision; no writes.",
-      "subtask_prompt_markdown": "./frontend-test-dag.review-cases.prompt.md"
+      "outputContract": "Markdown cases, index.md and manifest.draft.json schemaVersion 1 only; the exclusive materializer promotes the validated draft to manifest.json, and this generator must not write manifest.json; no test source code.",
+      "subtask_prompt_markdown": "./frontend-test-dag.generate-cases.prompt.md",
+      "writeGuardPolicy": "tools-only"
     },
     {
-      "id": "final-frontend-case-review-gate-shell",
+      "id": "checklist-and-materialize-manifest-shell",
       "depends_on": [
-        "review-frontend-cases-pi",
-        "review-frontend-cases-final-pi"
+        "generate-frontend-functional-cases-pi"
       ],
-      "executor": "shell",
       "role": "verifier",
-      "complexity": "LOW",
-      "writePolicy": "read-only",
-      "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "Pass-only effective case review gate; final review takes precedence when revision ran.",
-      "subtask_prompt": "Enforce the frontend case review verdict before manifest materialization.",
-      "shell": {
-        "commands": [],
-        "verdictGate": {
-          "fromNodeId": "review-frontend-cases-final-pi",
-          "fallbackFromNodeIds": [
-            "review-frontend-cases-pi"
-          ],
-          "accept": [
-            "VERDICT: pass"
-          ],
-          "label": "effective frontend case review",
-          "lineMode": "first-verdict-line"
-        },
-        "cwd": ".",
-        "timeoutMs": 60000
-      },
-      "dependsPolicy": "all-or-condition-skip"
-    },
-    {
-      "id": "frontend-case-checklist-shell",
-      "depends_on": [
-        "final-frontend-case-review-gate-shell"
-      ],
       "executor": "shell",
-      "role": "verifier",
-      "complexity": "LOW",
-      "writePolicy": "read-only",
-      "allowedPaths": [
-        "testcase/frontend/rag/**",
-        "testcase/frontend/cases/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "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 frontend case checklist without spawning Bash, PowerShell, or node -e.",
-      "shell": {
-        "commands": [],
-        "frontendTestCaseChecklist": {},
-        "cwd": ".",
-        "timeoutMs": 120000
-      }
-    },
-    {
-      "id": "materialize-frontend-case-manifest-shell",
-      "depends_on": [
-        "frontend-case-checklist-shell"
-      ],
-      "executor": "shell",
-      "role": "verifier",
       "complexity": "LOW",
       "writePolicy": "exclusive",
       "writeSet": [
         "testcase/frontend/cases/**"
       ],
       "allowedPaths": [
+        "testcase/frontend/rag/**",
         "testcase/frontend/cases/**"
       ],
       "forbiddenPaths": [
         ".harness/**",
-        "artifacts/**"
+        "src/**"
       ],
-      "outputContract": "Validated frontend manifest payload { cases: [...] }; ruleId-tagged fail-closed validation of manifest.draft.json; the exclusive materializer atomically writes testcase/frontend/cases/manifest.json via temp+rename then deletes draft; stdout is exactly one final JSON line {cases}.",
-      "subtask_prompt": "Read and validate only manifest.draft.json after the mechanical checklist passes. Normalize its case payload, atomically materialize manifest.json, then delete the draft. Do not consume a generator-authored manifest.json.",
+      "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.",
       "shell": {
-        "commands": [
-          "node -e \"const fs=require('fs'),path=require('path');function fail(ruleId,detail){throw new Error('frontend-test manifest blocked: '+ruleId+(detail?': '+detail:''));}const draft='testcase/frontend/cases/manifest.draft.json',file='testcase/frontend/cases/manifest.json',tmp=file+'.tmp';if(!fs.existsSync(draft))fail('draft-missing','missing '+draft);let manifest;try{manifest=JSON.parse(fs.readFileSync(draft,'utf8'));}catch(error){fail('draft-invalid-json',error.message);}if(manifest.schemaVersion!==1)fail('draft-schema','schemaVersion must be 1');if(!Array.isArray(manifest.cases)||!manifest.cases.length)fail('draft-empty-cases','cases must be a non-empty array');const dims=new Set(['core','boundary','flow','backend']),ids=new Set(),paths=new Set(),evidence=new Set();const cases=manifest.cases.map(c=>{if(!c||typeof c.caseId!=='string'||!/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/.test(c.caseId)||ids.has(c.caseId))fail('case-id-shape','invalid or duplicate caseId');ids.add(c.caseId);if(!dims.has(c.dimension))fail('invalid-dimension',String(c.dimension));if(!Array.isArray(c.acIds)||!c.acIds.length||c.acIds.some(a=>typeof a!=='string'||!a.trim()))fail('ac-mapping','invalid acIds');const casePath='testcase/frontend/cases/'+c.caseId+'.md',evidenceDir='testcase/frontend/evidence/'+c.caseId+'/';if(path.isAbsolute(casePath)||casePath.includes('..')||!fs.existsSync(casePath))fail('case-file-missing',casePath);if(paths.has(casePath))fail('duplicate-case-path',casePath);paths.add(casePath);if(evidence.has(evidenceDir))fail('duplicate-evidence-dir',evidenceDir);evidence.add(evidenceDir);return {caseId:c.caseId,casePath,dimension:c.dimension,acIds:[...c.acIds],evidenceDir};});fs.writeFileSync(tmp,JSON.stringify({schemaVersion:1,cases},null,2)+'\\n');fs.renameSync(tmp,file);fs.unlinkSync(draft);process.stdout.write(JSON.stringify({cases}));\""
-        ],
+        "commands": [],
+        "frontendTestCaseManifest": {},
         "cwd": ".",
         "timeoutMs": 120000
       }
@@ -322,7 +188,7 @@
     {
       "id": "execute-frontend-cases-map",
       "depends_on": [
-        "materialize-frontend-case-manifest-shell"
+        "checklist-and-materialize-manifest-shell"
       ],
       "executor": "static",
       "role": "verifier",
@@ -341,7 +207,7 @@
       "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": 20,
         "maxExpandedNodes": 20,
@@ -379,19 +245,23 @@
           ],
           "writeSet": [
             "testcase/frontend/evidence/{{case.caseId}}/**"
-          ]
+          ],
+          "writeGuardPolicy": "tools-only"
         }
       }
     },
     {
-      "id": "validate-frontend-case-evidence-shell",
+      "id": "select-frontend-rerun-candidates-shell",
       "depends_on": [
         "execute-frontend-cases-map"
       ],
       "executor": "shell",
       "role": "verifier",
       "complexity": "LOW",
-      "writePolicy": "read-only",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/frontend/evidence/**"
+      ],
       "allowedPaths": [
         "testcase/frontend/cases/**",
         "testcase/frontend/evidence/**"
@@ -400,131 +270,117 @@
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Deterministic validation that every manifest case has execution.md and valid matching case-result.json; blocked results require blockedReason.",
-      "subtask_prompt": "Validate all frontend case evidence before evidence review; fail closed on missing or malformed records.",
+      "outputContract": "Stdout final JSON line {cases:[...]} for blocked or missing-result-file cases with rerunAttempt < 2.",
+      "subtask_prompt": "Select frontend-test cases eligible for bounded rerun.",
       "shell": {
         "commands": [
-          "node -e \"const fs=require('fs'),path=require('path');const file='testcase/frontend/cases/manifest.json';if(!fs.existsSync(file))throw new Error('missing '+file);const manifest=JSON.parse(fs.readFileSync(file,'utf8'));const statuses=new Set(['passed','failed','blocked']);let failed=false;for(const c of manifest.cases||[]){const dir=c&&c.evidenceDir;const execution=path.join(dir||'','execution.md'),resultPath=path.join(dir||'','case-result.json');if(!c||typeof c.caseId!=='string'||typeof dir!=='string'||path.isAbsolute(dir)||dir.includes('..')||!fs.existsSync(execution)||!fs.existsSync(resultPath)){failed=true;continue;}let r;try{r=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch{failed=true;continue;}if(!r||r.caseId!==c.caseId||!statuses.has(r.status)||!Array.isArray(r.evidencePaths)||(r.status==='blocked'&&!(typeof r.blockedReason==='string'&&r.blockedReason.trim())))failed=true;}if(failed)process.exit(1);\""
+          "node -e \"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)){const st=reason;if(st!=='blocked'){missing=true;reason=reason||'missing-result-files';}}const should=(reason==='blocked'||missing)&&attempt<2;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'});}}const out={schemaVersion:1,cases};fs.mkdirSync('testcase/frontend/evidence',{recursive:true});fs.writeFileSync('testcase/frontend/evidence/rerun-candidates.json',JSON.stringify(out,null,2)+'\\n');process.stdout.write(JSON.stringify({cases}));"
         ],
         "cwd": ".",
         "timeoutMs": 120000
       }
     },
     {
-      "id": "finalize-frontend-test-result-shell",
+      "id": "rerun-frontend-cases-map",
       "depends_on": [
-        "validate-frontend-case-evidence-shell"
+        "select-frontend-rerun-candidates-shell"
       ],
-      "executor": "shell",
+      "executor": "static",
       "role": "verifier",
       "complexity": "LOW",
-      "writePolicy": "read-only",
-      "allowedPaths": [
-        "testcase/frontend/cases/**",
-        "testcase/frontend/evidence/**"
-      ],
+      "writePolicy": "none",
+      "allowedPaths": [],
       "forbiddenPaths": [
         ".harness/**",
         "artifacts/**"
       ],
-      "outputContract": "Run-owned hash-bound frontend-test-result-v1 from manifest and validated evidence.",
-      "subtask_prompt": "Materialize the authoritative frontend-test-result-v1; never consume Pi prose.",
-      "shell": {
-        "commands": [],
-        "jsonArtifactGate": {
-          "fromNodeId": "validate-frontend-case-evidence-shell",
-          "schemaId": "frontend-test-result-v1",
-          "artifactName": "frontend-test-result.json",
-          "outputDir": "contracts"
+      "outputContract": "Serial rerun of blocked/missing-result frontend cases.",
+      "subtask_prompt": "Expand rerun candidates into serial browser case children.",
+      "static": {
+        "resultMarkdown": "Frontend case map expansion barrier."
+      },
+      "dynamicExpansion": {
+        "type": "map_agent",
+        "workflowNodeId": "rerun-frontend-cases-map",
+        "itemsFrom": "$.nodes['select-frontend-rerun-candidates-shell'].output.cases",
+        "itemName": "case",
+        "maxItems": 20,
+        "maxExpandedNodes": 20,
+        "childIdPrefix": "rerun-frontend-case",
+        "tokenBudget": {
+          "maxTokensPerCase": 20000,
+          "maxTotalTokens": 200000
         },
-        "cwd": ".",
-        "timeoutMs": 120000
+        "childTask": {
+          "executor": "pi",
+          "role": "implementer",
+          "skills": [
+            "playwright-cli"
+          ],
+          "toolProfile": "write",
+          "commandPolicy": {
+            "mode": "capability-allowlist",
+            "capabilities": [
+              "playwright-cli"
+            ]
+          },
+          "complexity": "MED",
+          "subtaskPromptTemplate": "RERUN attempt {{case.rerunAttempt}} for {{case.caseId}} (reason={{case.reason}}). Rewrite authoritative evidenceDir case-result.json and execution.md; set rerunAttempt={{case.rerunAttempt}}. Primary job: EXECUTE {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session). Use the structured playwright_cli tool for every browser action. Do not request or search for bash. Translate each playwright-cli line in the case Markdown into one playwright_cli tool call. The controller-owned browser capability freezes baseUrl from hash-bound task source config.md or the localhost default; context/case prose may reference but cannot establish or override that origin. Start only with playwright_cli command=open and controller-injected concrete frozen URL args (default session; no -s=). Dynamic refs: literal eX/eY are documentation placeholders, not tool args. Immediately before every structured playwright_cli call that references an element, parse the actual eNN from the immediately preceding latest snapshot and pass only that actual eNN. Never send literal eX/eY, and never reuse a stale ref after a new snapshot. File outputs are canonical: screenshot uses [--filename, final.png] (or [e5, --filename, final.png] only for a real target), pdf uses [--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 an output path as a positional target. Passed authority requires same-child ordered controller receipts: successful open → successful find → successful post-execution cleanup. Only successful find is meaningful; snapshot, goto, screenshot, request/console, and ordinary interactions cannot establish passed. Only when preflight or playwright_cli tool explicitly fails may you write blocked evidence. Always persist {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json (caseId, status passed|failed|blocked, evidencePaths; blocked needs blockedReason). Business failed/blocked is not a node failure. Close via playwright_cli command=close. Return compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
+          "outputContract": "Compact JSON <=1200 chars. Browser actions must use structured playwright_cli tool.",
+          "writePolicy": "exclusive",
+          "allowedPaths": [
+            "testcase/frontend/cases/{{case.caseId}}.md",
+            "testcase/frontend/rag/context.md",
+            "testcase/frontend/rag/coverage-map.md",
+            "testcase/frontend/evidence/{{case.caseId}}/**"
+          ],
+          "forbiddenPaths": [
+            ".harness/**",
+            "artifacts/**"
+          ],
+          "writeSet": [
+            "testcase/frontend/evidence/{{case.caseId}}/**"
+          ],
+          "writeGuardPolicy": "tools-only"
+        }
       }
     },
     {
-      "id": "frontend-outcome-gate-shell",
+      "id": "finalize-frontend-test-result-shell",
       "depends_on": [
-        "finalize-frontend-test-result-shell"
+        "rerun-frontend-cases-map"
       ],
-      "executor": "shell",
       "role": "verifier",
-      "complexity": "LOW",
-      "writePolicy": "read-only",
-      "allowedPaths": [],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "Pass only for a real passed frontend-test-result-v1.",
-      "subtask_prompt": "Delivery/Worker gate for authoritative frontend-test result. Retrospective does not depend on this node so failed runs can still write reports.",
-      "shell": {
-        "commands": [
-          "test -n \"${HARNESS_DAG_RUN_DIR:-}\" || { echo \"missing HARNESS_DAG_RUN_DIR for frontend-test outcome gate\" >&2; exit 2; }; RESULT=\"${HARNESS_DAG_RUN_DIR}/contracts/frontend-test-result.json\"; test -f \"${RESULT}\" || { echo \"missing frontend-test result: ${RESULT}\" >&2; exit 2; }; node -e 'const fs=require(\"fs\");const r=JSON.parse(fs.readFileSync(process.argv[1],\"utf8\"));const ok=r.outcome===\"passed\"&&r.integrationMode===\"real\"&&Number(r.totals?.failed||0)===0&&Number(r.totals?.blocked||0)===0&&Array.isArray(r.acceptanceCoverage?.missing)&&r.acceptanceCoverage.missing.length===0;if(!ok)process.exit(1);' \"${RESULT}\""
-        ],
-        "cwd": ".",
-        "timeoutMs": 60000
-      }
-    },
-    {
-      "id": "frontend-test-retrospect-pi",
-      "depends_on": [
-        "finalize-frontend-test-result-shell",
-        "frontend-test-l5-report-shell"
-      ],
-      "executor": "pi",
-      "role": "closeout",
-      "toolProfile": "write",
-      "complexity": "MED",
-      "writePolicy": "exclusive",
-      "writeSet": [
-        "testcase/frontend/reports/**"
-      ],
-      "allowedPaths": [
-        "testcase/frontend/**"
-      ],
-      "forbiddenPaths": [
-        ".harness/**",
-        "artifacts/**"
-      ],
-      "outputContract": "Write 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.",
-      "subtask_prompt": "Write the frontend test retrospective under testcase/frontend/reports/ after result materialization (do not wait for outcome=pass). Combine AC→case→browser-evidence review with the closeout report. Blocked cases never count as passed. Do not write docs/**."
-    },
-    {
-      "id": "frontend-test-l5-report-shell",
-      "depends_on": [
-        "finalize-frontend-test-result-shell"
-      ],
       "executor": "shell",
-      "role": "verifier",
       "complexity": "LOW",
       "writePolicy": "exclusive",
       "writeSet": [
-        "testcase/frontend/reports/**"
+        "testcase/frontend/evidence/**"
       ],
       "allowedPaths": [
-        "testcase/frontend/**"
+        "testcase/frontend/cases/**",
+        "testcase/frontend/evidence/**"
       ],
       "forbiddenPaths": [
         ".harness/**",
-        "artifacts/**"
+        "src/**"
       ],
-      "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": "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.",
       "shell": {
         "commands": [],
-        "frontendTestL5Report": {},
+        "frontendTestResultFinalize": {},
         "cwd": ".",
         "timeoutMs": 120000
       }
     },
     {
-      "id": "frontend-test-html-report-shell",
+      "id": "frontend-test-reports-shell",
       "depends_on": [
-        "frontend-test-retrospect-pi",
-        "frontend-test-l5-report-shell"
+        "finalize-frontend-test-result-shell"
       ],
-      "executor": "shell",
       "role": "verifier",
+      "executor": "shell",
       "complexity": "LOW",
       "writePolicy": "exclusive",
       "writeSet": [
@@ -535,13 +391,15 @@
       ],
       "forbiddenPaths": [
         ".harness/**",
-        "artifacts/**"
+        "src/**"
       ],
-      "outputContract": "Write frontend-test-report.md and frontend-test-report.html containing only case execution results, case content, and failed/blocked error analysis.",
-      "subtask_prompt": "Render the formal frontend test report from frontend-test-result-v1 without evidence chains, advisory findings, suggestions, or ratings.",
+      "outputContract": "Main frontend-test-report.md/html from frontend-test-result-v1; optional L-5. Pipeline acceptance = result-v1 + main HTML.",
+      "subtask_prompt": "Render operational reports from frontend-test-result-v1 only.",
       "shell": {
         "commands": [],
-        "frontendTestHtmlReport": {},
+        "frontendTestReports": {
+          "l5": true
+        },
         "cwd": ".",
         "timeoutMs": 120000
       }

package/docs/templates/frontend-test-dag.retrieve-context.prompt.md

@@ -10,6 +10,12 @@ The preflight controller resolves and freezes one absolute browser base URL from
 - Never use production hosts or credentials.
 - Write `environmentProbe: pending`. The environment preflight shell will replace this with `reachable`, `unreachable`, or `curl-unavailable` plus a structured `blockedReason` (for example `frontend-base-url-unreachable`).
 - Include the exact browser start prefix using the supplied controller-frozen URL:
-  `playwright-cli open --browser=chrome --headed <controller-frozen-base-url>`.
+  `playwright-cli open --browser=chrome --headless <controller-frozen-base-url>`.
 
 Do not claim the environment is reachable until preflight completes. Preflight does not start the application.
+
+
+## Standard scenario coverage
+
+- Copy or reference `docs/templates/frontend-test-standard-scenarios.v1.json` into `testcase/frontend/rag/standard-scenarios.v1.json` when available.
+- Add `## Standard scenario coverage` to coverage-map.md with planned/n/a for each must scenario.

package/docs/templates/frontend-test-dag.review-cases.prompt.md

@@ -2,4 +2,4 @@
 
 Read the RAG files and Markdown cases only. First line must be `VERDICT: pass` or `VERDICT: request-revision`. Report AC coverage, case independence, evidence completeness, unsafe environment/data dependencies, and manifest issues. This verdict is a deterministic safety gate: `request-revision` blocks manifest materialization and browser execution.
 
-Every case must retain the exact browser-start command prefix with the resolved absolute baseUrl from `testcase/frontend/rag/context.md` (prefer task source `config.md`, else `http://localhost:5173`): `playwright-cli open --browser=chrome --headed <resolved-base-url>`; session flags must not precede `open`, and subsequent commands must remain in its default session without `-s=` or assumed named-session binding. Verify every executable sub-scenario specifies fixture/reset, UI reset, fresh snapshot before element refs, a successful `playwright-cli find ...` semantic assertion after `open`, and an evidence write point. `snapshot`, `goto`, `screenshot`, `request`/`console`, and ordinary interactions cannot independently authorize passed. Verify each case requires both `execution.md` and `case-result.json` under its own evidence directory. The JSON result must contain matching `caseId`, `status` (`passed`, `failed`, or `blocked`) and `evidencePaths`; blocked cases must name a non-empty `blockedReason` and cannot count as passed.
+Every case must retain the exact browser-start command prefix with the resolved absolute baseUrl from `testcase/frontend/rag/context.md` (prefer task source `config.md`, else `http://localhost:5173`): `playwright-cli open --browser=chrome --headless <resolved-base-url>`; session flags must not precede `open`, and subsequent commands must remain in its default session without `-s=` or assumed named-session binding. Verify every executable sub-scenario specifies fixture/reset, UI reset, fresh snapshot before element refs, a successful `playwright-cli find ...` semantic assertion after `open`, and an evidence write point. `snapshot`, `goto`, `screenshot`, `request`/`console`, and ordinary interactions cannot independently authorize passed. Verify each case requires both `execution.md` and `case-result.json` under its own evidence directory. The JSON result must contain matching `caseId`, `status` (`passed`, `failed`, or `blocked`) and `evidencePaths`; blocked cases must name a non-empty `blockedReason` and cannot count as passed.