@tea-agent/loop-agent 0.16.1-beta.2 → 0.16.2

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

@@ -18,10 +18,10 @@ 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";
-import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -933,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, {
@@ -1339,11 +1355,10 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
         allowedPaths: readOnlyPaths,
         forbiddenPaths,
         skills: FRONTEND_IMPLEMENTATION_SKILLS,
-        firstProtocolLine: "MOCK_STRATEGY:",
-        outputContract: "Plain Markdown whose first line is MOCK_STRATEGY: native|browser-intercept|request-adapter|not-needed|blocked, followed by Mock Decision, API Contract Evidence, Specification Evidence, Service Evidence, Backend Readiness, Selection Evidence, Endpoint / Fixture Matrix, Activation, Target Files, Production Safety, Verification Plan, Real Integration Gap, and Blocking Issues. No file writes.",
+        outputContract: "Plain Markdown whose first non-empty line is MOCK_STRATEGY: native|browser-intercept|request-adapter|not-needed|blocked, followed by Mock Decision, API Contract Evidence, Specification Evidence, Service Evidence, Backend Readiness, Selection Evidence, Endpoint / Fixture Matrix, Activation, Target Files, Production Safety, Verification Plan, Real Integration Gap, and Blocking Issues. No file writes.",
         subtask_prompt: [
             "Perform read-only Mock assessment and select one safe frontend data strategy.",
-            "The first line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked. Do not emit blank lines, headings, or explanatory preamble before it.",
+            "The first non-empty line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked.",
             "Prefer an existing native Mock facility. Use browser-intercept only with an existing browser/e2e harness. When no Mock exists but the API layer is writable, use request-adapter by adding a minimal reversible adapter/DI seam within the approved writeSet; the real adapter must remain the production default.",
             autoMaySkipMissingMock
                 ? "Auto mode may skip Mock when no project Mock capability is confirmed. Select not-needed with positive evidence from contract/scout that no project Mock capability is confirmed, continue without adding Mock files or dependencies, run the fixed verification entrypoints, and record any unproved real API behavior in Real Integration Gap. Do not block solely because no project Mock capability, browser interception harness, or request adapter exists."
@@ -1734,46 +1749,6 @@ function buildFrontendHybridDagFromTask(sources) {
             allowedPaths: taskConfig.allowedPaths,
             complexity: taskConfig.complexity,
         });
-    const frontendSourceBinding = buildDagSourceBinding(sources);
-    const frontendContractSchemaBlock = (() => {
-        const schema = loadFrontendImplementationContractJsonSchema();
-        const requirement = frontendSourceBinding.sources.find((source) => source.kind === "requirement");
-        if (!requirement) {
-            throw new Error("frontend implementation contract context requires a bound requirement source");
-        }
-        const referencePaths = frontendSourceBinding.sources
-            .filter((s) => s.kind === "reference")
-            .map((s) => s.path);
-        const fixedFields = {
-            schemaVersion: 1,
-            sourceBinding: {
-                taskId: frontendSourceBinding.taskId,
-                requirementPath: requirement.path,
-                requirementSha256: requirement.sha256,
-                referencePaths,
-                requirementIds: frontendSourceBinding.requirementIds,
-            },
-            riskLevel: frontendRisk.selectedRisk,
-            targets: { files: implementPaths.writeSet },
-        };
-        return [
-            `## ${FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID} JSON Schema (authoritative; do not guess fields)`,
-            schema,
-            "",
-            "## Fixed contract fields (deterministic; copy exactly and do not modify)",
-            JSON.stringify(fixedFields),
-            "",
-            "## Forbidden fields (these are NOT in the schema; do not emit)",
-            "- schemaId",
-            "- targetFiles",
-            "- requirementCoverage",
-            "",
-            "## Critical rules",
-            "- verificationTargets is a TOP-LEVEL required array",
-            "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
-            "- mockApi.productionDefaultOff must always be true (including strategy: not-needed)",
-        ].join("\n");
-    })();
     const sourceContext = [
         buildSourceContextBlock(sources),
         capabilityContextBlock,
@@ -1782,7 +1757,7 @@ function buildFrontendHybridDagFromTask(sources) {
         .join("\n\n");
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
-    const requirementIds = frontendSourceBinding.requirementIds;
+    const requirementIds = buildDagSourceBinding(sources).requirementIds;
     const requirementCoverageInstruction = requirementIds.length > 0
         ? `Include a Requirement Coverage section that lists every exact source identifier: ${requirementIds.join(", ")}. Preserve each identifier verbatim and map it to concrete implementation and verification steps.`
         : "";
@@ -1941,7 +1916,6 @@ function buildFrontendHybridDagFromTask(sources) {
                     fixedVerificationContext,
                     sourceContext,
                     mockContextBlock,
-                    frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
             {
@@ -2018,7 +1992,6 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
                     "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
                     sourceContext,
-                    frontendContractSchemaBlock,
                 ].join("\n\n"),
             },
             ...(requirementIds.length > 0
@@ -2468,6 +2441,7 @@ function buildFrontendHybridDagFromTask(sources) {
 // Backend test DAG template
 // ---------------------------------------------------------------------------
 function buildAnalyzeInputsNode(sources) {
+    const sourceBindingContract = buildBackendTestAnalysisSourceBindingContract(sources);
     return {
         id: "analyze-inputs-pi",
         depends_on: [],
@@ -2477,14 +2451,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"),
@@ -2500,13 +2479,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",
             },
@@ -2533,11 +2512,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),
@@ -2572,7 +2552,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",
@@ -2584,19 +2567,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)",
@@ -2611,16 +2606,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",
         ],
@@ -2633,20 +2640,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",
@@ -2658,7 +2662,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",
@@ -2668,13 +2672,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",
@@ -2690,10 +2699,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",
         ],
@@ -2703,21 +2714,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",
@@ -2727,40 +2742,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: ".",
@@ -2889,7 +2987,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
@@ -2900,12 +3140,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}"',
@@ -2914,9 +3158,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",
@@ -2929,6 +3173,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",
@@ -2941,10 +3186,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",
@@ -2956,10 +3204,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,
@@ -2969,7 +3220,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",
@@ -2980,7 +3231,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).",
@@ -2992,24 +3245,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.",
@@ -3031,7 +3447,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"),
@@ -3078,63 +3496,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);
@@ -4356,22 +4784,45 @@ function buildReviewNode(sources) {
         ].join("\n\n"),
     };
 }
+function buildReviewVerdictRecoveryNode(sources) {
+    return {
+        id: "review-verdict-recovery-pi",
+        depends_on: ["review-pi"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is exactly VERDICT: pass or VERDICT: request-revision, followed by the original review findings without substantive changes. No file writes.",
+        subtask_prompt: [
+            "Normalize the output format of review-pi; this is the single read-only format-recovery attempt for the review verdict protocol.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "If review-pi already contains a valid VERDICT line, preserve that verdict exactly and keep the original findings.",
+            "If it omitted or malformed the VERDICT line but states an unambiguous request-revision conclusion, emit VERDICT: request-revision and preserve the findings.",
+            "Do not invent VERDICT: pass from natural-language phrases such as 通过、PASS、✅, or general approval prose.",
+            "If the upstream conclusion is ambiguous or cannot be preserved safely, emit VERDICT: request-revision and report the format ambiguity.",
+            "Do not re-review code, expand task allowedPaths, or edit files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
 function buildReviewGateNode(sources) {
     return {
         id: "review-gate-shell",
-        depends_on: ["review-pi"],
+        depends_on: ["review-verdict-recovery-pi"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Deterministic review verdict gate: exit 0 only when review-pi first non-empty assistant output line is pass.",
-        subtask_prompt: "Deterministic gate: block downstream closeout unless review-pi emitted VERDICT: pass.",
+        outputContract: "Deterministic review verdict gate: exit 0 only when review-verdict-recovery-pi first VERDICT line is pass.",
+        subtask_prompt: "Deterministic gate: block downstream closeout unless review-verdict-recovery-pi emitted VERDICT: pass.",
         shell: {
             commands: [],
             verdictGate: {
-                fromNodeId: "review-pi",
+                fromNodeId: "review-verdict-recovery-pi",
                 accept: ["VERDICT: pass"],
                 label: "review",
                 lineMode: "first-verdict-line",
@@ -4388,13 +4839,13 @@ function buildReviewGatedHybridDag(standard, sources) {
         objective: `${standard.objective ?? ""}\n\nRoute: review-gated DAG selected by workflowPolicy/governanceProfile.`.trim(),
         globalConstraints: [
             ...(standard.globalConstraints ?? []),
-            "Review-gated DAGs must block closeout unless review-pi emits first-line VERDICT: pass.",
+            "Review-gated DAGs must block closeout unless review-verdict-recovery-pi emits first-line VERDICT: pass.",
         ],
         tasks: standard.tasks.map((task) => ({ ...task })),
     };
     const closeout = getTaskOrThrow(spec, "closeout-pi");
     replaceTask(spec, cloneTask(closeout, { depends_on: ["review-gate-shell"] }));
-    spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewGateNode(sources));
+    spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewVerdictRecoveryNode(sources), buildReviewGateNode(sources));
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
@@ -4778,6 +5229,7 @@ function buildSupervisedHybridDag(standard, sources) {
             cloneTask(buildReviewNode(sources), {
                 depends_on: reviewDependsOn,
             }),
+            buildReviewVerdictRecoveryNode(sources),
             buildReviewGateNode(sources),
             buildDecisionNode(sources),
             cloneTask(closeout, { depends_on: ["decision-pi"] }),