@tea-agent/loop-agent 0.16.15-beta.0 → 0.16.16

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

@@ -20,6 +20,7 @@ import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "
 import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
 import { buildBackendTestEffectiveResultSelectorShellSnippet, buildBackendTestRepairEligibilityShellSnippet, buildBackendTestRepairSafetyShellSnippet, } from "./backend-test-repair-contract.js";
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
+import { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
@@ -3660,11 +3661,8 @@ function buildFrontendTestHybridDag(sources) {
     const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
         pattern === "testcase/**" ||
         pattern === "**");
-    const hasReportWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" ||
-        pattern === "docs/**" ||
-        pattern === "**");
-    if (!hasFrontendTestWriteScope || !hasReportWriteScope) {
-        throw new Error('frontend-test requires task.json allowedPaths to include both "testcase/frontend/**" and "docs/test-reports/**" (or explicit containing globs).');
+    if (!hasFrontendTestWriteScope) {
+        throw new Error('frontend-test requires task.json allowedPaths to include "testcase/frontend/**" (or an explicit containing glob).');
     }
     const forbidden = commonForbiddenPaths(sources);
     const ragWriteSet = ["testcase/frontend/rag/**"];
@@ -3675,7 +3673,7 @@ function buildFrontendTestHybridDag(sources) {
         JSON.stringify([
             "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')); if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases)) throw new Error('invalid frontend case manifest');",
+            "const manifest=JSON.parse(fs.readFileSync(file,'utf8')); if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases)||manifest.cases.length===0) throw new Error('invalid or empty frontend case manifest');",
             "const dims=new Set(['core','boundary','flow','backend']);",
             "const seen=new Set(); const seenCasePath=new Set(); const seenEvidenceDir=new Set();",
             "for(const c of manifest.cases){",
@@ -3685,13 +3683,27 @@ function buildFrontendTestHybridDag(sources) {
             " if(!Array.isArray(c.acIds)||c.acIds.length===0||c.acIds.some(a=>typeof a!=='string'||!a.trim())) throw new Error('invalid acIds');",
             " for(const k of ['casePath','evidenceDir']){ const v=c[k]; if(typeof v!=='string'||path.isAbsolute(v)||v.includes('..')) throw new Error('unsafe '+k); }",
             " if(c.casePath!=='testcase/frontend/cases/'+c.caseId+'.md') throw new Error('casePath must match caseId');",
-            " if(!c.evidenceDir.startsWith('testcase/frontend/evidence/'+c.caseId+'/')) throw new Error('case path escapes frontend test roots');",
+            // Accept evidenceDir as the case root or a nested path under that root.
+            " { const prefix='testcase/frontend/evidence/'+c.caseId; if(!(c.evidenceDir===prefix||c.evidenceDir.startsWith(prefix+'/'))) throw new Error('case path escapes frontend test roots'); }",
+            " if(!fs.existsSync(c.casePath)) throw new Error('missing case file '+c.casePath);",
             " if(seenCasePath.has(c.casePath)) throw new Error('duplicate casePath'); seenCasePath.add(c.casePath);",
             " if(seenEvidenceDir.has(c.evidenceDir)) throw new Error('duplicate evidenceDir'); seenEvidenceDir.add(c.evidenceDir);",
             "}",
             "process.stdout.write(JSON.stringify({cases:manifest.cases}));",
         ].join("")),
     ].join(" ");
+    const evidenceValidation = [
+        "node -e",
+        JSON.stringify([
+            "const fs=require('fs'),path=require('path');",
+            "const manifestPath='testcase/frontend/cases/manifest.json';if(!fs.existsSync(manifestPath))throw new Error('missing '+manifestPath);",
+            "const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));if(!Array.isArray(manifest.cases))throw new Error('invalid frontend case manifest');",
+            "const statuses=new Set(['passed','failed','blocked']);let failed=false;",
+            "for(const c of manifest.cases){const dir=c&&c.evidenceDir;if(!c||typeof c.caseId!=='string'||typeof dir!=='string'||path.isAbsolute(dir)||dir.includes('..')||!dir.startsWith('testcase/frontend/evidence/'+c.caseId+'/')){console.error('invalid case evidence target');failed=true;continue;}const execution=path.join(dir,'execution.md'),resultPath=path.join(dir,'case-result.json');if(!fs.existsSync(execution)){console.error(c.caseId+': missing '+execution);failed=true;}if(!fs.existsSync(resultPath)){console.error(c.caseId+': missing '+resultPath);failed=true;continue;}let result;try{result=JSON.parse(fs.readFileSync(resultPath,'utf8'));}catch{console.error(c.caseId+': invalid JSON '+resultPath);failed=true;continue;}if(!result||result.caseId!==c.caseId||!statuses.has(result.status)||!Array.isArray(result.evidencePaths)||result.evidencePaths.some(p=>typeof p!=='string'||path.isAbsolute(p)||p.includes('..'))){console.error(c.caseId+': result must have matching caseId, passed|failed|blocked status, and safe evidencePaths array');failed=true;continue;}if(result.status==='passed'&&(result.evidencePaths.length<2||!result.evidencePaths.some(p=>/\\.(png|jpg|jpeg|webp|zip|har|webm|mp4)$/i.test(p)))){console.error(c.caseId+': passed result requires browser evidence');failed=true;}if(result.status==='blocked'&&(typeof result.blockedReason!=='string'||!result.blockedReason.trim())){console.error(c.caseId+': blocked result requires blockedReason');failed=true;}}",
+            "if(failed)process.exit(1);console.log('frontend case evidence validation ok cases='+manifest.cases.length);",
+        ].join("")),
+    ].join(" ");
+    const frontendTestOutcomeGate = buildFrontendTestOutcomeGateShellSnippet();
     const spec = {
         version: 3,
         title: `Frontend test DAG: ${sources.taskConfig.title}`,
@@ -3705,7 +3717,8 @@ function buildFrontendTestHybridDag(sources) {
             "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 <base-url>.",
+            "Browser startup for generated cases must be playwright-cli open --browser=chrome --headed <base-url>; generated operations stay in the default browser session and must not use unverified named-session flags.",
+            "A frontend case review must emit VERDICT: pass before manifest materialization; request-revision blocks browser execution.",
             "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
         ],
         defaults: {
@@ -3747,8 +3760,21 @@ function buildFrontendTestHybridDag(sources) {
                 ].join("\n\n"),
             },
             {
-                id: "generate-frontend-functional-cases-pi",
+                id: "materialize-frontend-test-execution-shell",
                 depends_on: ["retrieve-frontend-test-context-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Fail-closed preflight for an isolated non-production frontend test execution contract.",
+                subtask_prompt: "Validate that RAG context declares a non-production base URL/env name, fixture/reset isolation, browser startup, and no credential values.",
+                shell: { commands: [["node -e", JSON.stringify("const fs=require('fs');const p='testcase/frontend/rag/context.md';if(!fs.existsSync(p))throw new Error('missing '+p);const s=fs.readFileSync(p,'utf8');const required=[['base URL',/base[- ]url/i],['fixture',/fixture/i],['reset',/reset|重置/i],['playwright-cli open --browser=chrome --headed',/playwright-cli open --browser=chrome --headed/i]];for(const [label,pattern] of required)if(!pattern.test(s))throw new Error('frontend-test execution contract missing '+label);if(/https?:\\/\\/(?:www\\.)?[^\\s]*(?:prod|production)/i.test(s))throw new Error('production URL forbidden');console.log('frontend-test-execution-v1 validated')")].join(" ")], cwd: ".", timeoutMs: 60000 },
+            },
+            {
+                id: "generate-frontend-functional-cases-pi",
+                depends_on: ["materialize-frontend-test-execution-shell"],
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -3762,8 +3788,8 @@ function buildFrontendTestHybridDag(sources) {
                     "Use skill playwright-cli-case-generator.",
                     "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and existing testcase/frontend/cases/. Write only testcase/frontend/cases/**.",
                     "Generate Markdown cases, index.md and manifest.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.",
-                    "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>.",
-                    "Each case must be independent, declare its session/preconditions/data cleanup, UI assertions, evidence paths under testcase/frontend/evidence/<case-id>/, and mark unsafe/missing dependencies blocked.",
+                    "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>. Use the same default browser session for every subsequent command; never write -s=<case-id> or assume named-session binding.",
+                    "Each case must be independently reproducible: for every executable sub-scenario state fixture/reset, UI reset, a fresh snapshot before references are used, exact evidence write point, preconditions/data cleanup, UI assertions, and evidence paths under testcase/frontend/evidence/<case-id>/. If the isolated environment is unavailable, require writing blocked evidence before any browser command.",
                 ].join("\n\n"),
             },
             {
@@ -3775,19 +3801,72 @@ function buildFrontendTestHybridDag(sources) {
                 writePolicy: "read-only",
                 allowedPaths: [...ragWriteSet, ...casesWriteSet],
                 forbiddenPaths: forbidden,
-                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes.",
-                subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, and evidence requirements. The verdict is advisory and does not block case execution.",
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes. request-revision blocks manifest materialization.",
+                subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, session consistency, fixture/UI reset and fresh snapshot steps, and evidence requirements. Any Important or Critical finding requires VERDICT: request-revision. Browser execution is blocked unless this review passes.",
             },
             {
-                id: "materialize-frontend-case-manifest-shell",
+                id: "revise-frontend-cases-pi",
                 depends_on: ["review-frontend-cases-pi"],
+                runIf: "$.nodes['review-frontend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: "HIGH",
+                writePolicy: "exclusive",
+                writeSet: casesWriteSet,
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Apply the one permitted frontend case revision under testcase/frontend/cases/** only; no browser execution or evidence writes.",
+                subtask_prompt: "This is the only permitted case revision. Read the first review findings and the RAG package. Revise only testcase/frontend/cases/**, preserve traceable AC mappings, and do not execute a browser 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'",
+                role: "reviewer",
+                executor: "pi",
+                complexity: "HIGH",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision after the single allowed case revision; no writes.",
+                subtask_prompt: "Perform the final frontend case review after the sole permitted revision. Apply the same traceability, isolation, manifest, reset, session, snapshot, and evidence checks. First verdict line must be exact; any Important or Critical finding requires request-revision. Do not write files.",
+            },
+            {
+                id: "final-frontend-case-review-gate-shell",
+                depends_on: ["review-frontend-cases-pi", "review-frontend-cases-final-pi"],
+                dependsPolicy: "all-or-condition-skip",
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "Pass-only effective frontend case review gate; final review takes precedence when the revision branch ran.",
+                subtask_prompt: "Authorize manifest materialization only after the effective frontend case review passes.",
+                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,
+                },
+            },
+            {
+                id: "materialize-frontend-case-manifest-shell",
+                depends_on: ["final-frontend-case-review-gate-shell"],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: casesWriteSet,
                 forbiddenPaths: forbidden,
-                outputContract: "stdout is exactly JSON { cases: [...] } after deterministic frontend manifest validation.",
+                outputContract: "Validated frontend manifest payload { cases: [...] }; shell command echo is permitted only as the prefix before exactly one final JSON line.",
                 subtask_prompt: "Validate and materialize the generated frontend case manifest.",
                 shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
             },
@@ -3811,6 +3890,7 @@ function buildFrontendTestHybridDag(sources) {
                     maxItems: config.maxCasesPerBatch,
                     maxExpandedNodes: config.maxCasesPerBatch,
                     childIdPrefix: "execute-frontend-case",
+                    workspaceTemplate: "{{case.evidenceDir}}",
                     tokenBudget: {
                         maxTokensPerCase: config.maxTokensPerCase,
                         maxTotalTokens: config.maxTotalTokens,
@@ -3834,15 +3914,67 @@ function buildFrontendTestHybridDag(sources) {
                         subtaskPromptTemplate: [
                             "Execute exactly case {{case.caseId}} from {{case.casePath}} using playwright-cli and webapp-testing. This is a fresh Pi session; do not use /new.",
                             "Use only the declared isolated test environment. If CLI/browser/base URL/credentials/fixture isolation is missing, record blocked rather than installing tools or guessing.",
-                            "Use playwright-cli open --browser=chrome --headed <base-url>. Persist execution.md, case-result.json, screenshots/trace/video/logs under {{case.evidenceDir}} before returning.",
+                            "Use exactly this browser start command prefix: playwright-cli open --browser=chrome --headed <base-url>. Do not put session flags before open. Every later playwright-cli command must use that same default browser session; must not use -s=<case-id>, -s=, or any named-session flag because no session binding is verified.",
+                            "For every sub-scenario, record fixture/reset, UI reset, and a fresh snapshot before using element references. If the isolated environment is missing, write blocked evidence before any browser command; do not open or connect to a browser.",
+                            "Before returning, always persist {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json. case-result.json must be JSON with matching caseId, status as passed, failed, or blocked, and evidencePaths array; a blocked result must include non-empty blockedReason and must never imply pass.",
+                            "Run a local deterministic validation before returning: node -e \"const fs=require('fs');const p='{{case.evidenceDir}}';const r=JSON.parse(fs.readFileSync(p+'case-result.json','utf8'));if(!fs.existsSync(p+'execution.md')||r.caseId!=='{{case.caseId}}'||!['passed','failed','blocked'].includes(r.status)||!Array.isArray(r.evidencePaths)||(r.status==='blocked'&&!(typeof r.blockedReason==='string'&&r.blockedReason.trim())))process.exit(1)\". Persist screenshots/trace/video/logs when actually available. execution.md must record the executed or blocked steps, base URL safety decision, fixture/reset and request-observation availability, and evidence file list.",
                             "A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
                         ].join("\n\n"),
                     },
                 },
             },
             {
-                id: "review-frontend-execution-pi",
+                id: "validate-frontend-case-evidence-shell",
                 depends_on: ["execute-frontend-cases-map"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
+                forbiddenPaths: forbidden,
+                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.",
+                shell: { commands: [evidenceValidation], 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",
+                    },
+                    cwd: ".",
+                    timeoutMs: 120000,
+                },
+            },
+            {
+                id: "frontend-test-result-outcome-gate-shell",
+                depends_on: ["materialize-frontend-test-result-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: [],
+                forbiddenPaths: forbidden,
+                outputContract: "Pass only when the run-owned frontend-test-result-v1 records outcome=passed and integrationMode=real.",
+                subtask_prompt: "Gate the authoritative frontend-test result before Pi review and retrospective.",
+                shell: { commands: [frontendTestOutcomeGate], cwd: ".", timeoutMs: 60000 },
+            },
+            {
+                id: "review-frontend-execution-pi",
+                depends_on: ["frontend-test-result-outcome-gate-shell"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -3860,11 +3992,11 @@ function buildFrontendTestHybridDag(sources) {
                 toolProfile: "write",
                 complexity: "MED",
                 writePolicy: "exclusive",
-                writeSet: ["docs/test-reports/**"],
-                allowedPaths: ["testcase/frontend/**", "docs/test-reports/**"],
+                writeSet: ["testcase/frontend/reports/**"],
+                allowedPaths: ["testcase/frontend/**"],
                 forbiddenPaths: forbidden,
-                outputContract: "Write frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
-                subtask_prompt: "Write the frontend test retrospective under docs/test-reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed.",
+                outputContract: "Write frontend-test retrospective under testcase/frontend/reports/frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
+                subtask_prompt: "Write the frontend test retrospective under testcase/frontend/reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed. Do not write docs/**.",
             },
         ],
     };

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
@@ -421,6 +422,19 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
             node.structuredArtifactSchemaId = task.shell.jsonArtifactGate.schemaId;
         }
+        else if (task.shell?.backendTestPipeline === "finalize-effective-result") {
+            // Pipeline materializes contracts/backend-test-result.json without jsonArtifactGate.
+            // Bind it so Outcome adapters project kind=backend-test-result for Ready Planner.
+            const artifactPath = path.join(runDir, "contracts", "backend-test-result.json");
+            if (existsSync(artifactPath)) {
+                const bytes = await readFile(artifactPath);
+                node.structuredArtifactPath = artifactPath;
+                node.structuredArtifactSha256 = createHash("sha256")
+                    .update(bytes)
+                    .digest("hex");
+                node.structuredArtifactSchemaId = "backend-test-result-v1";
+            }
+        }
     }
     state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
     await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);

package/dist/workflows/dag/types.js

@@ -91,6 +91,7 @@ export const dagJsonArtifactSchemaIdSchema = z.enum([
     "backend-test-semantic-review-v1",
     "backend-test-case-manifest-v1",
     "frontend-implementation-contract-v1",
+    "frontend-test-result-v1",
 ]);
 export const dagJsonArtifactGateSchema = z.object({
     fromNodeId: z.string().regex(/^[a-z][a-z0-9-]*$/),

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

@@ -2,4 +2,21 @@
 
 Use `playwright-cli-case-generator`. Read only `testcase/frontend/rag/context.md`, `coverage-map.md`, and existing `testcase/frontend/cases/`; write only that cases directory. Produce Markdown cases, `index.md`, and schema-version-1 `manifest.json`. Do not generate pytest or Playwright source code.
 
-Each case is independently executable and includes AC mapping, preconditions, session, cleanup, UI assertions, and isolated evidence paths. Use dimensions `core`, `boundary`, `flow`, or `backend`. Never guess API fields, constraints, SLA, credentials, or unrecorded data. The open command is exactly `playwright-cli open --browser=chrome --headed <base-url>`.
+Each case is independently executable and includes AC mapping, preconditions, cleanup, UI assertions, and its isolated evidence path. Use dimensions `core`, `boundary`, `flow`, or `backend`. Never guess API fields, constraints, SLA, credentials, or unrecorded data.
+
+Every case must use this exact browser-start command prefix:
+
+```text
+playwright-cli open --browser=chrome --headed <base-url>
+```
+
+Do not put a session flag before `open`. Every later Playwright CLI command must stay in that same default browser session: do **not** emit `-s=<case-id>`, `-s=...`, or assume an undocumented named-session binding.
+
+For every executable sub-scenario, state the fixture/reset operation, UI reset operation, a fresh snapshot before using element references, and the exact evidence write point. If the isolated environment is unavailable, require writing blocked evidence before any browser command; do not open or connect to a browser.
+
+Each case must require the executor to persist, even when blocked:
+
+- `testcase/frontend/evidence/<case-id>/execution.md`
+- `testcase/frontend/evidence/<case-id>/case-result.json`
+
+`case-result.json` must be valid JSON containing the matching `caseId`, `status` (`passed`, `failed`, or `blocked`), and an `evidencePaths` array. A blocked result must include a non-empty `blockedReason`, such as `isolated-test-environment-unavailable` or `token-budget-exhausted`, and must never claim or imply a pass. `execution.md` records attempted or blocked steps, base-URL safety decision, fixture/reset and request-observation availability, timestamps, and the evidence-file list. Screenshots, snapshots, traces, videos, and logs are required only when actually available and must stay under the same case evidence directory.