@tea-agent/loop-agent 0.16.18 → 0.16.20

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

@@ -18,7 +18,6 @@ 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 { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
@@ -2682,7 +2681,7 @@ function buildGenerateBackendFunctionalCasesNode(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.",
+    "Top-level keys MUST be exactly: schemaVersion, sourceBinding, cases, evidenceGaps. Do NOT emit coverageSummary — the shell materializer always computes it from sourceBinding/cases/evidenceGaps. 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.",
@@ -2690,7 +2689,7 @@ const BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS = [
     "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.",
+    "Use full BE-<MODULE>-<NNN> caseId strings. Do not invent coverage percentages and do not emit coverageSummary; shell always writes the canonical summary.",
     "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) {
@@ -2769,10 +2768,8 @@ function buildBackendTestTraceabilityGateNode(sources, options = {}) {
     };
 }
 function buildReviewBackendCasesNode(sources, options) {
-    const phase = options?.phase ?? "first";
-    const isFinal = phase === "final";
     return {
-        id: options?.id ?? "review-backend-cases-pi",
+        id: "review-backend-cases-pi",
         depends_on: options?.dependsOn ?? [
             "backend-test-case-manifest-shell",
             "backend-test-analysis-contract-shell",
@@ -2783,13 +2780,9 @@ function buildReviewBackendCasesNode(sources, options) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        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.",
+        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes. The deterministic gate accepts pass only; request-revision ends this run.",
         subtask_prompt: [
-            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.",
+            "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",
@@ -2818,15 +2811,13 @@ function buildReviewBackendCasesNode(sources, options) {
             "## 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/**.",
+            "- Any request-revision verdict ends the current run at the deterministic gate; describe findings clearly for an independent follow-up task.",
             "",
             "## Output After Verdict:",
             "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)",
+            "4. Required follow-up actions (only when request-revision; no in-run writer)",
             "",
             "## Constraints:",
             "- Read-only: do not modify files",
@@ -2837,69 +2828,6 @@ function buildReviewBackendCasesNode(sources, options) {
             .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",
@@ -3053,21 +2981,18 @@ function buildGenerateBackendPytestNode(sources) {
             "- If a test filename exists, add suffix: test_order.py → test_order_01.py",
             "- Do NOT re-read source documents — use reviewed cases under testcase/md/ and upstream analyze-inputs-pi output only",
             "- Read existing conftest.py/pytest.ini to understand conventions, but do NOT modify them",
-            "- Do NOT execute pytest/python -m pytest or npm test in this node; initial/final execution is owned by dedicated shell nodes. Local smoke runs create __pycache__/.pytest_cache and are unnecessary here.",
+            "- Do NOT execute pytest/python -m pytest or npm test in this node; the single execution is owned by the dedicated shell node. Local smoke runs create __pycache__/.pytest_cache and are unnecessary here.",
         ].join("\n\n"),
     };
 }
 function buildBackendTestSemanticReviewNode(sources, options = {}) {
-    const final = options.final ?? false;
     return {
-        id: options.id ?? "review-generated-backend-pytest-pi",
+        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",
@@ -3076,7 +3001,7 @@ function buildBackendTestSemanticReviewNode(sources, options = {}) {
         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.",
+            "Review generated pytest semantics before the single 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.",
@@ -3089,98 +3014,6 @@ function buildBackendTestSemanticReviewNode(sources, options = {}) {
         ].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: [],
-            backendTestPipeline: "semantic-effective",
-            cwd: ".",
-            timeoutMs: 60000,
-        },
-    };
-}
 function collectBackendTestShellEnvAllowlist(sources) {
     const names = new Set();
     for (const verify of sources.taskConfig.verifyCommands) {
@@ -3228,7 +3061,7 @@ function buildExecuteBackendPytestNode(sources, options = {}) {
     return {
         id: nodeId,
         depends_on: options.dependsOn ?? [
-            "backend-test-semantic-final-gate-shell",
+            "backend-test-semantic-gate-shell",
             "backend-test-execution-contract-shell",
         ],
         role: "verifier",
@@ -3254,41 +3087,10 @@ function buildExecuteBackendPytestNode(sources, options = {}) {
         },
     };
 }
-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,
-        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 Result v1 at contracts/backend-test-result.json (schemaId backend-test-result-v1) with outcome/counts/failures from deterministic JUnit parse.",
-        subtask_prompt: "Materialize Backend Test Result v1 from JUnit + pytestExitCode under the current DAG run (fail-closed on missing/corrupt report).",
-        shell: {
-            commands: [],
-            jsonArtifactGate: {
-                fromNodeId,
-                schemaId: "backend-test-result-v1",
-                artifactName,
-                outputDir: "contracts",
-                ...(options.junitRelativePath
-                    ? { junitRelativePath: options.junitRelativePath }
-                    : {}),
-            },
-            cwd: ".",
-            timeoutMs: 60000,
-        },
-    };
-}
 function buildClassifyBackendTestResultNode(sources) {
     return {
         id: "classify-backend-test-result-pi",
-        depends_on: ["parse-backend-test-result-initial-shell"],
+        depends_on: ["execute-and-parse-backend-pytest-shell"],
         role: "reviewer",
         executor: "pi",
         complexity: "MED",
@@ -3313,155 +3115,6 @@ 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 {
@@ -3567,10 +3220,11 @@ function buildBackendTestHybridDag(sources) {
     const globalConstraints = [
         ...taskConfig.hardConstraints,
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "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.",
+        "backend-test-dag uses exactly 15 real top-level tasks and executes pytest exactly once.",
+        "Case and semantic request-revision verdicts fail at deterministic gates; no in-run revision or repair writer is authorized.",
+        "Analysis, execution, manifest, semantic review, single-run result, classification, canonical result, retrospective and outcome evidence remain run-owned and fail-closed.",
         "Functional test case IDs must use BE-<MODULE>-<NNN> format.",
-        "pytest writers may only change declared testcase assets; production code, config, skip/xfail, swallowed failures and mock substitution are forbidden.",
+        "pytest writers may only create the initially declared testcase assets; production code, config, skip/xfail, swallowed failures and mock substitution are forbidden.",
     ];
     const analyze = buildAnalyzeInputsNode(sources);
     analyze.id = "analyze-and-discover-backend-test-pi";
@@ -3589,64 +3243,49 @@ function buildBackendTestHybridDag(sources) {
     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" };
+    caseGate.depends_on = [reviewCases.id];
+    caseGate.dependsPolicy = undefined;
+    caseGate.outputContract = "Deterministic backend case review gate: exit 0 only when the first and only review emits VERDICT: pass.";
+    caseGate.subtask_prompt = "Block pytest generation when backend case review requests revision; do not authorize an in-run writer.";
+    caseGate.shell.verdictGate = { fromNodeId: reviewCases.id, accept: ["VERDICT: pass"], label: "backend case 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 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 } };
-    const semanticFinal = {
-        id: "backend-test-semantic-final-gate-shell",
-        depends_on: [semanticInitial.id, finalSemanticMaterialize.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.",
+    const semanticReview = buildBackendTestSemanticReviewNode(sources, { dependsOn: [generatePytest.id, contracts.id, manifest.id] });
+    const semanticMaterialize = {
+        id: "validate-semantic-review-and-traceability-shell", depends_on: [semanticReview.id, manifest.id], role: "verifier", executor: "shell", complexity: "LOW",
+        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Materialize the only semantic review and validate pytest traceability.", subtask_prompt: "Materialize semantic facts and traceability; verdict authorization is handled by the next deterministic gate.",
+        shell: { commands: [], backendTestPipeline: "semantic-initial", cwd: ".", timeoutMs: 60000 },
+    };
+    const semanticGate = {
+        id: "backend-test-semantic-gate-shell", depends_on: [semanticMaterialize.id, semanticReview.id], role: "verifier", executor: "shell", complexity: "LOW",
+        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pass-only authorization by reading contracts/backend-test-semantic-review.json; only verdict=pass proceeds to the single pytest execution.",
+        subtask_prompt: "Read the canonical semantic review artifact written by validate-semantic-review-and-traceability-shell. Authorize only when verdict is pass. Do not materialize, do not parse raw Pi Markdown or VERDICT lines, and do not authorize an in-run pytest writer.",
         shell: {
             commands: [],
-            backendTestPipeline: "semantic-effective",
+            backendTestPipeline: "semantic-initial",
             cwd: ".",
             timeoutMs: 60000,
         },
     };
-    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 execute = buildExecuteBackendPytestNode(sources, { id: "execute-and-parse-backend-pytest-shell", dependsOn: [semanticGate.id, contracts.id], reportStem: "backend-test-initial" });
+    execute.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.";
+    classify.depends_on = [execute.id];
+    const context = {
+        id: "materialize-classification-and-result-context-shell", depends_on: [classify.id, manifest.id], role: "verifier", executor: "shell", complexity: "LOW",
+        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Materialize Classification v1, copy the unique initial Result to canonical contracts/backend-test-result.json, and emit Result + Manifest + Classification context.",
+        subtask_prompt: "Validate classification and materialize canonical single-run result context without repair eligibility or rerun.",
+        shell: { commands: [], backendTestPipeline: "classification-result-context", cwd: ".", timeoutMs: 60000 },
+    };
     const retrospect = buildTestRetrospectNode(sources);
-    retrospect.depends_on = [finalize.id];
+    retrospect.depends_on = [context.id];
+    retrospect.subtask_prompt = retrospect.subtask_prompt.replaceAll("select-effective-backend-test-result-shell", context.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 tasks = [analyze, contracts, generateCases, manifest, reviewCases, caseGate, generatePytest, semanticReview, semanticMaterialize, semanticGate, execute, classify, context, 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);

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

@@ -422,9 +422,10 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
             node.structuredArtifactSchemaId = task.shell.jsonArtifactGate.schemaId;
         }
-        else if (task.shell?.backendTestPipeline === "finalize-effective-result") {
-            // Pipeline materializes contracts/backend-test-result.json without jsonArtifactGate.
-            // Bind it so Outcome adapters project kind=backend-test-result for Ready Planner.
+        else if (task.shell?.backendTestPipeline === "classification-result-context") {
+            // The current 15-node single-run pipeline materializes the canonical
+            // contracts/backend-test-result.json without jsonArtifactGate. Bind it
+            // so Outcome adapters project kind=backend-test-result for Ready Planner.
             const artifactPath = path.join(runDir, "contracts", "backend-test-result.json");
             if (existsSync(artifactPath)) {
                 const bytes = await readFile(artifactPath);

package/dist/workflows/dag/types.js

@@ -145,12 +145,8 @@ export const dagNodeStatusSchema = z.enum([
 export const dagBackendTestPipelineSchema = z.enum([
     "contracts",
     "semantic-initial",
-    "semantic-final",
-    "semantic-effective",
     "execute-parse-initial",
-    "classification-eligibility",
-    "repair-safety-traceability",
-    "finalize-effective-result",
+    "classification-result-context",
 ]);
 export const dagShellConfigSchema = z.object({
     commands: z.array(z.string()).default([]),