@tea-agent/loop-agent 0.18.1 → 0.20.0

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

@@ -1512,9 +1512,8 @@ function buildFrontendMockVerifyNode(sources, implementId, readOnlyPaths, forbid
         },
     };
 }
-function buildBlockedFrontendMockDag(sources, sourceContext, readOnlyPaths, forbiddenPaths, globalConstraints) {
+function buildBlockedFrontendMockDag(sources, readOnlyPaths, forbiddenPaths, globalConstraints) {
     const { taskConfig } = sources;
-    const mockContextBlock = resolveFrontendMockContextBlock(sources);
     const spec = {
         version: 3,
         title: `Frontend implementation DAG (BLOCKED Mock): ${taskConfig.title}`,
@@ -1533,46 +1532,25 @@ function buildBlockedFrontendMockDag(sources, sourceContext, readOnlyPaths, forb
         },
         skillsByRole: FRONTEND_SKILLS_BY_ROLE,
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        tasks: [
-            {
-                id: "frontend-contract-pi",
+        tasks: [{
+                id: "frontend-mock-blocked-shell",
                 depends_on: [],
-                role: "planner",
-                executor: "pi",
-                complexity: "MED",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown contract with Scope, Non-goals, Acceptance Criteria, UI States, Target Runtime Environment, Risks, and Verification Expectations. No file writes.",
-                subtask_prompt: [
-                    "Read task source and produce a concise frontend implementation contract.",
-                    "Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations.",
-                    "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    sourceContext,
-                ].join("\n\n"),
-            },
-            {
-                id: "frontend-scout-pi",
-                depends_on: ["frontend-contract-pi"],
-                role: "scout",
-                executor: "pi",
-                complexity: mapTaskComplexity(taskConfig.complexity),
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown scout report covering frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, and risks. No file writes.",
-                subtask_prompt: [
-                    "Inspect frontend code, routing, components, styles, package scripts, and tests.",
-                    "Return code and design observations, existing reuse opportunities, and verification entry points.",
-                    "Read-only: do not modify repository files.",
-                    sourceContext,
-                ].join("\n\n"),
-            },
-            buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, "No verification entrypoints were materialized because the generation-time Mock contract is blocked.", readOnlyPaths, forbiddenPaths),
-            buildFrontendMockContractGateNode("blocked", taskConfig.frontendMock?.policy ?? "auto", readOnlyPaths, forbiddenPaths),
-        ],
+                outputContract: "Deterministic generation-time Mock blocker. Always exits nonzero and never reaches a writer.",
+                subtask_prompt: "Fail closed because required Mock verification entrypoints were not materialized. Resolve the task contract and regenerate the DAG.",
+                shell: {
+                    commands: [
+                        "node -e \"console.error('frontend Mock contract blocked: required verification entrypoints are unavailable'); process.exit(1)\"",
+                    ],
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            }],
     };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
@@ -1653,13 +1631,13 @@ function pruneFrontendTasksForRisk(tasks, risk) {
     if (risk.forceFullGates || risk.selectedRisk !== "small") {
         return tasks;
     }
-    // small topology: drop the initial design review + conditional revision cycle;
-    // keep mock assess/gate, single design review (final), contract, implement, verify, repair chain, review.
+    // Small topology keeps one design review and removes only the conditional
+    // revision/final-review branch. The deterministic prewrite gate consumes the
+    // surviving plan and design review directly.
     const drop = new Set([
-        "frontend-design-gate-pi",
         "frontend-plan-revision-pi",
+        "frontend-final-design-review-pi",
     ]);
-    // If we drop plan-revision, contract shell must depend on plan-pi instead; final design review depends on plan.
     const filtered = tasks.filter((task) => !drop.has(task.id));
     const byId = new Map(filtered.map((task) => [task.id, task]));
     const remap = (deps) => {
@@ -1672,10 +1650,6 @@ function pruneFrontendTasksForRisk(tasks, risk) {
                     next.push("frontend-plan-pi");
                 continue;
             }
-            if (dep === "frontend-design-gate-pi") {
-                // skip removed gates
-                continue;
-            }
             if (byId.has(dep) || dep === "frontend-implement-pi")
                 next.push(dep);
         }
@@ -1683,76 +1657,29 @@ function pruneFrontendTasksForRisk(tasks, risk) {
     };
     return filtered.map((task) => {
         const depends_on = remap(task.depends_on);
-        // Ensure final design review still has plan + mock + contract path
-        if (task.id === "frontend-final-design-review-pi") {
-            for (const need of [
-                "frontend-plan-pi",
-                "frontend-mock-assess-pi",
-                "frontend-implementation-contract-shell",
-            ]) {
-                if (byId.has(need) && !depends_on.includes(need))
-                    depends_on.push(need);
-            }
+        if (task.id === "frontend-prewrite-gate-shell") {
+            const gate = task.shell?.frontendPrewriteGate;
             return {
                 ...task,
-                depends_on,
+                depends_on: ["frontend-plan-pi", "frontend-design-review-pi"],
                 dependsPolicy: "all",
-                runIf: undefined,
+                shell: gate
+                    ? {
+                        ...task.shell,
+                        commands: task.shell?.commands ?? [],
+                        frontendPrewriteGate: {
+                            ...gate,
+                            planFromNodeId: "frontend-plan-pi",
+                            planFallbackFromNodeIds: [],
+                            reviewFromNodeId: "frontend-design-review-pi",
+                            reviewFallbackFromNodeIds: [],
+                        },
+                    }
+                    : task.shell,
             };
         }
-        if (task.id === "frontend-requirement-coverage-shell") {
-            const shell = task.shell?.requirementCoverageGate
-                ? {
-                    ...task.shell,
-                    requirementCoverageGate: {
-                        ...task.shell.requirementCoverageGate,
-                        fromNodeIds: task.shell.requirementCoverageGate.fromNodeIds.map((nodeId) => nodeId === "frontend-plan-revision-pi"
-                            ? "frontend-plan-pi"
-                            : nodeId),
-                        fallbackFromNodeIds: undefined,
-                    },
-                }
-                : task.shell;
-            return { ...task, depends_on, shell };
-        }
-        if (task.id === "frontend-implementation-contract-shell") {
-            const nextDeps = depends_on.filter((dep) => dep !== "frontend-plan-revision-pi");
-            if (!nextDeps.includes("frontend-plan-pi") &&
-                byId.has("frontend-plan-pi")) {
-                nextDeps.push("frontend-plan-pi");
-            }
-            const shell = task.shell
-                ? {
-                    ...task.shell,
-                    jsonArtifactGate: task.shell.jsonArtifactGate
-                        ? {
-                            ...task.shell.jsonArtifactGate,
-                            fromNodeId: "frontend-plan-pi",
-                            fallbackFromNodeIds: undefined,
-                        }
-                        : task.shell.jsonArtifactGate,
-                }
-                : task.shell;
-            return { ...task, depends_on: nextDeps, shell };
-        }
-        if (task.id === "frontend-final-design-gate-shell") {
-            const shell = task.shell?.verdictGate
-                ? {
-                    ...task.shell,
-                    verdictGate: {
-                        ...task.shell.verdictGate,
-                        fallbackFromNodeIds: undefined,
-                    },
-                }
-                : task.shell;
-            return { ...task, depends_on, dependsPolicy: "all", shell };
-        }
         if (task.id === "frontend-implement-pi") {
-            // still requires final design gate
-            for (const need of [
-                "frontend-final-design-gate-shell",
-                "frontend-implementation-contract-shell",
-            ]) {
+            for (const need of ["frontend-prewrite-gate-shell"]) {
                 if (byId.has(need) && !depends_on.includes(need))
                     depends_on.push(need);
             }
@@ -1867,7 +1794,7 @@ function buildFrontendHybridDagFromTask(sources) {
     ];
     // Guard: blocked mode — generate assessment-only DAG with no writer reachable
     if (mockMode === "blocked") {
-        return buildBlockedFrontendMockDag(frontendSources, sourceContext, readOnlyPaths, forbiddenPaths, globalConstraints);
+        return buildBlockedFrontendMockDag(frontendSources, readOnlyPaths, forbiddenPaths, globalConstraints);
     }
     const staticFallbackCommands = ["npm run typecheck", "npm run build"];
     const behaviorFallbackCommands = ["npm test"];
@@ -1909,6 +1836,11 @@ function buildFrontendHybridDagFromTask(sources) {
         fallbackCommands: behaviorFallbackCommands,
         finalFullRequired: true,
     });
+    const mockVerifyTemplate = mockMode === "required" && hasMockVerifyCommands
+        ? buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths)
+        : undefined;
+    const mockShellCommands = mockVerifyTemplate?.shell?.commands ?? [];
+    const mockVerifyEvidence = mockVerifyTemplate?.shell?.verifyEvidence;
     const fixedVerificationContext = [
         "## Fixed frontend verification entrypoints",
         "These shell entrypoints are fixed at DAG generation and are the only commands the static and behavior shell nodes execute. A strategy or plan may add tests behind an existing entrypoint inside writeSet, but must not invent or replace commands or assume subtask_prompt executes a command.",
@@ -1968,16 +1900,11 @@ function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
-            // Mock assessment is always read-only and runs before planning.
-            buildFrontendMockAssessNode(frontendSources, sourceContext, mockContextBlock, fixedVerificationContext, readOnlyPaths, forbiddenPaths),
-            buildFrontendMockContractGateNode(mockMode, taskConfig.frontendMock?.policy ?? "auto", readOnlyPaths, forbiddenPaths),
             {
                 id: "frontend-plan-pi",
                 depends_on: [
                     "frontend-contract-pi",
                     "frontend-scout-pi",
-                    "frontend-mock-assess-pi",
-                    "frontend-mock-contract-gate-shell",
                 ],
                 role: "planner",
                 executor: "pi",
@@ -1990,8 +1917,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 outputContract: "Markdown implementation plan with Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks, followed by exactly one fenced json object conforming to frontend-implementation-contract-v1 when this node is the effective plan source. No file writes.",
                 subtask_prompt: [
-                    "Based on frontend-contract-pi, frontend-scout-pi, and the gated frontend-mock-assess-pi strategy, return a minimal frontend implementation plan.",
-                    "Carry the selected Mock / API strategy, endpoint/fixture mapping, explicit activation, production-default-off rule, verification commands, and Real Integration Gap into the plan.",
+                    "Based on frontend-contract-pi, frontend-scout-pi, task sources, and the generation-time Mock capability evidence, return a minimal frontend implementation plan.",
+                    "Select the Mock / API strategy inside the plan and structured contract. Carry endpoint/fixture mapping, explicit activation, production-default-off rule, verification commands, and Real Integration Gap into both outputs.",
                     "Include ordered steps, target files, UI state handling, styling/component strategy, interaction notes, Mock/API strategy, dependency policy, deterministic verification entrypoints, and residual risks. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
                     "End with exactly one fenced json object conforming to frontend-implementation-contract-v1 so small topology can materialize the contract without plan-revision.",
                     requirementCoverageInstruction,
@@ -2003,8 +1930,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 ].join("\n\n"),
             },
             {
-                id: "frontend-design-gate-pi",
-                depends_on: ["frontend-plan-pi", "frontend-mock-assess-pi"],
+                id: "frontend-design-review-pi",
+                depends_on: ["frontend-plan-pi"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "MED",
@@ -2027,10 +1954,9 @@ function buildFrontendHybridDagFromTask(sources) {
                 id: "frontend-plan-revision-pi",
                 depends_on: [
                     "frontend-plan-pi",
-                    "frontend-design-gate-pi",
-                    "frontend-mock-assess-pi",
+                    "frontend-design-review-pi",
                 ],
-                runIf: "$.nodes['frontend-design-gate-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                runIf: "$.nodes['frontend-design-review-pi'].firstVerdictLine == 'VERDICT: request-revision'",
                 role: "planner",
                 executor: "pi",
                 complexity: "MED",
@@ -2042,8 +1968,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 outputContract: "When the initial design review requests revision, return a complete Markdown revision plan followed by exactly one fenced json object conforming to frontend-implementation-contract-v1. The JSON is the authoritative materialization input. No file writes.",
                 subtask_prompt: [
-                    "Consume frontend-plan-pi (original plan) and frontend-design-gate-pi (first design review findings).",
-                    "This node runs only when frontend-design-gate-pi emitted VERDICT: request-revision. Produce a complete revised implementation plan that addresses every Required Plan Correction from the design findings.",
+                    "Consume frontend-plan-pi (original plan) and frontend-design-review-pi (first design review findings).",
+                    "This node runs only when frontend-design-review-pi emitted VERDICT: request-revision. Produce a complete revised implementation plan that addresses every Required Plan Correction from the design findings.",
                     "The revised plan must include Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks.",
                     requirementCoverageInstruction,
                     "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
@@ -2053,73 +1979,15 @@ function buildFrontendHybridDagFromTask(sources) {
                     frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
-            ...(requirementIds.length > 0
-                ? [
-                    {
-                        id: "frontend-requirement-coverage-shell",
-                        depends_on: ["frontend-plan-revision-pi", "frontend-plan-pi"],
-                        dependsPolicy: "all-or-condition-skip",
-                        role: "verifier",
-                        executor: "shell",
-                        complexity: "LOW",
-                        writePolicy: "read-only",
-                        allowedPaths: readOnlyPaths,
-                        forbiddenPaths,
-                        outputContract: "Deterministic current-run evidence that the original or revised frontend plan retains every explicit REQ-/BR-/AC- identifier from the bound task sources.",
-                        subtask_prompt: "Block final design review when the current run's plan facts omit any explicit requirement identifier from the authoritative task sources.",
-                        shell: {
-                            commands: [],
-                            requirementCoverageGate: {
-                                fromNodeIds: ["frontend-plan-revision-pi"],
-                                fallbackFromNodeIds: ["frontend-plan-pi"],
-                                requiredIds: requirementIds,
-                                label: "frontend requirement coverage",
-                            },
-                            cwd: ".",
-                            timeoutMs: 60000,
-                        },
-                    },
-                ]
-                : []),
-            {
-                id: "frontend-implementation-contract-shell",
-                depends_on: ["frontend-plan-revision-pi", "frontend-plan-pi"],
-                dependsPolicy: "all-or-condition-skip",
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Run-owned validated frontend-implementation-contract-v1 artifact path, schema id, and SHA-256.",
-                subtask_prompt: "Materialize the effective frontend plan as a source-bound structured contract; fail closed on missing or invalid output.",
-                shell: {
-                    commands: [],
-                    jsonArtifactGate: {
-                        fromNodeId: "frontend-plan-revision-pi",
-                        fallbackFromNodeIds: ["frontend-plan-pi"],
-                        schemaId: "frontend-implementation-contract-v1",
-                        artifactName: "frontend-implementation-contract.json",
-                        outputDir: "contracts",
-                    },
-                    cwd: ".",
-                    timeoutMs: 60000,
-                },
-            },
             {
                 id: "frontend-final-design-review-pi",
                 depends_on: [
                     "frontend-plan-revision-pi",
                     "frontend-plan-pi",
-                    "frontend-design-gate-pi",
-                    "frontend-mock-assess-pi",
-                    "frontend-implementation-contract-shell",
-                    ...(requirementIds.length > 0
-                        ? ["frontend-requirement-coverage-shell"]
-                        : []),
+                    "frontend-design-review-pi",
                 ],
                 dependsPolicy: "all-or-condition-skip",
-                runIf: "$.nodes['frontend-design-gate-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                runIf: "$.nodes['frontend-design-review-pi'].firstVerdictLine == 'VERDICT: request-revision'",
                 role: "reviewer",
                 executor: "pi",
                 complexity: "MED",
@@ -2129,11 +1997,11 @@ function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
                 outputContract: "For the effective frontend plan, return plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings and Checked Items. No file writes.",
                 subtask_prompt: [
-                    "Audit the effective frontend plan before implementation. In the standard topology this node runs after request-revision and consumes frontend-plan-revision-pi; in a small-risk topology where that branch is pruned, audit frontend-plan-pi directly.",
+                    "Audit the revised frontend plan before implementation. This node runs only after request-revision and consumes frontend-plan-revision-pi.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "When an initial design review requested revision, verify that every Required Plan Correction has been fully addressed. In the small-risk topology, independently audit the original plan against the full checklist because there is no initial-review finding set.",
+                    "Verify that every Required Plan Correction from the initial design review has been fully addressed.",
                     "Recheck the selected Mock / API strategy, contract-to-fixture mapping, authorized paths/dependencies, explicit activation, production-default-off behavior, behavior verification, and Real Integration Gap. MOCK_STRATEGY: blocked cannot receive VERDICT: pass.",
-                    "The frontend requirement coverage gate has verified that every explicit REQ-/BR-/AC- identifier remains present in the current-run plan evidence; review the mapped behavior rather than accepting identifier presence alone.",
+                    "Review every explicit REQ-/BR-/AC- mapping; the downstream prewrite gate also checks identifier retention deterministically.",
                     "Request revision if any design gap remains, if corrections are incomplete, or if the revised plan introduces new unaddressed issues.",
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
@@ -2141,10 +2009,12 @@ function buildFrontendHybridDagFromTask(sources) {
                 ].join("\n\n"),
             },
             {
-                id: "frontend-final-design-gate-shell",
+                id: "frontend-prewrite-gate-shell",
                 depends_on: [
                     "frontend-final-design-review-pi",
-                    "frontend-design-gate-pi",
+                    "frontend-design-review-pi",
+                    "frontend-plan-revision-pi",
+                    "frontend-plan-pi",
                 ],
                 dependsPolicy: "all-or-condition-skip",
                 role: "verifier",
@@ -2153,16 +2023,24 @@ function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic effective design verdict gate: resolve the selected design review output and exit 0 only on VERDICT: pass. This is the sole authorization for frontend implementation writes.",
-                subtask_prompt: "Deterministic gate: block frontend implementation unless the effective design review emitted VERDICT: pass.",
+                outputContract: "Deterministic prewrite authorization: resolve effective plan/review, require VERDICT: pass, retain every requirement id, validate Mock policy, and materialize the canonical implementation contract.",
+                subtask_prompt: "Fail closed unless the effective reviewed plan is source-bound, requirement-complete, Mock-policy compliant, schema-valid, and approved.",
                 shell: {
                     commands: [],
-                    verdictGate: {
-                        fromNodeId: "frontend-final-design-review-pi",
-                        fallbackFromNodeIds: ["frontend-design-gate-pi"],
-                        accept: ["VERDICT: pass"],
-                        label: "frontend final design gate",
-                        lineMode: "first-verdict-line",
+                    frontendPrewriteGate: {
+                        schemaVersion: 1,
+                        planFromNodeId: "frontend-plan-revision-pi",
+                        planFallbackFromNodeIds: ["frontend-plan-pi"],
+                        reviewFromNodeId: "frontend-final-design-review-pi",
+                        reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
+                        requiredRequirementIds: requirementIds,
+                        allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled"
+                            ? ["not-needed"]
+                            : taskConfig.frontendMock?.policy === "required"
+                                ? ["native", "browser-intercept", "request-adapter"]
+                                : ["native", "browser-intercept", "request-adapter", "not-needed"],
+                        artifactName: "frontend-implementation-contract.json",
+                        outputDir: "contracts",
                     },
                     cwd: ".",
                     timeoutMs: 60000,
@@ -2171,12 +2049,10 @@ function buildFrontendHybridDagFromTask(sources) {
             {
                 id: implementId,
                 depends_on: [
-                    "frontend-final-design-gate-shell",
-                    "frontend-implementation-contract-shell",
+                    "frontend-prewrite-gate-shell",
                     "frontend-plan-revision-pi",
                     "frontend-final-design-review-pi",
                     "frontend-plan-pi",
-                    "frontend-mock-assess-pi",
                 ],
                 dependsPolicy: "all-or-condition-skip",
                 role: "implementer",
@@ -2190,11 +2066,11 @@ function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 outputContract: "Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
-                    "Implement against the validated run-owned Frontend Implementation Contract from frontend-implementation-contract-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
+                    "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
                     "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
                     "Map every requirement id and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
-                    "Implement only the approved Mock strategy from frontend-mock-assess-pi as carried in the contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
-                    "frontend-final-design-gate-shell confirmed the effective initial-or-final design verdict is pass. Stay within writeSet and preserve unrelated files.",
+                    "Implement only the approved Mock strategy carried by the validated contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
+                    "frontend-prewrite-gate-shell confirmed the effective plan/review, requirement coverage, Mock policy, and contract. Stay within writeSet and preserve unrelated files.",
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
                     "Do not write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     writerDeliveryContract(taskConfig),
@@ -2204,122 +2080,37 @@ function buildFrontendHybridDagFromTask(sources) {
                     .filter((value) => Boolean(value))
                     .join("\n\n"),
             },
-            // Optional dedicated Mock verification exists only when trusted commands
-            // were frozen at generation time. Behavior verification remains required.
-            ...(mockMode === "required" && hasMockVerifyCommands
-                ? [
-                    buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths),
-                ]
-                : []),
             {
-                id: "frontend-static-verify-shell",
-                depends_on: mockMode === "required" && hasMockVerifyCommands
-                    ? ["frontend-mock-verify-shell"]
-                    : [implementId],
+                id: "frontend-verify-assess-shell",
+                depends_on: [implementId],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Archived shell stdout/stderr with exit codes for deterministic static verification; no worktree writes.",
-                subtask_prompt: "Run deterministic static verification for the frontend implementation, including a production/default-real-path build with Mock activation off when Mock applies. Report only what the commands actually exercise.",
-                shell: {
-                    commands: staticShellCommands,
-                    verifyEvidence: staticVerifyEvidence,
-                    cwd: ".",
-                    timeoutMs: 300000,
-                    nonZeroExitPolicy: "record",
-                },
-            },
-            {
-                id: "frontend-behavior-verify-shell",
-                depends_on: ["frontend-static-verify-shell"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: behaviorPaths,
-                forbiddenPaths,
-                outputContract: "Archived shell stdout/stderr with exit codes for deterministic behavior verification; no worktree writes.",
-                subtask_prompt: "Run the fixed deterministic behavior entrypoints for the selected strategy. For native, browser-intercept, or request-adapter, cover the approved Mock activation and applicable success/loading/empty/error states; for not-needed, exercise applicable real or no-remote behavior. Report only what the commands actually exercise.",
+                outputContract: "Run frozen Mock/static/behavior commands, materialize verification trace and repair assessment, and fail closed for non-repairable failures.",
+                subtask_prompt: "Execute the frontend verification bundle. Preserve per-command evidence; eligible repairable failures select the bounded repair branch.",
                 shell: {
-                    commands: behaviorShellCommands,
-                    verifyEvidence: behaviorVerifyEvidence,
+                    commands: [],
+                    frontendVerificationBundle: {
+                        schemaVersion: 1,
+                        mockCommands: mockShellCommands,
+                        staticCommands: staticShellCommands,
+                        behaviorCommands: behaviorShellCommands,
+                        mockEvidence: mockVerifyEvidence,
+                        staticEvidence: staticVerifyEvidence,
+                        behaviorEvidence: behaviorVerifyEvidence,
+                        mode: "initial",
+                    },
                     cwd: ".",
                     timeoutMs: 300000,
-                    nonZeroExitPolicy: "record",
-                },
-            },
-            {
-                id: "frontend-verification-trace-shell",
-                depends_on: [
-                    "frontend-behavior-verify-shell",
-                    "frontend-static-verify-shell",
-                    "frontend-implementation-contract-shell",
-                ],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Deterministic verification trace: contract verificationTargets bound to current-run static/behavior commandLabels; target files/symbols exist; Browser/visual not-run. No worktree writes.",
-                subtask_prompt: "Validate AC/UI/verification targets against frozen shell evidence and workspace files. Do not invent commands. Does not prove semantic test quality.",
-                shell: {
-                    commands: ["frontend-verification-trace-gate"],
-                    cwd: ".",
-                    timeoutMs: 120000,
-                    nonZeroExitPolicy: "record",
-                },
-            },
-            {
-                id: "frontend-failure-assess-shell",
-                depends_on: [
-                    "frontend-verification-trace-shell",
-                    "frontend-behavior-verify-shell",
-                    "frontend-static-verify-shell",
-                    "frontend-implementation-contract-shell",
-                ],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Run-owned frontend-repair-assessment-v1 at contracts/frontend-repair-assessment.json classifying verify/trace failures as repairable or not.",
-                subtask_prompt: "Assess current-run static/behavior/trace failure facts against the validated contract. Do not repair code.",
-                shell: {
-                    commands: ["frontend-failure-assess-gate"],
-                    cwd: ".",
-                    timeoutMs: 60000,
-                },
-            },
-            {
-                id: "frontend-repair-contract-shell",
-                depends_on: ["frontend-failure-assess-shell"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Deterministic repair eligibility gate: pass when no failure or repairable assessment; fail-closed on non-repairable classes.",
-                subtask_prompt: "Validate frontend-repair-assessment writeSet subset, attempt limit, and eligibility before repair writer.",
-                shell: {
-                    commands: ["frontend-repair-contract-gate"],
-                    cwd: ".",
-                    timeoutMs: 60000,
                 },
             },
             {
                 id: "frontend-repair-pi",
-                depends_on: [
-                    "frontend-repair-contract-shell",
-                    "frontend-failure-assess-shell",
-                    implementId,
-                ],
-                runIf: "$.nodes['frontend-failure-assess-shell'].json.eligible == true",
+                depends_on: ["frontend-verify-assess-shell", implementId],
+                runIf: "$.nodes['frontend-verify-assess-shell'].json.eligible == true",
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -2343,7 +2134,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     .join("\n\n"),
             },
             {
-                id: "frontend-static-reverify-shell",
+                id: "frontend-reverify-shell",
                 depends_on: ["frontend-repair-pi"],
                 role: "verifier",
                 executor: "shell",
@@ -2351,61 +2142,30 @@ function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Archived static re-verification after repair using the same frozen commands; fail on nonzero.",
-                subtask_prompt: "Re-run frozen static entrypoints after repair. Fresh evidence only; do not rewrite prior failure artifacts.",
+                outputContract: "Post-repair Mock/static/behavior re-verification plus refreshed canonical trace; any failure blocks review.",
+                subtask_prompt: "Re-run the frozen frontend verification bundle after bounded repair and fail on any command or trace failure.",
                 shell: {
-                    commands: staticShellCommands,
-                    verifyEvidence: staticVerifyEvidence,
-                    cwd: ".",
-                    timeoutMs: 300000,
-                },
-            },
-            {
-                id: "frontend-behavior-reverify-shell",
-                depends_on: ["frontend-static-reverify-shell"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: behaviorPaths,
-                forbiddenPaths,
-                outputContract: "Archived behavior re-verification after repair using the same frozen commands; fail on nonzero.",
-                subtask_prompt: "Re-run frozen behavior entrypoints after repair.",
-                shell: {
-                    commands: behaviorShellCommands,
-                    verifyEvidence: behaviorVerifyEvidence,
+                    commands: [],
+                    frontendVerificationBundle: {
+                        schemaVersion: 1,
+                        mockCommands: mockShellCommands,
+                        staticCommands: staticShellCommands,
+                        behaviorCommands: behaviorShellCommands,
+                        mockEvidence: mockVerifyEvidence,
+                        staticEvidence: staticVerifyEvidence,
+                        behaviorEvidence: behaviorVerifyEvidence,
+                        mode: "repair",
+                    },
                     cwd: ".",
                     timeoutMs: 300000,
                 },
             },
             {
-                id: "frontend-verification-retrace-shell",
+                id: "frontend-review-context-shell",
                 depends_on: [
-                    "frontend-behavior-reverify-shell",
-                    "frontend-static-reverify-shell",
-                    "frontend-implementation-contract-shell",
-                ],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Re-run verification trace against contract and reverify shell evidence after repair.",
-                subtask_prompt: "Trace AC/UI/verification targets against post-repair static/behavior evidence.",
-                shell: {
-                    commands: ["frontend-verification-trace-gate"],
-                    cwd: ".",
-                    timeoutMs: 120000,
-                },
-            },
-            {
-                id: "frontend-worktree-diff-shell",
-                depends_on: [
-                    "frontend-verification-retrace-shell",
-                    "frontend-behavior-reverify-shell",
-                    "frontend-static-reverify-shell",
+                    "frontend-reverify-shell",
                     "frontend-repair-pi",
+                    "frontend-verify-assess-shell",
                     implementId,
                 ],
                 dependsPolicy: "all-or-condition-skip",
@@ -2415,10 +2175,11 @@ function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Run-owned actual worktree diff_patch (artifacts/diff_patch.patch) plus contracts/frontend-worktree-diff.json inventory/hash for review. No product worktree writes.",
-                subtask_prompt: "Capture the authoritative actual diff after implementation and any selected repair/reverify branch so frontend-review-pi can audit changed files without relying on failure-path patches or model summaries.",
+                outputContract: "Canonical frontend review context containing validated contract, effective verification trace, repair assessment, and actual worktree diff.",
+                subtask_prompt: "Capture the actual diff and bind it to the effective initial-or-post-repair verification evidence for final review.",
                 shell: {
-                    commands: ["frontend-worktree-diff-gate"],
+                    commands: [],
+                    frontendReviewContext: { schemaVersion: 1 },
                     cwd: ".",
                     timeoutMs: 120000,
                 },
@@ -2426,26 +2187,16 @@ function buildFrontendHybridDagFromTask(sources) {
             {
                 id: "frontend-review-pi",
                 depends_on: [
-                    "frontend-worktree-diff-shell",
-                    "frontend-verification-retrace-shell",
-                    "frontend-static-reverify-shell",
-                    "frontend-behavior-reverify-shell",
+                    "frontend-review-context-shell",
+                    "frontend-reverify-shell",
                     "frontend-repair-pi",
-                    "frontend-verification-trace-shell",
-                    "frontend-static-verify-shell",
-                    "frontend-behavior-verify-shell",
-                    "frontend-failure-assess-shell",
+                    "frontend-verify-assess-shell",
                     implementId,
-                    "frontend-implementation-contract-shell",
-                    "frontend-contract-pi",
+                    "frontend-prewrite-gate-shell",
                     "frontend-plan-pi",
-                    "frontend-design-gate-pi",
+                    "frontend-design-review-pi",
                     "frontend-plan-revision-pi",
                     "frontend-final-design-review-pi",
-                    "frontend-mock-assess-pi",
-                    ...(mockMode === "required" && hasMockVerifyCommands
-                        ? ["frontend-mock-verify-shell"]
-                        : []),
                 ],
                 dependsPolicy: "all-or-condition-skip",
                 role: "reviewer",
@@ -2460,11 +2211,11 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Review the frontend implementation and verification evidence.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
                     "Any Critical or Important finding must force VERDICT: request-revision.",
-                    "Read the validated frontend-implementation-contract, the effective initial-or-post-repair frontend verification trace, the corresponding static/behavior shell facts, and the run-owned actual diff from frontend-worktree-diff-shell (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, effective initial-or-post-repair verification trace, repair assessment, and the run-owned actual diff (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
                     "Use the direct contract and the effective plan/design branch: original plan plus initial pass when revision was skipped, or revised plan plus final design review when revision ran. Do not infer them from the implementation summary.",
                     "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
-                    "Inspect the production/default-real-path static evidence directly and require Mock activation to be off for that check.",
+                    "Inspect the frontend-verify-assess-shell or selected frontend-reverify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
                     sourceContext,
@@ -2499,19 +2250,11 @@ function buildFrontendHybridDagFromTask(sources) {
                 depends_on: [
                     "frontend-review-gate-shell",
                     "frontend-review-pi",
-                    "frontend-verification-retrace-shell",
-                    "frontend-static-reverify-shell",
-                    "frontend-behavior-reverify-shell",
+                    "frontend-review-context-shell",
+                    "frontend-reverify-shell",
                     "frontend-repair-pi",
-                    "frontend-verification-trace-shell",
-                    "frontend-static-verify-shell",
-                    "frontend-behavior-verify-shell",
-                    "frontend-failure-assess-shell",
-                    "frontend-implementation-contract-shell",
-                    "frontend-mock-assess-pi",
-                    ...(mockMode === "required" && hasMockVerifyCommands
-                        ? ["frontend-mock-verify-shell"]
-                        : []),
+                    "frontend-verify-assess-shell",
+                    "frontend-prewrite-gate-shell",
                 ],
                 dependsPolicy: "all-or-condition-skip",
                 role: "closeout",
@@ -2526,7 +2269,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 outputContract: "Markdown closeout summary with Changes, Mock Decision / Strategy / Files / Verification / Production Boundary, Verification Evidence, Review Result, Frontend Status, Real Integration Status, Known Risks, and Follow-up. No file writes.",
                 subtask_prompt: [
                     "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
-                    "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use the effective initial-or-post-repair frontend verification trace facts; do not invent Browser evidence from component tests.",
+                    "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use contracts/frontend-review-context.json and the effective frontend-verify-assess-shell or frontend-reverify-shell facts; do not invent Browser evidence from component tests.",
                     `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
                     `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
@@ -3301,13 +3044,14 @@ async function buildBackendTestHybridDag(sources) {
         id: "generate-backend-md-cases-pi", depends_on: [environment.id], role: "implementer",
         executor: "pi", toolProfile: "write", complexity: "MED", writePolicy: "exclusive",
         writeSet: ["testcase/md/**"], allowedPaths: ["testcase/md/**"], forbiddenPaths: forbidden,
-        outputContract: "Write testcase/md/README.md plus module Markdown cases using BE-<MODULE>-<NNN>. Use Chinese for human-readable content while preserving required machine-readable identifiers and section headings; no JSON, pytest execution, production code or config writes.",
+        outputContract: "Write a Chinese, human-readable testcase/md/README.md plus module Markdown case cards using BE-<MODULE>-<NNN>; keep machine IDs/literals exact and do not execute pytest or modify production code/config.",
         subtask_prompt: [
             "Read the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.",
-            "Write human-readable content in Simplified Chinese by default: document titles, case titles, strategy explanations, preconditions, test-data descriptions, step descriptions, expected-result descriptions, automation notes, table headers and evidence-gap explanations. Keep English only where it is part of a machine-readable contract or established technical literal, including Case IDs, AC/REQ/BR IDs, exact section headings, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and source citations. Do not add an English translation when Chinese already conveys the meaning.",
-            "Every case heading is `## BE-<MODULE>-<NNN> <中文用例标题>` and contains these exact machine-readable headings: `### Acceptance Criteria`, `### Source References`, `### Preconditions`, `### Test Data`, `### Steps`, `### Expected Results`, and `### Automation Notes`. API cases also contain `### Endpoint` with Method and Path. Under those headings, write descriptions in Chinese while preserving exact IDs, values and protocol literals.",
-            "Create testcase/md/README.md in Chinese. It should concisely explain the test objective, environment/target, isolation and cleanup strategy, module index, traceability summary, assertion principles, evidence gaps and non-goals. Prefer readable Chinese tables and lists over repeated boilerplate.",
-            "Expected Results must be concrete, independently assertable Chinese statements. Each result should name the observable HTTP status, response field/value, state transition or membership condition instead of vague phrases such as ‘works correctly’ or ‘符合预期’. Steps must be executable and ordered. Use only environment-supported fixtures/targets/isolation. Record evidence gaps in Chinese instead of inventing behavior or credentials. Do not emit JSON, pytest, or execute commands.",
+            "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
+            "Create testcase/md/README.md as the concise entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in README.",
+            "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>` and uses these Chinese headings: `### 测试目的`, `### 验收标准`, `### 需求依据`, `### 前置条件`, optional `### 测试数据`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射`. API metadata may use a compact table under the case heading. The deterministic validator also accepts legacy English headings, but new output should use this Chinese presentation.",
+            "Place steps and their expected results in a compact readable table when that improves clarity; otherwise keep numbered executable steps and numbered/bulleted independently assertable results. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
+            "In `自动化映射`, record the planned script path and pytest function name when known. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
             "Read only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
@@ -3319,9 +3063,9 @@ async function buildBackendTestHybridDag(sources) {
         writeSet: ["testcase/md/**"], allowedPaths: ["testcase/md/**"], forbiddenPaths: forbidden,
         outputContract: "Review source fidelity and directly revise only testcase/md/**; return concise Markdown, never JSON.",
         subtask_prompt: [
-            "Independently review generated Markdown cases against each case Source References and environment evidence. Preserve and improve the Simplified Chinese presentation: human-readable titles, prose, table headers, steps, expected results and notes should be Chinese unless the token is a machine-readable ID, exact required heading, HTTP/API literal, field/enum value, path, filename, command or code symbol.",
-            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Also reject avoidable English prose, duplicated bilingual wording, vague Chinese results such as ‘符合预期’, and literal translations that obscure the observable assertion.",
-            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, fix mappings/expectations, merge duplicates, improve unclear Chinese wording, or record gaps in Chinese. Do not translate or alter Case IDs, AC/REQ/BR IDs, exact required section headings, HTTP methods, paths, field names, enum values, filenames, code symbols or Source References. Avoid cosmetic rewrites that do not improve correctness or readability.",
+            "Independently review generated Markdown cases against each case 需求依据 and environment evidence. Treat the files as human-facing test documentation: require a clear Chinese name and scenario/purpose, compact metadata, readable steps/results, and a concise automation mapping while preserving exact machine IDs and technical literals.",
+            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, and missing script/function mapping where it can be derived.",
+            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, fix mappings/expectations, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations exact. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "Read only precise referenced source paths plus requirement sections needed for uncovered ACs. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
             intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
@@ -3336,11 +3080,11 @@ async function buildBackendTestHybridDag(sources) {
         outputContract: "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring; no JSON and no pytest execution.",
         subtask_prompt: [
             "Convert validated testcase/md/** to pytest using upstream environment and validation evidence plus only bounded pytest config/conftest.",
-            "Ensure every final Markdown Case ID appears in at least one real top-level test_* function region, preferably as `test_BE_<MODULE>_<NNN>_<description>` or in that function's docstring. Multiple test functions may cover one Case ID; assertions come only from Expected Results and setup comes only from Preconditions/Test Data/Automation Notes.",
-            "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON.",
+            "Ensure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件/测试数据/自动化映射 or their legacy English aliases.",
+            "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
         ].join("\n\n"),
     };
-    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Fail closed only when a real Markdown case heading has no associated top-level pytest test function. Accept exact Case IDs in the function name or its decorator/body/docstring region; report multiple mappings and extra automation Case IDs without blocking. Continue to reject skip/xfail or swallowed exceptions.", "Run-owned reports/backend-test-traceability.md proving every real Markdown Case ID is covered by at least one pytest test function.");
+    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Fail closed only when a real Markdown case heading has no associated pytest test function or class method. Accept exact Case IDs in the function/method name or its decorator/body/docstring region; report multiple mappings and extra automation Case IDs without blocking. Continue to reject skip/xfail or swallowed exceptions.", "Run-owned reports/backend-test-traceability.md proving every real Markdown Case ID is covered by at least one pytest test function.");
     const pytestCommand = [
         'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
         'PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest testcase/ -v -p no:cacheprovider --junitxml="${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml"',
@@ -3348,7 +3092,7 @@ async function buildBackendTestHybridDag(sources) {
         'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml" ]; then exit 0; fi',
         'exit "${STATUS}"',
     ].join("; ");
-    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Execute pytest exactly once. Validate JUnit, render self-contained HTML from that JUnit without rerun, and preserve failures as facts.", "One pytest execution producing valid JUnit, self-contained HTML and reports/backend-test-facts.md; exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Execute pytest exactly once. Validate JUnit, render the primary self-contained Chinese HTML report from the same JUnit plus final Markdown case metadata without rerun, list every case with name/scenario/script/function/result/duration, and preserve failure summaries plus expandable technical details as facts.", "One pytest execution producing valid JUnit, self-contained HTML and reports/backend-test-facts.md; exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
     const canWriteReport = taskAllowsBackendTestReportWrite(sources);
     const report = {
         id: "backend-test-report-and-l5-pi", depends_on: [execute.id], role: "closeout", executor: "pi", complexity: "MED",