@tea-agent/loop-agent 0.16.1 → 0.16.3

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

@@ -18,6 +18,7 @@ import { resolveVerifyPreset } from "../../executors/shell-verification.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "./task-demand-routing.js";
 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 { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
@@ -932,6 +933,22 @@ function buildDagSourceBinding(sources) {
         requirementIds: extractExplicitRequirementIds(sources.requirementMarkdown, sources.constraintMarkdown, ...(sources.referenceDocuments ?? []).map((reference) => reference.markdown)),
     };
 }
+function buildBackendTestAnalysisSourceBindingContract(sources) {
+    const binding = buildDagSourceBinding(sources);
+    const requirement = binding.sources.find((source) => source.kind === "requirement");
+    if (!requirement) {
+        throw new Error("backend-test analysis requires a requirement source binding");
+    }
+    return {
+        taskId: binding.taskId,
+        requirementPath: requirement.path,
+        requirementSha256: requirement.sha256,
+        referencePaths: binding.sources
+            .filter((source) => source.kind === "reference")
+            .map((source) => source.path),
+        requirementIds: binding.requirementIds,
+    };
+}
 function buildSourceContextBlock(sources) {
     const requirementRef = toTaskRelativeSourcePath(sources, sources.requirementPath);
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
@@ -2311,9 +2328,33 @@ function buildFrontendHybridDagFromTask(sources) {
                     timeoutMs: 120000,
                 },
             },
+            {
+                id: "frontend-worktree-diff-shell",
+                depends_on: [
+                    "frontend-verification-retrace-shell",
+                    "frontend-behavior-reverify-shell",
+                    "frontend-static-reverify-shell",
+                    "frontend-repair-pi",
+                    implementId,
+                ],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                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 implement/repair/reverify so frontend-review-pi can audit changed files without relying on failure-path patches or model summaries.",
+                shell: {
+                    commands: ["frontend-worktree-diff-gate"],
+                    cwd: ".",
+                    timeoutMs: 120000,
+                },
+            },
             {
                 id: "frontend-review-pi",
                 depends_on: [
+                    "frontend-worktree-diff-shell",
                     "frontend-verification-retrace-shell",
                     "frontend-static-reverify-shell",
                     "frontend-behavior-reverify-shell",
@@ -2342,7 +2383,7 @@ 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, frontend-verification-trace evidence, static/behavior shell facts, and actual diff. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "Read the validated frontend-implementation-contract, frontend-verification-trace evidence, 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.",
                     "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, original plan, revision/no-op result, and final design review to reconstruct the approved plan and design verdict; 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.",
@@ -2424,6 +2465,7 @@ function buildFrontendHybridDagFromTask(sources) {
 // Backend test DAG template
 // ---------------------------------------------------------------------------
 function buildAnalyzeInputsNode(sources) {
+    const sourceBindingContract = buildBackendTestAnalysisSourceBindingContract(sources);
     return {
         id: "analyze-inputs-pi",
         depends_on: [],
@@ -2433,14 +2475,19 @@ function buildAnalyzeInputsNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Pure Backend Test Analysis v1 JSON object matching docs/templates/backend-test-analysis.schema.json. No Markdown prose and no file writes.",
+        outputContract: "Pure Backend Test Analysis v2 JSON object matching docs/templates/backend-test-analysis.schema.json. No Markdown prose and no file writes.",
         subtask_prompt: [
-            "Read the task source materials and return exactly one JSON object matching Backend Test Analysis v1.",
+            "Read the task source materials and return exactly one JSON object matching Backend Test Analysis v2.",
             "Do not wrap it in explanatory prose. A single fenced json block is tolerated, but pure JSON is preferred.",
-            "Copy taskId, requirementPath, requirementSha256, referencePaths, and requirementIds exactly from the DAG source binding shown below.",
-            "Preserve existing AC IDs. Do not invent endpoint methods, paths, fields, errors, boundaries, or business rules; record unknowns in evidenceGaps.",
+            "Copy the sourceBinding object exactly from the JSON block below; do not infer, add, remove, or reclassify source paths.",
+            "Only kind=reference sources belong in referencePaths; kind=constraint sources MUST NOT be included in referencePaths.",
+            "## Exact Backend Test Analysis sourceBinding JSON",
+            JSON.stringify(sourceBindingContract, null, 2),
+            "For every endpoint, explicitly set responseBody.kind=array|object|scalar|empty|unknown and ordering=specified|unspecified|not-applicable. Add itemSchemaRef for arrays when documented.",
+            "For response fields, use comparison=exact|parseable-only|semantic when the source defines assertion semantics; date-time fields whose precision is unspecified should use parseable-only, not string equality.",
+            "Endpoint sourceRefs and field sourceRefs must cite only requirement/reference evidence actually read. Empty sourceRefs are allowed only when normalizing legacy v1 input; newly generated v2 should cite evidence.",
             "Use empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.",
-            "Required top-level keys: schemaVersion, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.",
+            "Required top-level keys: schemaVersion=2, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.",
             "Read-only: do not modify code, docs, artifacts, or repository files.",
             buildSourceContextBlock(sources),
         ].join("\n\n"),
@@ -2456,13 +2503,13 @@ function buildBackendTestAnalysisContractGateNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Validated run-owned Backend Test Analysis v1 artifact pointer, schema ID, and SHA-256.",
+        outputContract: "Validated run-owned Backend Test Analysis v2 artifact pointer, schema ID, and SHA-256 (legacy v1 input is normalized to v2).",
         subtask_prompt: "Materialize and validate the backend-test analysis contract under the current DAG run.",
         shell: {
             commands: [],
             jsonArtifactGate: {
                 fromNodeId: "analyze-inputs-pi",
-                schemaId: "backend-test-analysis-v1",
+                schemaId: "backend-test-analysis-v2",
                 artifactName: "backend-test-analysis.json",
                 outputDir: "contracts",
             },
@@ -2489,11 +2536,12 @@ function buildBackendTestEnvironmentScoutNode(sources) {
             "Discover only non-secret evidence: pytest config files (pytest.ini / pyproject.toml / setup.cfg test paths), candidate test roots, existing fixtures/clients, documented run commands, and env *names* (not values).",
             "Do NOT search the whole repo for secrets, .env values, tokens, private keys, or production credentials.",
             'framework must be "pytest". Default targetMode to "in-process" unless evidence clearly shows an external service base URL env name or documented managed start/stop with sourceRef.',
-            'Do NOT select targetMode "managed-command" unless task source documents a safe start/stop command with an explicit sourceRef; otherwise leave managedCommand absent and record the gap in evidenceGaps.',
+            'Do NOT select targetMode "managed-command" unless task source documents a safe start/stop command with an explicit sourceRef; otherwise leave managedCommand absent (do not invent managed mode). For external-running-service, missing managed start/stop is expected and is NOT an evidenceGap.',
             "testRoot and workingDirectory must be repo-relative posix paths without .. or absolute form. Adapter default testRoot is testcase when evidence is incomplete.",
             "runner must not include secret values. report.format must be junit with a relativeHint under the run (e.g. reports/backend-test-junit.xml).",
             "requiredEnvNames lists env NAMES only. baseUrlEnvName is required only for external-running-service and must match ^[A-Z_][A-Z0-9_]*$.",
-            "Record incomplete discovery in evidenceGaps. Populate evidenceRefs with repo-relative paths actually read.",
+            "evidenceGaps are optional notes only. Do NOT list greenfield/expected-later items as gaps: missing test_*.py / conftest (generate-pytest will create them), missing pytest.ini when testRoot defaults to testcase/, projected schema under ai_workspace/** instead of docs/templates/**, or optional API_BASE_URL when a documented default base URL exists.",
+            "Prefer evidenceGaps: [] for MVP greenfield external pytest. Use evidenceGaps only for true blockers the later generate nodes cannot fix (e.g. no viable testRoot at all). Populate evidenceRefs with repo-relative paths actually read.",
             "Required top-level keys: schemaVersion, framework, runner, testRoot, workingDirectory, report, targetMode, existingFixtures, authenticationMode, requiredEnvNames, dataIsolation, evidenceGaps, evidenceRefs.",
             "Read-only: do not modify code, docs, artifacts, or repository files.",
             buildSourceContextBlock(sources),
@@ -2528,7 +2576,10 @@ function buildBackendTestExecutionContractGateNode(sources) {
 function buildGenerateBackendFunctionalCasesNode(sources) {
     return {
         id: "generate-backend-functional-cases-pi",
-        depends_on: ["backend-test-execution-contract-shell"],
+        depends_on: [
+            "backend-test-analysis-contract-shell",
+            "backend-test-execution-contract-shell",
+        ],
         role: "implementer",
         executor: "pi",
         toolProfile: "write",
@@ -2540,19 +2591,31 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
         // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
         // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
         subtask_prompt: [
-            "Read the validated structured artifact pointer from backend-test-analysis-contract-shell and generate cases only from that JSON contract.",
-            ,
+            "Read both validated run-owned contracts before generating functional cases:",
+            "- contracts/backend-test-analysis.json: authoritative requirements, AC IDs, endpoints, fields, rules, boundaries, risks, and evidence gaps.",
+            "- contracts/backend-test-execution.json: pytest target mode, base URL env name, readiness, fixtures, and data-isolation constraints.",
+            "Generate cases from the analysis contract; use the execution contract only to keep preconditions and automation feasibility realistic.",
+            "Do not proceed from the execution contract alone. Do not re-read source documents or fall back to free-form analysis.",
             "",
             "## Output Steps (do in order):",
             "1. First, output a brief summary: how many modules, how many cases planned per module",
             "2. Then write each test case file under testcase/md/",
             "",
             "## Format Rules:",
-            "- Each test case ID: BE-<MODULE>-<NNN> (e.g. BE-ORDER-001)",
+            "- Each test case ID: BE-<MODULE>-<NNN> (e.g. BE-ORDER-001) — always write the FULL id; never abbreviate as 002, 003 in matrices",
             "- Each file covers one module",
-            "- Case structure: ID, Title, Precondition, Steps, Expected Result",
+            "- Case structure: ID, Title, Acceptance Criteria, Business Rules, Precondition, Steps, Expected Result",
+            "- Every emitted case MUST declare at least one semantically applicable explicit AC-* under Acceptance Criteria; list BR-* separately under Business Rules",
+            "- If a BR-only scenario has no semantically valid in-scope AC, do not create a standalone case for it; record the limitation in the summary for the manifest evidenceGaps instead",
+            "- Never relabel a negative/boundary/BR-only behavior as AC-002 or another unrelated AC merely to make acIds non-empty",
             "- Map each case to acceptance criteria (AC-xxx)",
             "",
+            "## AC ↔ case consistency (CRITICAL — prevents review request-revision):",
+            "- Every AC-xxx listed on a case body MUST appear only on cases that truly exercise that AC",
+            "- Any AC-coverage matrix / summary table MUST list the same full BE-* case IDs that the case bodies claim — never 'all cases' / '全部用例' unless every case body maps that AC",
+            "- Prefer one primary BE-* case for suite-level ACs (e.g. AC-008 pytest exit 0) rather than tagging every case",
+            "- Out-of-scope ACs (Flyway, frontend e2e, mvn test, etc.) must NOT be claimed in MD; leave them for manifest evidenceGaps",
+            "",
             "## Coverage Requirements:",
             "- Positive paths: happy path for each acceptance criterion",
             "- Negative paths: error scenarios (invalid input, not found, state violations)",
@@ -2567,16 +2630,28 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
             "",
             "## Constraints:",
             "- Stay within writeSet: testcase/md/**",
-            "- Do NOT re-read source documents or fall back to free-form analysis — use the validated structured artifact only",
-            ,
+            "- Do NOT re-read source documents or fall back to free-form analysis; use the two validated run-owned contracts only",
             "- Do not write root artifacts/**",
         ].join("\n\n"),
     };
 }
-function buildEmitBackendCaseManifestNode(sources) {
+const BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS = [
+    "The final fenced JSON block is authoritative and MUST conform exactly to Backend Test Case Manifest v1.",
+    "Top-level keys MUST be exactly: schemaVersion, sourceBinding, cases, evidenceGaps, and optional coverageSummary. Set schemaVersion to numeric 1. Do NOT emit schemaId, manifestType, taskId, modules, acCoverage, brCoverage, dataIsolation, readiness, or other custom top-level keys.",
+    "Copy sourceBinding exactly from contracts/backend-test-analysis.json: taskId, requirementPath, requirementSha256, referencePaths, requirementIds. Preserve Unicode paths exactly; never replace characters in source/需求.md or other paths.",
+    "Each cases[] item MUST use exactly: caseId, non-empty acIds, title, category, automationStatus; optional endpointRef, ruleRefs, file, symbol, gapReason, evidenceRef. Do NOT use id, module, brIds, endpoint, or priority.",
+    "category MUST be exactly one of: positive, negative, boundary, state-transition, auth, timeout, concurrency, other.",
+    "Before pytest generation, set automationStatus=planned. Use generated only with both file and symbol. Use skipped or unsupported only with gapReason.",
+    "Each evidenceGaps[] item MUST use exactly: optional acId, optional caseId, required description, optional evidenceRef. Every gap requires at least acId or caseId. Do NOT use requirementId, relatedBrIds, or sourceRef.",
+    "Every case must map to at least one semantically applicable explicit AC-* in acIds. If no AC applies, omit that case and bind an evidence gap to the nearest applicable acId or caseId; never emit an unbound informational gap.",
+    "acIds MUST exactly match the explicit AC-* values in the written case body; do not infer ACs from Business Rules or summary matrices.",
+    "Use full BE-<MODULE>-<NNN> caseId strings. Do not invent coverage percentages; omit coverageSummary unless all deterministic counts are exact.",
+    "Minimal shape example: {\"schemaVersion\":1,\"sourceBinding\":{\"taskId\":\"...\",\"requirementPath\":\"source/需求.md\",\"requirementSha256\":\"<64 lowercase hex>\",\"referencePaths\":[],\"requirementIds\":[\"AC-001\"]},\"cases\":[{\"caseId\":\"BE-MODULE-001\",\"acIds\":[\"AC-001\"],\"title\":\"...\",\"category\":\"positive\",\"automationStatus\":\"planned\",\"evidenceRef\":\"testcase/md/module.md\"}],\"evidenceGaps\":[]}",
+].join("\n\n");
+function buildEmitBackendCaseManifestNode(sources, options) {
     return {
-        id: "emit-backend-case-manifest-pi",
-        depends_on: [
+        id: options?.id ?? "emit-backend-case-manifest-pi",
+        depends_on: options?.dependsOn ?? [
             "generate-backend-functional-cases-pi",
             "backend-test-analysis-contract-shell",
         ],
@@ -2589,20 +2664,17 @@ function buildEmitBackendCaseManifestNode(sources) {
         outputContract: "Pure Backend Test Case Manifest v1 JSON (schema docs/templates/backend-test-case-manifest.schema.json). No file writes; model must not write .harness/**.",
         subtask_prompt: [
             "Emit Backend Test Case Manifest v1 as pure JSON (or one fenced json block with no trailing text).",
+            BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS,
             "Read-only: use validated contracts/backend-test-analysis.json pointer + testcase/md/** only. Do not write repository files or .harness/**.",
-            "sourceBinding must match the analysis contract / DAG source binding exactly (taskId, requirementPath, requirementSha256, referencePaths, requirementIds).",
-            "For each functional case under testcase/md/: caseId BE-<MODULE>-<NNN>, acIds[], title, category, automationStatus.",
-            "After case generation (pre-pytest), default automationStatus=planned. Use skipped/unsupported only with gapReason. Use generated only when file+symbol already exist.",
-            "evidenceGaps: structured gaps for explicit AC-* that cannot be mapped to a case.",
-            "Do NOT invent coverage percentages. Optional coverageSummary must match deterministic counts (gate recomputes/validates).",
             "No secrets or credential-shaped fields.",
         ].join("\n\n"),
     };
 }
-function buildBackendTestCaseManifestGateNode(sources) {
+function buildBackendTestCaseManifestGateNode(sources, options) {
+    const fromNodeId = options?.fromNodeId ?? "emit-backend-case-manifest-pi";
     return {
-        id: "backend-test-case-manifest-shell",
-        depends_on: ["emit-backend-case-manifest-pi"],
+        id: options?.id ?? "backend-test-case-manifest-shell",
+        depends_on: options?.dependsOn ?? ["emit-backend-case-manifest-pi"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
@@ -2614,7 +2686,7 @@ function buildBackendTestCaseManifestGateNode(sources) {
         shell: {
             commands: [],
             jsonArtifactGate: {
-                fromNodeId: "emit-backend-case-manifest-pi",
+                fromNodeId,
                 schemaId: "backend-test-case-manifest-v1",
                 artifactName: "backend-test-case-manifest.json",
                 outputDir: "contracts",
@@ -2624,13 +2696,18 @@ function buildBackendTestCaseManifestGateNode(sources) {
         },
     };
 }
-function buildBackendTestTraceabilityGateNode(sources) {
+function buildBackendTestTraceabilityGateNode(sources, options = {}) {
     return {
-        id: "backend-test-traceability-gate-shell",
-        depends_on: [
+        id: options.id ?? "backend-test-traceability-gate-shell",
+        depends_on: options.dependsOn ?? [
             "generate-backend-pytest-pi",
+            // Effective Case Manifest v1 path (exclusive condition branches):
+            // pass → first manifest shell; request-revision → final manifest shell.
+            // Artifact path is always contracts/backend-test-case-manifest.json.
             "backend-test-case-manifest-shell",
+            "backend-test-case-manifest-final-shell",
         ],
+        dependsPolicy: "all-or-condition-skip",
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
@@ -2646,10 +2723,12 @@ function buildBackendTestTraceabilityGateNode(sources) {
         },
     };
 }
-function buildReviewBackendCasesNode(sources) {
+function buildReviewBackendCasesNode(sources, options) {
+    const phase = options?.phase ?? "first";
+    const isFinal = phase === "final";
     return {
-        id: "review-backend-cases-pi",
-        depends_on: [
+        id: options?.id ?? "review-backend-cases-pi",
+        depends_on: options?.dependsOn ?? [
             "backend-test-case-manifest-shell",
             "backend-test-analysis-contract-shell",
         ],
@@ -2659,21 +2738,25 @@ function buildReviewBackendCasesNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes.",
+        outputContract: isFinal
+            ? "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision after at most one revision; followed by Findings and Coverage Assessment. No file writes. Final gate accepts pass only."
+            : "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings, Coverage Assessment, and Required revisions when requesting revision. No file writes.",
         subtask_prompt: [
-            "Review the generated backend functional test cases under testcase/md/ and the validated Case Manifest v1.",
+            isFinal
+                ? "Final review of backend functional cases under testcase/md/ and the re-validated Case Manifest v1 after at most one revision pass."
+                : "Review the generated backend functional test cases under testcase/md/ and the validated Case Manifest v1.",
             "",
             "## Mandatory First Line:",
             "First non-empty line must be exactly: VERDICT: pass or VERDICT: request-revision",
             "",
             "## Review Checklist:",
-            "- ID format: every case uses BE-<MODULE>-<NNN>",
-            "- Positive coverage: each acceptance criterion (AC-xxx) has happy-path case",
+            "- ID format: every case uses BE-<MODULE>-<NNN> (full ids only in bodies and matrices)",
+            "- Positive coverage: each in-scope acceptance criterion (AC-xxx) has happy-path case",
             "- Negative coverage: error scenarios (invalid input, not found, state violations)",
-            "- Traceability: each AC maps to at least one case ID (prefer contracts/backend-test-case-manifest.json coverageSummary)",
+            "- Traceability: each explicit AC maps to a case ID or an evidenceGap in contracts/backend-test-case-manifest.json",
             "- Case structure: ID, Title, Precondition, Steps, Expected Result",
             "- No duplicate IDs across files",
-            "- Manifest consistency: MD cases align with manifest caseId/acIds; do not invent coverage %",
+            "- Manifest consistency (Critical): every AC claimed in MD case bodies/matrices must match manifest caseId→acIds; never accept 'all cases cover AC-xxx' unless every case maps that AC",
             "",
             "## Conditional Coverage (check ONLY if mentioned in upstream analysis):",
             "- Boundary coverage: check ONLY if analyze-inputs-pi mentions value ranges, length limits, numeric bounds, or format constraints",
@@ -2683,40 +2766,123 @@ function buildReviewBackendCasesNode(sources) {
             "- Concurrency coverage: check ONLY if analyze-inputs-pi mentions concurrency/idempotency rules",
             "- If not mentioned, do NOT flag as missing",
             "",
+            "## Do NOT treat as Critical alone:",
+            "- Missing test_*.py / automation still planned (expected before generate-backend-pytest-pi)",
+            "- Out-of-scope ACs already listed in manifest evidenceGaps (Flyway, frontend e2e, mvn test)",
+            "",
             "## Verdict Rules:",
             "- All Critical checks pass + Important findings ≤ 2 → VERDICT: pass",
             "- Any Critical fails OR Important > 2 → VERDICT: request-revision",
+            isFinal
+                ? "- This is the FINAL review after one revision opportunity; remaining Critical issues must still request-revision (final gate will stop the DAG)."
+                : "- When requesting revision, list numbered Required revisions concrete enough for revise-backend-cases-pi to edit testcase/md/**.",
             "",
             "## Output After Verdict:",
-            "1. Coverage Assessment table (AC → case IDs) using manifest + MD",
+            "1. Coverage Assessment table (AC → full BE-* case IDs) using manifest + MD",
             "2. Findings list (Critical/Important/Informational)",
             "3. Statistics (total cases, positive/negative/boundary breakdown)",
+            isFinal ? "" : "4. Required revisions (only when request-revision)",
             "",
             "## Constraints:",
             "- Read-only: do not modify files",
             "- Read validated analysis + case manifest artifacts; do not recompute coverage percentages",
             "- Use testcase/md/ files for case review",
+        ]
+            .filter((line) => line !== "")
+            .join("\n\n"),
+    };
+}
+function buildReviewBackendCasesBranchConditionNode(sources) {
+    return {
+        id: "review-backend-cases-branch-condition",
+        depends_on: ["review-backend-cases-pi"],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Dynamic condition: select direct pass vs single revision chain from first review firstVerdictLine; malformed VERDICT fails closed (no default). The pass target is the already-finished first review, so the effective gate remains outside the exclusive branch targets.",
+        subtask_prompt: "Branch on review-backend-cases-pi VERDICT: pass → already-finished first review (revision chain skipped); request-revision → revise-backend-cases-pi.",
+        static: {
+            resultMarkdown: "Backend case review branch condition (direct pass vs single revision).",
+        },
+        dynamicCondition: {
+            workflowNodeId: "review-backend-cases-branch-condition",
+            cases: [
+                {
+                    when: "$.nodes['review-backend-cases-pi'].firstVerdictLine == 'VERDICT: pass'",
+                    then: "review-backend-cases-pi",
+                },
+                {
+                    when: "$.nodes['review-backend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                    then: "revise-backend-cases-pi",
+                },
+            ],
+        },
+    };
+}
+function buildReviseBackendCasesNode(sources) {
+    return {
+        id: "revise-backend-cases-pi",
+        depends_on: ["review-backend-cases-branch-condition"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Only scheduled when first review is VERDICT: request-revision. Apply Required revisions under testcase/md/** then summarize changes (single revision pass).",
+        subtask_prompt: [
+            "You are the single backend case revision pass (max one per DAG run).",
+            "This node is only scheduled when review-backend-cases-pi emitted VERDICT: request-revision.",
+            "",
+            "## Inputs",
+            "- First review: review-backend-cases-pi Markdown (VERDICT + Findings + Required revisions)",
+            "- Current cases: testcase/md/**",
+            "- Validated analysis + case manifest under the current run contracts/",
+            "",
+            "## Required work",
+            "1. Edit only testcase/md/** to address every Critical finding and Required revision item",
+            "2. Fix AC matrices to list FULL BE-* ids matching case bodies; remove false 'all cases' AC claims",
+            "3. Keep BE-<MODULE>-<NNN> ids stable when possible; do not invent out-of-scope AC coverage",
+            "4. Stay within writeSet; do not write pytest or production code",
+            "5. End with a short summary of files touched",
+            "",
+            "Downstream will re-emit and re-validate Case Manifest v1, then run a FINAL review (pass-only gate).",
         ].join("\n\n"),
     };
 }
 function buildReviewBackendCasesGateNode(sources) {
     return {
         id: "review-backend-cases-gate-shell",
-        depends_on: ["review-backend-cases-pi"],
+        // OR-join tips: pass-path barrier vs final review after one revise.
+        // Soft condition-skip on the unused tip still allows the gate to run.
+        depends_on: [
+            "review-backend-cases-branch-condition",
+            "review-backend-cases-final-pi",
+            // Always finished; also required for verdictGate.fallbackFromNodeIds validate.
+            "review-backend-cases-pi",
+        ],
+        dependsPolicy: "all-or-condition-skip",
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Deterministic backend case review gate: exit 0 only when review-backend-cases-pi emits VERDICT: pass.",
-        subtask_prompt: "Deterministic gate: block pytest generation unless backend case review emitted VERDICT: pass.",
+        outputContract: "Deterministic backend case review gate: exit 0 only when the effective review emits VERDICT: pass (sole authorization for generate-backend-pytest-pi). Prefers final review JSON when present (revision path); else first review (pass path).",
+        subtask_prompt: "Deterministic gate: block pytest generation unless the effective backend case review (final after revision, else first) emitted VERDICT: pass.",
         shell: {
             commands: [],
             verdictGate: {
-                fromNodeId: "review-backend-cases-pi",
+                // Prefer final (revision path) when its artifact exists; fall back to first review.
+                fromNodeId: "review-backend-cases-final-pi",
+                fallbackFromNodeIds: ["review-backend-cases-pi"],
                 accept: ["VERDICT: pass"],
-                label: "backend case review",
+                label: "backend case effective review",
                 lineMode: "first-verdict-line",
             },
             cwd: ".",
@@ -2845,7 +3011,149 @@ function buildGenerateBackendPytestNode(sources) {
         ].join("\n\n"),
     };
 }
-function buildExecuteBackendPytestNode(sources) {
+function buildBackendTestSemanticReviewNode(sources, options = {}) {
+    const final = options.final ?? false;
+    return {
+        id: options.id ?? "review-generated-backend-pytest-pi",
+        depends_on: options.dependsOn ?? [
+            "generate-backend-pytest-pi",
+            "backend-test-analysis-contract-shell",
+            "backend-test-case-manifest-shell",
+            "backend-test-case-manifest-final-shell",
+        ],
+        dependsPolicy: "all-or-condition-skip",
+        role: "reviewer",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: ["testcase/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure Backend Test Semantic Review v1 JSON: verdict, findings[], summary. No file writes.",
+        subtask_prompt: [
+            final ? "Final semantic review after the single generated-pytest revision." : "Review generated pytest semantics before the first execution.",
+            "Use only compact authoritative inputs: contracts/backend-test-analysis.json, contracts/backend-test-case-manifest.json, testcase/md/**, and generated testcase/**/test_*.py/helpers/factories.",
+            "Return exactly one pure JSON object with only verdict, findings, summary; no Markdown fence or surrounding prose.",
+            "verdict must be pass or request-revision. Each findings[] item must contain exactly severity, caseId, testFile, testSymbol, contractRefs, issue, requiredChange.",
+            "severity must be exactly Critical, Important, or Informational; contractRefs must be a non-empty string array. A request-revision verdict requires at least one finding; pass must not contain Critical findings.",
+            "Minimal shape: {\"verdict\":\"pass\",\"findings\":[],\"summary\":\"No contract-backed semantic contradiction found.\"}",
+            "Check responseBody.kind (array vs object/items), ordering, field comparison (especially parseable-only date-time precision), documented status/error fields, and each caseId→symbol assertion meaning.",
+            "Do not use aliases such as file, symbol, refs, finding, or requiredFix; the strict contract requires testFile, testSymbol, contractRefs, issue, requiredChange.",
+            "request-revision only for concrete semantic contradiction with reviewed cases/formal analysis evidence. No style findings.",
+            "Read-only; do not edit tests or production code.",
+        ].join("\n\n"),
+    };
+}
+function buildBackendTestSemanticReviewGateNode(sources, options = {}) {
+    const fromNodeId = options.fromNodeId ?? "review-generated-backend-pytest-pi";
+    return {
+        id: options.id ?? "backend-test-semantic-review-shell",
+        depends_on: options.dependsOn ?? [fromNodeId],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Semantic Review v1 artifact.",
+        subtask_prompt: "Validate semantic review JSON before branch selection.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId,
+                schemaId: "backend-test-semantic-review-v1",
+                artifactName: options.id?.includes("final") ? "backend-test-semantic-review-final.json" : "backend-test-semantic-review.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildBackendTestSemanticReviewConditionNode(sources) {
+    return {
+        id: "backend-test-semantic-review-condition",
+        depends_on: ["backend-test-semantic-review-shell"],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Select direct semantic pass or one testcase-only revision; the pass target is the already-finished validated semantic review so the final gate remains outside the exclusive branch targets.",
+        subtask_prompt: "Branch deterministically from semantic review verdict.",
+        static: { resultMarkdown: "Backend pytest semantic review selector." },
+        dynamicCondition: {
+            workflowNodeId: "backend-test-semantic-review-condition",
+            cases: [
+                { when: "$.nodes['backend-test-semantic-review-shell'].json.verdict == 'pass'", then: "backend-test-semantic-review-shell" },
+            ],
+            default: "revise-generated-backend-pytest-pi",
+        },
+    };
+}
+function buildReviseGeneratedBackendPytestNode(sources) {
+    const writeSet = ["testcase/**/test_*.py", "testcase/**/helpers/**", "testcase/**/factories/**"];
+    return {
+        id: "revise-generated-backend-pytest-pi",
+        depends_on: ["backend-test-semantic-review-condition"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet,
+        allowedPaths: writeSet,
+        forbiddenPaths: [...commonForbiddenPaths(sources), "apps/**", "src/**", "testcase/md/**", "**/conftest.py", "**/pytest.ini"],
+        outputContract: "Apply one bounded semantic correction to generated pytest from validated findings only.",
+        subtask_prompt: [
+            "This is the only pre-execution generated-pytest semantic revision (1/1).",
+            "Read contracts/backend-test-semantic-review.json and edit only the cited generated test files/helpers/factories.",
+            "Preserve case IDs, symbols, test count, target mode, base URL and real-service path.",
+            "Do not delete tests, add skip/xfail, swallow failures, substitute mocks, or weaken assertions beyond the formal comparison/shape contract.",
+            "Do not modify product code, testcase/md/**, conftest.py, pytest.ini, or .harness/**.",
+        ].join("\n\n"),
+    };
+}
+function buildBackendTestSemanticFinalGateNode(sources) {
+    return {
+        id: "backend-test-semantic-final-gate-shell",
+        depends_on: ["backend-test-semantic-review-condition", "backend-test-semantic-review-final-shell"],
+        dependsPolicy: "all-or-condition-skip",
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pass-only semantic authorization for traceability and initial pytest.",
+        subtask_prompt: "Accept initial pass path or final semantic review pass; fail closed otherwise.",
+        shell: {
+            commands: [[
+                    'test -n "${HARNESS_DAG_RUN_DIR:-}" || exit 2',
+                    'node -e \'const fs=require("fs"),path=require("path");const r=process.env.HARNESS_DAG_RUN_DIR;const final=path.join(r,"contracts","backend-test-semantic-review-final.json");const first=path.join(r,"contracts","backend-test-semantic-review.json");const p=fs.existsSync(final)?final:first;const v=JSON.parse(fs.readFileSync(p,"utf8"));if(v.verdict!=="pass")throw new Error("backend pytest semantic review did not pass");console.log("backend pytest semantic gate: pass");\'',
+                ].join("; ")],
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function collectBackendTestShellEnvAllowlist(sources) {
+    const names = new Set();
+    for (const verify of sources.taskConfig.verifyCommands) {
+        const assignmentPattern = /(?:^|[\s;&|])([A-Z_][A-Z0-9_]*)\s*=/g;
+        for (const match of verify.command.matchAll(assignmentPattern)) {
+            if (match[1])
+                names.add(match[1]);
+        }
+    }
+    return [...names].sort();
+}
+function taskAllowsBackendTestReportWrite(sources) {
+    return sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" ||
+        pattern === "docs/**" ||
+        pattern === "**");
+}
+function buildExecuteBackendPytestNode(sources, options = {}) {
     // Keep the target worktree read-only: JUnit is runner-owned evidence under
     // the current DAG run and moves with active → completed/paused lifecycle.
     // Adapter default testRoot is frozen at DAG generation time (auditable) and
@@ -2856,12 +3164,16 @@ function buildExecuteBackendPytestNode(sources) {
     });
     // Map pytest exit 0/1 → node success ONLY when JUnit exists (assertion-fail is a
     // legal result). Do not change global shell ok semantics. Persist raw exit for parse.
+    const nodeId = options.id ?? "execute-backend-pytest-shell";
+    const reportStem = options.reportStem ?? "backend-test";
+    const reportName = `${reportStem}-junit.xml`;
+    const exitName = `${reportStem}-pytest-exit.txt`;
     const pytestCommand = [
         preflightCommand,
-        'REPORT="${HARNESS_DAG_RUN_DIR}/reports/backend-test-junit.xml"',
-        'EXIT_FILE="${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
+        `REPORT="\${HARNESS_DAG_RUN_DIR}/reports/${reportName}"`,
+        `EXIT_FILE="\${HARNESS_DAG_RUN_DIR}/reports/${exitName}"`,
         'mkdir -p "$(dirname "${REPORT}")"',
-        `PYTHONDONTWRITEBYTECODE=1 python -m pytest ${frozenTestRoot}/ -v -p no:cacheprovider --junitxml="\${REPORT}"`,
+        `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest ${frozenTestRoot}/ -v -p no:cacheprovider --junitxml="\${REPORT}"`,
         "STATUS=$?",
         'printf "%s" "${STATUS}" > "${EXIT_FILE}"',
         'printf "JUnit report: %s\\n" "${REPORT}"',
@@ -2870,9 +3182,9 @@ function buildExecuteBackendPytestNode(sources) {
         'exit "${STATUS}"',
     ].join("; ");
     return {
-        id: "execute-backend-pytest-shell",
-        depends_on: [
-            "backend-test-traceability-gate-shell",
+        id: nodeId,
+        depends_on: options.dependsOn ?? [
+            "backend-test-semantic-final-gate-shell",
             "backend-test-execution-contract-shell",
         ],
         role: "verifier",
@@ -2885,6 +3197,7 @@ function buildExecuteBackendPytestNode(sources) {
         subtask_prompt: "Run pytest for the backend test suite; write JUnit + pytestExitCode evidence only under the current HARNESS_DAG_RUN_DIR/reports/.",
         shell: {
             commands: [pytestCommand],
+            envAllowlist: collectBackendTestShellEnvAllowlist(sources),
             verifyEvidence: buildVerifyEvidence({
                 phase: "final",
                 quota: "full",
@@ -2897,10 +3210,13 @@ function buildExecuteBackendPytestNode(sources) {
         },
     };
 }
-function buildParseBackendTestResultNode(sources) {
+function buildParseBackendTestResultNode(sources, options = {}) {
+    const id = options.id ?? "parse-backend-test-result-shell";
+    const fromNodeId = options.fromNodeId ?? "execute-backend-pytest-shell";
+    const artifactName = options.artifactName ?? "backend-test-result.json";
     return {
-        id: "parse-backend-test-result-shell",
-        depends_on: ["execute-backend-pytest-shell"],
+        id,
+        depends_on: options.dependsOn ?? [fromNodeId],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
@@ -2912,10 +3228,13 @@ function buildParseBackendTestResultNode(sources) {
         shell: {
             commands: [],
             jsonArtifactGate: {
-                fromNodeId: "execute-backend-pytest-shell",
+                fromNodeId,
                 schemaId: "backend-test-result-v1",
-                artifactName: "backend-test-result.json",
+                artifactName,
                 outputDir: "contracts",
+                ...(options.junitRelativePath
+                    ? { junitRelativePath: options.junitRelativePath }
+                    : {}),
             },
             cwd: ".",
             timeoutMs: 60000,
@@ -2925,7 +3244,7 @@ function buildParseBackendTestResultNode(sources) {
 function buildClassifyBackendTestResultNode(sources) {
     return {
         id: "classify-backend-test-result-pi",
-        depends_on: ["parse-backend-test-result-shell"],
+        depends_on: ["parse-backend-test-result-initial-shell"],
         role: "reviewer",
         executor: "pi",
         complexity: "MED",
@@ -2936,7 +3255,9 @@ function buildClassifyBackendTestResultNode(sources) {
         subtask_prompt: [
             "Read-only classifier for Backend Test Result v1.",
             "Return exactly one JSON object (prefer pure JSON; single fenced json block tolerated; no trailing prose).",
-            "Read contracts/backend-test-result.json (run-owned Result v1). Do NOT invent pass rates from raw logs.",
+            "The object must contain exactly category, evidence, confidence, notes. evidence must be a non-empty array of strings, confidence must be a number from 0 through 1, and notes must be a non-empty string. Do not emit schemaVersion or custom fields.",
+            "Minimal shape: {\"category\":\"Unknown\",\"evidence\":[\"outcome=completed-with-failures\"],\"confidence\":0.5,\"notes\":\"Single-run evidence is insufficient for a stronger classification.\"}",
+            "Read contracts/backend-test-result-initial.json (run-owned initial Result v1). Do NOT invent pass rates from raw logs.",
             "category must be one of: ProductBug, TestBug, EnvFailure, ContractMismatch, FlakyTest, Unknown.",
             "Hard constraints:",
             "- Single-run failure MUST NOT use FlakyTest (use Unknown, TestBug, or ProductBug).",
@@ -2948,24 +3269,187 @@ function buildClassifyBackendTestResultNode(sources) {
         ].join("\n\n"),
     };
 }
+function buildBackendTestClassificationGateNode(sources) {
+    return {
+        id: "backend-test-classification-shell",
+        depends_on: ["classify-backend-test-result-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Classification v1 at contracts/backend-test-classification.json.",
+        subtask_prompt: "Validate and materialize the read-only backend-test classification for deterministic repair routing.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "classify-backend-test-result-pi",
+                schemaId: "backend-test-classification-v1",
+                artifactName: "backend-test-classification.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildBackendTestRepairEligibilityNode(sources) {
+    const command = buildBackendTestRepairEligibilityShellSnippet();
+    return {
+        id: "backend-test-repair-eligibility-shell",
+        depends_on: ["backend-test-classification-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure JSON {schemaVersion,eligible,reason,revisionAttempt,category,confidence}; eligible only for completed TestBug assertion failures with error=0.",
+        subtask_prompt: "Deterministically decide whether this run may use its single testcase-only repair attempt.",
+        shell: { commands: [command], cwd: ".", timeoutMs: 60000 },
+    };
+}
+function buildBackendTestRepairConditionNode(sources) {
+    return {
+        id: "backend-test-repair-condition",
+        depends_on: ["backend-test-repair-eligibility-shell"],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Select repair or skip repair exactly once; ineligible runs select the already-finished eligibility evidence so the effective-result shell remains outside the exclusive branch targets.",
+        subtask_prompt: "Route eligible TestBug to one repair attempt; otherwise select the already-finished eligibility evidence and skip repair.",
+        static: { resultMarkdown: "Backend-test repair branch selector." },
+        dynamicCondition: {
+            workflowNodeId: "backend-test-repair-condition",
+            cases: [
+                {
+                    when: "$.nodes['backend-test-repair-eligibility-shell'].json.eligible == true",
+                    then: "repair-backend-pytest-pi",
+                },
+            ],
+            default: "backend-test-repair-eligibility-shell",
+        },
+    };
+}
+function buildRepairBackendPytestNode(sources) {
+    const writeSet = [
+        "testcase/**/test_*.py",
+        "testcase/**/helpers/**",
+        "testcase/**/factories/**",
+    ];
+    return {
+        id: "repair-backend-pytest-pi",
+        depends_on: ["backend-test-repair-condition"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet,
+        allowedPaths: writeSet,
+        forbiddenPaths: [
+            ...commonForbiddenPaths(sources),
+            "apps/**",
+            "src/**",
+            ".env*",
+            "**/migrations/**",
+        ],
+        outputContract: "Repair only existing generated pytest tests/helpers/factories for classified TestBug findings. No production/config/runtime evidence writes.",
+        subtask_prompt: [
+            "This is the only automatic TestBug repair attempt (1/1).",
+            "Read contracts/backend-test-result-initial.json, contracts/backend-test-classification.json, contracts/backend-test-analysis.json, contracts/backend-test-case-manifest.json, and only the generated pytest files named in failures[].name or manifest mappings.",
+            "Do not re-read the full task source tree: the run-owned analysis/manifest are the compact authoritative context.",
+            "Repair only test implementation defects directly supported by reviewed Expected Results or formal API contract evidence.",
+            "Never modify product code, migrations, service configuration, conftest.py, pytest.ini, pyproject.toml, setup.cfg, source requirements, testcase/md/**, or .harness/**.",
+            "Never delete a test, remove a case mapping, add skip/skipif/xfail, swallow AssertionError/network exceptions, switch to a mock server, or weaken documented status/value assertions.",
+            "Keep the full suite runnable and preserve each BE-* case ID and pytest symbol mapping.",
+            "Stay within writeSet: testcase/**/test_*.py, helpers/**, factories/**.",
+        ].join("\n\n"),
+    };
+}
+function buildBackendTestRepairSafetyGateNode(sources) {
+    const command = buildBackendTestRepairSafetyShellSnippet();
+    return {
+        id: "backend-test-repair-safety-gate-shell",
+        depends_on: ["repair-backend-pytest-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ["testcase/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Fail-closed repair safety gate rejecting skip/xfail and broad failure swallowing before final traceability and pytest.",
+        subtask_prompt: "Check that automatic TestBug repair did not manufacture success.",
+        shell: { commands: [command], cwd: ".", timeoutMs: 60000 },
+    };
+}
+function buildBackendTestEffectiveResultNode(sources) {
+    const command = buildBackendTestEffectiveResultSelectorShellSnippet();
+    // Inline retrospective context: relocated verbatim from the former
+    // buildBackendTestRetrospectiveContextNode so test-retrospect-pi keeps a
+    // single upstream. Runs after `command` which materializes
+    // contracts/backend-test-result.json from the effective (final|initial) result.
+    const retroCommand = [
+        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend-test retrospective context" >&2; exit 2; }',
+        'node -e \'const fs=require("fs"),path=require("path"); const root=process.env.HARNESS_DAG_RUN_DIR; const read=(name)=>JSON.parse(fs.readFileSync(path.join(root,"contracts",name),"utf8")); process.stdout.write(JSON.stringify({schemaVersion:1,result:read("backend-test-result.json"),initialResult:read("backend-test-result-initial.json"),finalResult:fs.existsSync(path.join(root,"contracts","backend-test-result-final.json"))?read("backend-test-result-final.json"):null,manifest:read("backend-test-case-manifest.json"),classification:read("backend-test-classification.json")},null,2));\'',
+    ].join("; ");
+    return {
+        id: "select-effective-backend-test-result-shell",
+        depends_on: [
+            "backend-test-repair-condition",
+            "parse-backend-test-result-final-shell",
+            "backend-test-case-manifest-shell",
+            "backend-test-case-manifest-final-shell",
+            "backend-test-classification-shell",
+        ],
+        dependsPolicy: "all-or-condition-skip",
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Materialize contracts/backend-test-result.json from final result when present, otherwise initial result; emit effective result metadata, and emit the complete retrospective context (Result v1 + Case Manifest v1 + classifier output) for downstream retrospective consumption.",
+        subtask_prompt: "Select the effective backend-test result deterministically without changing initial/final evidence, then emit the complete retrospective context.",
+        shell: { commands: [command, retroCommand], cwd: ".", timeoutMs: 60000 },
+    };
+}
 function buildTestRetrospectNode(sources) {
+    const canWriteReport = taskAllowsBackendTestReportWrite(sources);
     return {
         id: "test-retrospect-pi",
-        depends_on: ["classify-backend-test-result-pi"],
+        depends_on: ["select-effective-backend-test-result-shell"],
         role: "closeout",
         executor: "pi",
-        toolProfile: "write",
         complexity: "MED",
-        writePolicy: "exclusive",
-        writeSet: ["docs/test-reports/**"],
-        allowedPaths: ["docs/test-reports/**"],
+        ...(canWriteReport
+            ? {
+                toolProfile: "write",
+                writePolicy: "exclusive",
+                writeSet: ["docs/test-reports/**"],
+                allowedPaths: ["docs/test-reports/**"],
+            }
+            : {
+                writePolicy: "read-only",
+                allowedPaths: commonReadOnlyPaths(sources),
+            }),
         forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: canWriteReport
+            ? "Maturity rating in assistant output plus a report written under docs/test-reports/**."
+            : "Read-only maturity rating and retrospective in assistant output; no repository file writes because task allowedPaths do not authorize docs/test-reports/**.",
         subtask_prompt: [
-            "Read upstream Result v1 + Case Manifest coverageSummary + classification and generate a test retrospective report.",
+            "Read the complete JSON from direct upstream select-effective-backend-test-result-shell and generate a test retrospective report.",
+            "That JSON contains result, manifest (including coverageSummary), and classification. Treat those fields as authoritative; do not rely on pointer/hash summaries.",
             "",
             "## Output Steps (do in order):",
             "1. First, output the maturity rating on the first line: Rating: A/B/C/D",
-            "2. Then write the full report under docs/test-reports/",
+            canWriteReport
+                ? "2. Then write the full report under docs/test-reports/"
+                : "2. Keep the full retrospective in assistant output only; do not write repository files because docs/test-reports/** is outside task allowedPaths.",
             "",
             "## Stats authority (deterministic only):",
             "- Pass rate, failed/error/skipped counts, and failure list MUST come from contracts/backend-test-result.json only.",
@@ -2987,7 +3471,9 @@ function buildTestRetrospectNode(sources) {
             "- D: below C thresholds",
             "",
             "## Constraints:",
-            "- Stay within writeSet: docs/test-reports/**",
+            canWriteReport
+                ? "- Stay within writeSet: docs/test-reports/**"
+                : "- Read-only: do not modify repository files",
             "- Do NOT re-read source documents — use upstream outputs only",
             "- Do not write root artifacts/**",
         ].join("\n\n"),
@@ -3034,63 +3520,73 @@ const BACKEND_TEST_SKILLS_BY_ROLE = {
 };
 function buildBackendTestHybridDag(sources) {
     const { taskConfig } = sources;
-    const sourceContext = buildSourceContextBlock(sources);
-    const readOnlyPaths = commonReadOnlyPaths(sources);
-    const forbiddenPaths = commonForbiddenPaths(sources);
     const globalConstraints = [
         ...taskConfig.hardConstraints,
-        ...(sources.constraintMarkdown
-            ? [`See 执行约束.md in task source (${sources.taskId})`]
-            : []),
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "backend-test-dag nodes must maintain traceability from requirements to functional cases to pytest automation.",
+        "backend-test-dag uses exactly 24 real top-level tasks; bounded revision/repair branches are controlled by fail-closed runIf expressions.",
+        "Analysis, execution, manifest, semantic review, initial/final/effective results, classification, eligibility, repair safety, traceability and outcome evidence remain run-owned and fail-closed.",
         "Functional test case IDs must use BE-<MODULE>-<NNN> format.",
-        "pytest execution must keep the target worktree read-only and write machine-readable results only under the current HARNESS_DAG_RUN_DIR/reports/** (e.g. JUnit XML).",
-        "pytest automation scripts must use test_ filename prefix for pytest discovery.",
-        "generate-backend-pytest-pi may create only new files under testcase/**/test_*.py, testcase/**/helpers/**, and testcase/**/factories/**; modifying conftest.py, pytest.ini, pyproject.toml, or production code is forbidden.",
-        "review-backend-cases-gate-shell must block pytest generation unless the review verdict is exactly VERDICT: pass.",
-        "If a target test filename already exists under testcase/, add a numeric suffix (_01, _02, ...); never overwrite or append to existing files.",
-        "execute-backend-pytest-shell must not modify test assertions or production code to make tests pass; test failures indicate potential implementation issues and must be reported honestly.",
-        "parse-backend-test-result-shell materializes Backend Test Result v1 from JUnit + pytestExitCode; classify/retrospect run on pass and assertion-fail; backend-test-outcome-gate-shell uses result.outcome only.",
-        "backend-test-case-manifest-shell validates schemaId backend-test-case-manifest-v1 and materializes contracts/backend-test-case-manifest.json; AC coverage is fail-closed and deterministic.",
-        "backend-test-traceability-gate-shell verifies generated file/symbol existence after pytest generation and before execute; models must not invent coverage percentages.",
+        "pytest writers may only change declared testcase assets; production code, config, skip/xfail, swallowed failures and mock substitution are forbidden.",
     ];
-    const spec = {
-        version: 3,
-        title: `Backend test DAG: ${taskConfig.title}`,
-        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
-        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
-        objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
-        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
-        globalConstraints,
-        // No convergence loop: review gate is fail-closed. request-revision stops
-        // the DAG; regenerate after fixing cases. Controller still keys off
-        // hard-verify-shell, which this template does not include.
-        defaults: {
-            ...BACKEND_TEST_DEFAULTS,
-            contextProfile: taskConfig.contextProfile,
-        },
-        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
-        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        tasks: [
-            buildAnalyzeInputsNode(sources),
-            buildBackendTestAnalysisContractGateNode(sources),
-            buildBackendTestEnvironmentScoutNode(sources),
-            buildBackendTestExecutionContractGateNode(sources),
-            buildGenerateBackendFunctionalCasesNode(sources),
-            buildEmitBackendCaseManifestNode(sources),
-            buildBackendTestCaseManifestGateNode(sources),
-            buildReviewBackendCasesNode(sources),
-            buildReviewBackendCasesGateNode(sources),
-            buildGenerateBackendPytestNode(sources),
-            buildBackendTestTraceabilityGateNode(sources),
-            buildExecuteBackendPytestNode(sources),
-            buildParseBackendTestResultNode(sources),
-            buildClassifyBackendTestResultNode(sources),
-            buildTestRetrospectNode(sources),
-            buildBackendTestOutcomeGateNode(sources),
-        ],
+    const analyze = buildAnalyzeInputsNode(sources);
+    analyze.id = "analyze-and-discover-backend-test-pi";
+    analyze.outputContract = "Pure JSON envelope {analysis: Backend Test Analysis v2, execution: Backend Test Execution Contract v1}; no prose or writes.";
+    analyze.subtask_prompt = `${analyze.subtask_prompt}\n\nAlso perform the read-only environment discovery described by Backend Test Execution Contract v1. Return exactly one JSON envelope with top-level keys analysis and execution; analysis must satisfy v2 and execution must satisfy v1.`;
+    const contracts = {
+        id: "validate-backend-test-contracts-shell", depends_on: [analyze.id], role: "verifier", executor: "shell", complexity: "LOW",
+        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Materialize and validate contracts/backend-test-analysis.json and contracts/backend-test-execution.json.",
+        subtask_prompt: "Validate both backend-test intake contracts fail-closed.", shell: { commands: [], backendTestPipeline: "contracts", cwd: ".", timeoutMs: 60000 },
     };
+    const generateCases = buildGenerateBackendFunctionalCasesNode(sources);
+    generateCases.id = "generate-backend-cases-and-manifest-pi";
+    generateCases.depends_on = [contracts.id];
+    generateCases.outputContract = "Write testcase/md/** and end with one fenced json Backend Test Case Manifest v1 block matching the strict field contract.";
+    generateCases.subtask_prompt += `\n\nAfter writing Markdown, end assistant output with exactly one fenced json block containing Backend Test Case Manifest v1 derived from the written cases.\n\n${BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS}`;
+    const manifest = buildBackendTestCaseManifestGateNode(sources, { dependsOn: [generateCases.id], fromNodeId: generateCases.id });
+    const reviewCases = buildReviewBackendCasesNode(sources, { dependsOn: [manifest.id, contracts.id] });
+    const reviseCases = buildReviseBackendCasesNode(sources);
+    reviseCases.depends_on = [reviewCases.id];
+    reviseCases.runIf = "$.nodes['review-backend-cases-pi'].firstVerdictLine == 'VERDICT: request-revision'";
+    reviseCases.outputContract = "Apply one case revision and end with one fenced json final Case Manifest v1 block matching the strict field contract.";
+    reviseCases.subtask_prompt += `\n\nAfter edits, end assistant output with exactly one fenced json block containing the complete final Backend Test Case Manifest v1.\n\n${BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS}`;
+    const finalManifest = buildBackendTestCaseManifestGateNode(sources, { id: "backend-test-case-manifest-final-shell", dependsOn: [reviseCases.id], fromNodeId: reviseCases.id });
+    finalManifest.runIf = reviseCases.runIf;
+    const finalCaseReview = buildReviewBackendCasesNode(sources, { id: "review-backend-cases-final-pi", phase: "final", dependsOn: [finalManifest.id, contracts.id] });
+    finalCaseReview.runIf = reviseCases.runIf;
+    const caseGate = buildReviewBackendCasesGateNode(sources);
+    caseGate.depends_on = [reviewCases.id, finalCaseReview.id];
+    caseGate.shell.verdictGate = { fromNodeId: finalCaseReview.id, fallbackFromNodeIds: [reviewCases.id], accept: ["VERDICT: pass"], label: "backend case effective review", lineMode: "first-verdict-line" };
+    const generatePytest = buildGenerateBackendPytestNode(sources);
+    generatePytest.depends_on = [caseGate.id, contracts.id];
+    const semanticReview = buildBackendTestSemanticReviewNode(sources, { dependsOn: [generatePytest.id, contracts.id, manifest.id, finalManifest.id] });
+    const semanticInitial = { id: "validate-semantic-review-and-traceability-shell", depends_on: [semanticReview.id, manifest.id, finalManifest.id], dependsPolicy: "all-or-condition-skip", role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), outputContract: "Materialize initial semantic review and validate pytest traceability.", subtask_prompt: "Validate initial semantic review and traceability fail-closed.", shell: { commands: [], backendTestPipeline: "semantic-initial", cwd: ".", timeoutMs: 60000 } };
+    const revisePytest = buildReviseGeneratedBackendPytestNode(sources);
+    revisePytest.depends_on = [semanticInitial.id];
+    revisePytest.runIf = "$.nodes['validate-semantic-review-and-traceability-shell'].json.verdict == 'request-revision'";
+    const finalSemanticReview = buildBackendTestSemanticReviewNode(sources, { id: "review-generated-backend-pytest-final-pi", dependsOn: [revisePytest.id], final: true });
+    finalSemanticReview.runIf = revisePytest.runIf;
+    const semanticFinal = { id: "backend-test-semantic-final-gate-shell", depends_on: [semanticInitial.id, finalSemanticReview.id], dependsPolicy: "all-or-condition-skip", role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), outputContract: "Pass-only effective semantic review gate with final traceability after revision.", subtask_prompt: "Accept initial semantic pass or validate the single final review and traceability.", shell: { commands: [['test -n "${HARNESS_DAG_RUN_DIR:-}" || exit 2', 'node -e \'const fs=require("fs"),path=require("path");const r=process.env.HARNESS_DAG_RUN_DIR;const f=path.join(r,"contracts","backend-test-semantic-review-final.json");const i=path.join(r,"contracts","backend-test-semantic-review.json");const v=JSON.parse(fs.readFileSync(fs.existsSync(f)?f:i,"utf8"));if(v.verdict!=="pass")throw new Error("backend pytest semantic review did not pass");\''].join("; ")], cwd: ".", timeoutMs: 60000 } };
+    const finalSemanticMaterialize = { id: "materialize-final-semantic-review-shell", depends_on: [finalSemanticReview.id], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), runIf: revisePytest.runIf, outputContract: "Materialize final semantic review and re-check traceability.", subtask_prompt: "Validate final semantic review and traceability.", shell: { commands: [], backendTestPipeline: "semantic-final", cwd: ".", timeoutMs: 60000 } };
+    semanticFinal.depends_on = [semanticInitial.id, finalSemanticMaterialize.id];
+    const executeInitial = buildExecuteBackendPytestNode(sources, { id: "execute-and-parse-backend-pytest-initial-shell", dependsOn: [semanticFinal.id, contracts.id], reportStem: "backend-test-initial" });
+    executeInitial.shell.backendTestPipeline = "execute-parse-initial";
+    const classify = buildClassifyBackendTestResultNode(sources);
+    classify.depends_on = [executeInitial.id];
+    const classifyEligibility = { id: "materialize-classification-and-eligibility-shell", depends_on: [classify.id], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources), outputContract: "Materialize Classification v1 and repair eligibility JSON.", subtask_prompt: "Validate classification and determine bounded repair eligibility.", shell: { commands: [], backendTestPipeline: "classification-eligibility", cwd: ".", timeoutMs: 60000 } };
+    const repair = buildRepairBackendPytestNode(sources);
+    repair.depends_on = [classifyEligibility.id];
+    repair.runIf = "$.nodes['materialize-classification-and-eligibility-shell'].json.eligible == true";
+    const repairVerify = { id: "validate-repair-safety-and-traceability-shell", depends_on: [repair.id], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: ["testcase/**"], forbiddenPaths: commonForbiddenPaths(sources), runIf: repair.runIf, outputContract: "Validate repair safety and final traceability.", subtask_prompt: "Reject manufactured success and revalidate mapping.", shell: { commands: [], backendTestPipeline: "repair-safety-traceability", cwd: ".", timeoutMs: 60000 } };
+    const finalize = buildExecuteBackendPytestNode(sources, { id: "finalize-effective-backend-test-result-shell", dependsOn: [classifyEligibility.id, repairVerify.id, contracts.id], reportStem: "backend-test-final" });
+    finalize.dependsPolicy = "all-or-condition-skip";
+    finalize.shell.backendTestPipeline = "finalize-effective-result";
+    finalize.outputContract = "If repaired, execute/parse final pytest; always materialize contracts/backend-test-result.json from final or initial result.";
+    const retrospect = buildTestRetrospectNode(sources);
+    retrospect.depends_on = [finalize.id];
+    const outcome = buildBackendTestOutcomeGateNode(sources);
+    const tasks = [analyze, contracts, generateCases, manifest, reviewCases, reviseCases, finalManifest, finalCaseReview, caseGate, generatePytest, semanticReview, semanticInitial, revisePytest, finalSemanticReview, finalSemanticMaterialize, semanticFinal, executeInitial, classify, classifyEligibility, repair, repairVerify, finalize, retrospect, outcome];
+    const spec = { version: 3, title: `Backend test DAG: ${taskConfig.title}`, runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT, outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE, objective: extractObjective(sources.requirementMarkdown, taskConfig.title), successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId), globalConstraints, defaults: { ...BACKEND_TEST_DEFAULTS, contextProfile: taskConfig.contextProfile }, skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE, executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS, tasks };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);