@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.12

package/dist/workflows/dag/hybrid/templates/backend-test.js

@@ -0,0 +1,1807 @@
+import { createHash } from "node:crypto";
+import { deflateRawSync } from "node:zlib";
+import { assertValidDagSpec } from "../../validate.js";
+import { DEFAULT_DAG_EXECUTOR_MODELS, DEFAULT_DAG_OUTPUT_LANGUAGE, parseDagSpec } from "../../types.js";
+import { BACKEND_TEST_MARKDOWN_BINDING_RETRY_POLICY, BACKEND_TEST_MD_PLAN_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY } from "../../retry-policy.js";
+import { BACKEND_TEST_MODULE_INDEX_HEADER, BACKEND_TEST_MODULE_SPLIT_REASONS } from "../../backend-test-plan-protocol.js";
+import { DEFAULT_VERIFY_TIMEOUT_MS } from "../../../../executors/shell-verification.js";
+import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet } from "../../backend-test-execution-contract.js";
+import { resolveBackendTestLayout } from "../../backend-test-layout.js";
+import { buildBackendTestOutcomeGateShellSnippet } from "../../backend-test-result-contract.js";
+import { buildBackendTestIntakeContext } from "../../backend-test-intake-context.js";
+import { GENERATED_DAG_RUNTIME_CONTRACT, HYBRID_DEFAULTS, STANDARD_GLOBAL_CONSTRAINTS, buildBackendTestAnalysisSourceBindingContract, buildSourceContextBlock, buildVerifyEvidence, extractObjective, extractSuccessCriteria, resolveDagVerifyStrategy, toDagSourcePath } from "../sources.js";
+import { applyDefaultReadOnlyRetryPolicy, commonForbiddenPaths, commonReadOnlyPaths, stampGeneratedArtifactBindings, } from "./shared.js";
+export function buildAnalyzeInputsNode(sources) {
+    const sourceBindingContract = buildBackendTestAnalysisSourceBindingContract(sources);
+    return {
+        id: "analyze-inputs-pi",
+        depends_on: [],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        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 v2.",
+            "Do not wrap it in explanatory prose. A single fenced json block is tolerated, but pure JSON is preferred.",
+            "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.",
+            "For externalDependencies and risks, emit canonical items with exactly description plus optional name and sourceRef. For a dependency target, put the target value in name. Do not emit type, target, kind, required, severity, mitigation, level, impact, sourceRefs, or custom keys in newly generated v2 output.",
+            "Use empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.",
+            "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"),
+    };
+}
+export function buildBackendTestAnalysisContractGateNode(sources) {
+    return {
+        id: "backend-test-analysis-contract-shell",
+        depends_on: ["analyze-inputs-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        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-v2",
+                artifactName: "backend-test-analysis.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export function buildBackendTestEnvironmentScoutNode(sources) {
+    return {
+        id: "backend-test-environment-scout-pi",
+        depends_on: ["backend-test-analysis-contract-shell"],
+        role: "scout",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure Backend Test Execution Contract v1 JSON object matching docs/templates/backend-test-execution.schema.json. No Markdown prose and no file writes.",
+        subtask_prompt: [
+            "Read-only environment scout for backend-test pytest MVP.",
+            "Return exactly one JSON object matching Backend Test Execution Contract v1 (schema docs/templates/backend-test-execution.schema.json).",
+            "Prefer pure JSON; a single fenced json block is tolerated; no trailing prose.",
+            "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 (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_]*$.",
+            "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),
+        ].join("\n\n"),
+    };
+}
+export function buildBackendTestExecutionContractGateNode(sources) {
+    return {
+        id: "backend-test-execution-contract-shell",
+        depends_on: ["backend-test-environment-scout-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Execution Contract v1 artifact pointer, schema ID, and SHA-256.",
+        subtask_prompt: "Materialize and validate the backend-test execution contract under the current DAG run.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "backend-test-environment-scout-pi",
+                schemaId: "backend-test-execution-v1",
+                artifactName: "backend-test-execution.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export function buildGenerateBackendFunctionalCasesNode(sources) {
+    return {
+        id: "generate-backend-functional-cases-pi",
+        depends_on: [
+            "backend-test-analysis-contract-shell",
+            "backend-test-execution-contract-shell",
+        ],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
+        // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
+        subtask_prompt: [
+            "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) — always write the FULL id; never abbreviate as 002, 003 in matrices",
+            "- Each file covers one module",
+            "- 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)",
+            "",
+            "## Conditional Coverage (include ONLY if mentioned in upstream analysis):",
+            "- Boundary conditions: include ONLY if upstream analyze-inputs-pi mentions value ranges, length limits, numeric bounds, or format constraints",
+            "- State transitions: include ONLY if upstream analyze-inputs-pi mentions state machine",
+            "- Authentication scenarios: include ONLY if upstream analyze-inputs-pi mentions auth mechanism",
+            "- Timeout scenarios: include ONLY if upstream analyze-inputs-pi mentions timeout handling",
+            "- Concurrency scenarios: include ONLY if upstream analyze-inputs-pi mentions concurrency/idempotency rules",
+            "- If not mentioned, do NOT generate these test cases",
+            "",
+            "## Constraints:",
+            "- Stay within writeSet: testcase/md/**",
+            "- 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"),
+    };
+}
+export function buildEmitBackendCaseManifestNode(sources, options) {
+    return {
+        id: options?.id ?? "emit-backend-case-manifest-pi",
+        depends_on: options?.dependsOn ?? [
+            "generate-backend-functional-cases-pi",
+            "backend-test-analysis-contract-shell",
+        ],
+        role: "scout",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(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/**.",
+            "No secrets or credential-shaped fields.",
+        ].join("\n\n"),
+    };
+}
+export function buildBackendTestCaseManifestGateNode(sources, options) {
+    const fromNodeId = options?.fromNodeId ?? "emit-backend-case-manifest-pi";
+    return {
+        id: options?.id ?? "backend-test-case-manifest-shell",
+        depends_on: options?.dependsOn ?? ["emit-backend-case-manifest-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Case Manifest v1 at contracts/backend-test-case-manifest.json (schemaId backend-test-case-manifest-v1) with deterministic AC coverage.",
+        subtask_prompt: "Materialize and validate Backend Test Case Manifest v1; fail closed on duplicate IDs, unknown AC, missing AC coverage without gap, or skipped without gapReason.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId,
+                schemaId: "backend-test-case-manifest-v1",
+                artifactName: "backend-test-case-manifest.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export function buildBackendTestTraceabilityGateNode(sources, options = {}) {
+    return {
+        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",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic traceability: generated cases have real file/symbol; skipped/unsupported have gapReason; convention symbols scanned under testcase/**/test_*.py.",
+        subtask_prompt: "Fail closed when generated automation claims do not resolve to workspace pytest symbols, or skip/unsupported lacks gapReason.",
+        shell: {
+            commands: ["backend-test-traceability-gate"],
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export function buildReviewBackendCasesNode(sources, options) {
+    return {
+        id: "review-backend-cases-pi",
+        depends_on: options?.dependsOn ?? [
+            "backend-test-case-manifest-shell",
+            "backend-test-analysis-contract-shell",
+        ],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "HIGH",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "advisory case review evidence whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes; this review neither authorizes nor blocks pytest generation.",
+        subtask_prompt: [
+            "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> (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 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 (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",
+            "- State transition coverage: check ONLY if analyze-inputs-pi mentions state machine",
+            "- Authentication coverage: check ONLY if analyze-inputs-pi mentions auth mechanism",
+            "- Timeout coverage: check ONLY if analyze-inputs-pi mentions timeout handling",
+            "- 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",
+            "- Any request-revision verdict is advisory evidence for canonical context, retrospective, and L-5; it does not authorize or block the pytest writer.",
+            "",
+            "## 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)",
+            "4. Required follow-up actions (only when request-revision; no in-run writer)",
+            "",
+            "## 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"),
+    };
+}
+export 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
+    // cross-checked against the materialized execution contract in preflight.
+    const frozenTestRoot = options.testRoot ?? BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT;
+    const preflightCommand = buildBackendTestExecutionPreflightShellSnippet({
+        expectedTestRoot: frozenTestRoot,
+    });
+    // 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`;
+    // Preflight snippet is already fail-closed (&&). Only the pytest body may use
+    // ";" so STATUS capture still runs after non-zero pytest exits.
+    const pytestBody = [
+        `REPORT="\${HARNESS_DAG_RUN_DIR}/reports/${reportName}"`,
+        `EXIT_FILE="\${HARNESS_DAG_RUN_DIR}/reports/${exitName}"`,
+        'mkdir -p "$(dirname "${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}"',
+        'printf "pytestExitCode=%s\\n" "${STATUS}"',
+        'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${REPORT}" ]; then exit 0; fi',
+        'exit "${STATUS}"',
+    ].join("; ");
+    const pytestCommand = `${preflightCommand} && { ${pytestBody}; }`;
+    return {
+        id: nodeId,
+        depends_on: options.dependsOn ?? [
+            "backend-test-semantic-gate-shell",
+            "backend-test-execution-contract-shell",
+        ],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Archived pytest stdout/stderr; raw pytestExitCode side-channel + JUnit at $HARNESS_DAG_RUN_DIR/reports/**. Exit 0/1 with non-empty JUnit finishes the node so parse/classify/retrospect can run; assertion failures remain recorded in exit file.",
+        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",
+                commandSource: "inline",
+                fallbackCommands: [pytestCommand],
+                finalFullRequired: true,
+                commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+            }),
+            cwd: ".",
+            timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+        },
+    };
+}
+export function buildClassifyBackendTestResultNode(sources) {
+    return {
+        id: "classify-backend-test-result-pi",
+        depends_on: ["execute-and-parse-backend-pytest-shell"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure JSON classification: category in {ProductBug,TestBug,EnvFailure,ContractMismatch,FlakyTest,Unknown}, evidence[], confidence (capped), notes. No file writes.",
+        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).",
+            "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).",
+            "- executionStatus/outcome collection-error, command-error, or report-error MUST NOT use ProductBug.",
+            "- Prefer EnvFailure/Unknown/TestBug for env, import, collection, and missing-report cases.",
+            "- confidence must respect deterministic caps (≤0.75 for assertion failures; ≤0.6 for env/collection).",
+            "Include evidence[] referencing result fields (outcome, failed, failures[].name, executionStatus).",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+        ].join("\n\n"),
+    };
+}
+export function buildTestRetrospectNode(sources) {
+    const canWriteReport = taskAllowsBackendTestReportWrite(sources);
+    return {
+        id: "test-retrospect-pi",
+        depends_on: ["select-effective-backend-test-result-shell"],
+        role: "closeout",
+        executor: "pi",
+        complexity: "MED",
+        ...(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 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",
+            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.",
+            "- AC coverage ratio / case counts MUST come from contracts/backend-test-case-manifest.json coverageSummary (or gate-derived fields). Do NOT invent coverage %.",
+            "- Automation coverage MUST use coverageSummary.generatedCount / coverageSummary.caseCount. If either field is missing, write unavailable; do not estimate.",
+            "- Code coverage MUST come only from the validated contracts/code-coverage-v1.json artifact generated by coverage.py/pytest-cov or JaCoCo. Show line, branch, function/method, covered, total, ratio, threshold, status, source scope, requirement IDs, tool, commit, and artifact hash.",
+            "- Use classify-backend-test-result-pi JSON as interpretive evidence only.",
+            "- NEVER rewrite a failed result as passed. Result v1 is authoritative for testOutcome; pipeline completion and L-5 readiness are separate conclusions.",
+            "",
+            "## Report Structure:",
+            "1. Maturity Rating with rationale",
+            "2. Test Coverage Summary (Result v1 pass rate, AC coverage, automation coverage, and code coverage)",
+            "3. Failed Test Analysis (failure/error details, category, confidence, evidence, and owner direction)",
+            "4. Defects (local Bug ledger in the same report directory; unavailable when absent)",
+            "5. Risks (Critical/High/Medium/Low, impact, controls, residual risk, treatment; Critical risks block L-5, High risks do not automatically block)",
+            "6. Regression Recommendations (immediate, related, periodic, deferred; every item links to failure/risk/AC/case IDs)",
+            "7. L-5 conclusion with blocking items",
+            "",
+            "## Rating Criteria:",
+            "- L-5 ready requires pass rate=100%, AC coverage=100%, automation coverage≥90%, line coverage≥80%, branch coverage≥70%, skipped=0, and no blocking Critical risk.",
+            "- Any required metric fail or unavailable means L-5 not-ready. Function/method coverage is displayed but not a gate. Preserve the existing A/B/C/D single-run rating separately.",
+            "",
+            "## Constraints:",
+            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"),
+    };
+}
+export function buildBackendTestOutcomeGateNode(sources) {
+    const gateCommand = buildBackendTestOutcomeGateShellSnippet();
+    return {
+        id: "backend-test-outcome-gate-shell",
+        depends_on: ["l5-metrics-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Shell exit 0 only when Result v1 outcome=passed with failed=0 and error=0; non-zero otherwise. Ignores retrospective Markdown.",
+        subtask_prompt: "Gate the backend-test DAG on run-owned Result v1 shell facts only (not retrospective prose).",
+        shell: {
+            commands: [gateCommand],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [gateCommand],
+                finalFullRequired: true,
+                commandTimeoutMs: 60_000,
+            }),
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export function buildL5MetricsNode(sources) {
+    return {
+        id: "l5-metrics-pi",
+        depends_on: ["test-retrospect-pi"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Exactly one JSON object with status=ready|not-ready, metrics, and blockingItems; no file writes.",
+        subtask_prompt: [
+            "You are the independent L-5 metrics node at the end of the existing backend-test DAG.",
+            "The direct upstream test-retrospect-pi output is the primary report to assess. Read it together with the run-owned Result v1, Case Manifest v1, and Code Coverage v1 artifacts when present.",
+            "Do not create a new DAG, rewrite the retrospective report, change test outcome, or modify any repository file.",
+            "Return exactly one JSON object and no surrounding prose.",
+            'Required shape: {"status":"ready"|"not-ready","metrics":{"passRate":metric,"acCoverage":metric,"automationCoverage":metric,"lineCoverage":metric,"branchCoverage":metric,"skipped":metric,"criticalRisks":metric},"blockingItems":[string]}.',
+            "Each metric must contain numerator, denominator, ratio, threshold, status=pass|fail|unavailable, and reason (null only when passed).",
+            "Use only explicit evidence. Missing or invalid required evidence is unavailable, never zero or an estimate.",
+            "L-5 ready requires pass rate=100%, AC coverage=100%, automation coverage>=90%, line coverage>=80%, branch coverage>=70%, skipped=0, and zero blocking Critical risks.",
+            "Function/method coverage is display-only and does not gate L-5. Preserve the distinction between L-5 maturity and the Result v1 outcome gate.",
+        ].join("\n\n"),
+    };
+}
+export function applyBackendTestLayoutToText(text, layout) {
+    if (layout.isDefault)
+        return text;
+    const replacements = [
+        ["testcase/test_", `${layout.scriptDir}/test_`],
+        ["testcase/md/", `${layout.markdownDir}/`],
+        ["testcase/**", `${layout.testRoot}/**`],
+        ["testcase/", `${layout.testRoot}/`],
+    ];
+    replacements.sort((a, b) => b[0].length - a[0].length);
+    let output = "";
+    const resolvedPrefix = `${layout.testRoot}/`;
+    for (let i = 0; i < text.length;) {
+        if (text.startsWith(resolvedPrefix, i)) {
+            output += resolvedPrefix;
+            i += resolvedPrefix.length;
+            continue;
+        }
+        const hit = replacements.find(([token]) => text.startsWith(token, i));
+        if (hit) {
+            output += hit[1];
+            i += hit[0].length;
+            continue;
+        }
+        output += text[i];
+        i += 1;
+    }
+    return output;
+}
+export function buildBackendTestModuleManifestShellCommand(layout, moduleLayout) {
+    // The extractor is base64-encoded so the shell command is fully opaque to
+    // bash: no backticks (command substitution), no regex \/ escaping, no
+    // backslash-counting through TS-string -> JSON.stringify -> bash -c -> node -e.
+    // Backticks in the README body are stripped at runtime via
+    // String.fromCharCode(96), so the extractor source contains no backtick.
+    // mdDir/testPrefix are injected as JSON literals so the same extractor
+    // works for any configured backendTest layout (plan A).
+    const mdDirLiteral = JSON.stringify(layout.markdownDir);
+    const scriptDirLiteral = JSON.stringify(layout.scriptDir);
+    const strictLayoutCompressed = moduleLayout
+        ? deflateRawSync(Buffer.from(JSON.stringify(moduleLayout), "utf8")).toString("base64")
+        : null;
+    const strictLayoutExpression = strictLayoutCompressed
+        ? `JSON.parse(zlib.inflateRawSync(Buffer.from(${JSON.stringify(strictLayoutCompressed)},'base64')).toString('utf8'))`
+        : "null";
+    const strictLayoutShaLiteral = JSON.stringify(moduleLayout
+        ? createHash("sha256").update(JSON.stringify(moduleLayout)).digest("hex")
+        : null);
+    const escOpen = String.fromCharCode(92, 91); // \[
+    const escClose = String.fromCharCode(92, 93); // \]
+    const escBslash = String.fromCharCode(92, 92); // \\
+    const script = `const fs=require('fs'),path=require('path'),crypto=require('crypto'),zlib=require('zlib');
+const mdDir=${mdDirLiteral};
+const scriptDir=${scriptDirLiteral};
+const strictLayout=${strictLayoutExpression};
+const strictLayoutSha256=${strictLayoutShaLiteral};
+const esc=s=>s.replace(/[${escOpen}${escClose}{}()*+?^$|${escBslash}]/g,'${escBslash}$&');
+const rxMdPath=new RegExp(esc(mdDir)+'${escBslash}/([A-Za-z0-9_.-]+)${escBslash}.md','g');
+const runDir=process.env.HARNESS_DAG_RUN_DIR||'';
+if(!runDir){process.stderr.write('missing HARNESS_DAG_RUN_DIR for backend-test Markdown plan artifact\\n');process.exit(2);}
+const planPath=path.join(runDir,'generate-backend-md-plan-pi','plan.md');
+if(!fs.existsSync(planPath)){process.stderr.write('missing backend-test Markdown plan artifact: '+planPath+'\\n');process.exit(2);}
+let readme=fs.readFileSync(planPath,'utf8');
+const norm=s=>String(s).toLowerCase().replace(/[^a-z0-9]+/g,'_').replace(/^_+|_+$/g,'').replace(/_+/g,'_');
+const bt=String.fromCharCode(96);
+const stripBackticks=s=>s.split(bt).join('');
+const invalidReason=raw=>{const st=norm(raw);if(/^p[0-2]$/.test(st))return 'priority-only-module-stem';if(/^[a-f][a-f0-9]{6,63}$/.test(st))return 'opaque-hash-module-stem';if(st==='readme')return 'reserved-module-stem';if(!/^[a-z][a-z0-9_]*$/.test(st))return 'invalid-syntax';if(/^(?:be|tp|ac|req|br)[_-]/i.test(st))return 'case-like-module-stem';return null;};
+const valid=raw=>invalidReason(raw)===null;
+const rxRelLink=/\\[[^\\]]+\\]\\(\\.\\/([A-Za-z0-9_.-]+)\\.md\\)/g;
+const headingAlias={'\u6a21\u5757\u7d22\u5f15':'Module Index','\u8986\u76d6\u8303\u56f4':'Coverage Scope','\u8986\u76d6\u77e9\u9635':'Coverage Matrix','\u573a\u666f\u5206\u533a':'Scenario Partitions'};
+const allLines=readme.replace(/\\r\\n/g,'\\n').replace(/\\r/g,'\\n').split('\\n');
+let headingRepair=false;
+for(let i=0;i<allLines.length;i++){const alias=/^##\\s+(模块索引|覆盖范围|覆盖矩阵|场景分区)\\s*$/.exec(allLines[i].trim());if(alias){allLines[i]='## '+headingAlias[alias[1]];headingRepair=true;}}
+let partitionRepair=false;
+const partHeadTrim=[];for(let i=0;i<allLines.length;i++){if(allLines[i].trim()==='## Scenario Partitions')partHeadTrim.push(i);}
+if(partHeadTrim.length===1){
+  const pStart=partHeadTrim[0]+1;let pEnd=allLines.length;for(let i=pStart;i<allLines.length;i++){if(/^##\\s+\\S/.test(allLines[i].trim())){pEnd=i;break;}}
+  const pCells=line=>line.split('|').slice(1,-1).map(v=>String(v||'').trim());
+  const pHeader=['Partition ID','Operation','Axis','Domain','Required Slots','Expected by Slot','Bind Rule'];
+  for(let i=pStart;i<pEnd;i++){
+    if(!allLines[i].includes('|')) continue;
+    const row=pCells(allLines[i]);
+    if(row.length<=7) continue;
+    if(pHeader.every((v,idx)=>row[idx]===v)) continue;
+    const pid=String(row[0]||'').trim();
+    const extras=row.slice(7).join(';').split(/[;,，；]/).map(v=>v.trim().split(bt).join('')).filter(Boolean);
+    const prefix='TP-'+pid.toUpperCase()+'-';
+    if(extras.length && extras.every(t=>/^TP-[A-Z0-9-]+$/i.test(t)&&(t.toUpperCase().startsWith(prefix)||t.toUpperCase().startsWith('TP-SP-')))){
+      allLines[i]='| '+row.slice(0,7).join(' | ')+' |';
+      partitionRepair=true;
+    }
+  }
+}
+if(headingRepair||partitionRepair)readme=allLines.join('\\n');
+const headings=[];for(let i=0;i<allLines.length;i++){if(allLines[i].trim()==='## Module Index')headings.push(i);}
+if(headings.length!==1){process.stderr.write((headings.length===0?'missing-module-index':'duplicate-module-index')+'; require exactly one exact ## Module Index section\\n');process.exit(2);}
+const start=headings[0]+1;let end=allLines.length;for(let i=start;i<allLines.length;i++){if(/^##\\s+\\S/.test(allLines[i].trim())){end=i;break;}}
+const section=allLines.slice(start,end).join('\\n');
+const raw=[];
+const lines=section.split('\\n').filter(l=>l.includes('|'));
+const cells=line=>line.split('|').slice(1,-1).map(value=>stripBackticks(value).trim());
+const expectedHeader=${JSON.stringify(BACKEND_TEST_MODULE_INDEX_HEADER)};
+const headerIndex=lines.findIndex(line=>{const row=cells(line);return expectedHeader.every((value,index)=>row[index]===value);});
+if(headerIndex<0){process.stderr.write('invalid-module-index-header: require exact business ownership and path columns\\n');process.exit(2);}
+const dataRows=lines.slice(headerIndex+2).map(cells).filter(row=>row.length>=8&&row[0]&&row[0]!=='Module Stem');
+const allowedSplit=new Set(${JSON.stringify(BACKEND_TEST_MODULE_SPLIT_REASONS)});
+const operationOwners=new Map();const canonicalSeen=new Set();const declaredModules=[];let planRepairApplied=headingRepair||partitionRepair;
+for(const row of dataRows){
+  const rawStem=String(row[0]||'').trim(),resource=String(row[1]||'').trim(),operations=String(row[2]||'').split(';').map(value=>value.trim()).filter(Boolean),split=String(row[5]||'').trim();
+  const mdMatches=[...String(row[6]||'').matchAll(rxMdPath)];
+  if(mdMatches.length!==1){process.stderr.write('module-markdown-path-mismatch: '+(rawStem||'unknown')+'; require exactly one canonical Markdown Path\\n');process.exit(2);}
+  let stem=norm(mdMatches[0][1]),markdownPath=mdMatches[0][0];
+  if(strictLayout&&!strictLayout.modules.some(item=>item.markdownPath===markdownPath)){planRepairApplied=true;continue;}
+  if(!resource){process.stderr.write('missing-business-resource: '+stem+'\\n');process.exit(2);}
+  if(/^(?:response|resp|regression|positive|negative|boundary|error|combo|filter)(?:[_ -]|$)/i.test(resource)){process.stderr.write('test-purpose-business-resource: '+stem+' -> '+resource+'\\n');process.exit(2);}
+  if(!allowedSplit.has(split)){process.stderr.write('invalid-module-split-reason: '+stem+' -> '+split+'\\n');process.exit(2);}
+  if(operations.length===0){process.stderr.write('missing-owned-operation: '+stem+'\\n');process.exit(2);}
+  let pytestPath=String(row[7]||'').replace(/^\\.\\//,'').replace(/\\\\/g,'/');
+  if(!/^[A-Za-z0-9_./-]+\\.py$/.test(pytestPath)||pytestPath.includes('..')){process.stderr.write('invalid-module-pytest-path: '+stem+' -> '+pytestPath+'\\n');process.exit(2);}
+  const requiredCandidates=strictLayout?strictLayout.modules.filter(item=>item.markdownPath===markdownPath):[];
+  if(strictLayout&&requiredCandidates.length!==1){process.stderr.write('MODULE_LAYOUT_CONFLICT: no unique required module for Markdown Path '+markdownPath+'\\n');process.exit(2);}
+  const required=requiredCandidates[0];
+  if(!required&&norm(rawStem)!==stem)planRepairApplied=true;
+  if(required){
+    stem=required.stem;
+    if(norm(rawStem)!==stem)planRepairApplied=true;
+    if(!required.markdownPath.startsWith(mdDir+'/')||!required.pytestPath.startsWith(scriptDir+'/')||required.markdownPath.includes('..')||required.pytestPath.includes('..')){process.stderr.write('MODULE_LAYOUT_CONFLICT: strict paths outside frozen roots for '+stem+'\\n');process.exit(2);}
+    if(markdownPath!==required.markdownPath||pytestPath!==required.pytestPath||resource!==required.businessResource||JSON.stringify(operations)!==JSON.stringify(required.ownedOperations)||split!==required.splitReason){planRepairApplied=true;}
+    markdownPath=required.markdownPath;pytestPath=required.pytestPath;
+    if(required.splitReason==='output-budget'){
+      const proof=required.budgetProof;const peers=strictLayout.modules.filter(item=>item.budgetProof&&item.budgetProof.groupId===proof.groupId);
+      if(!proof||proof.estimatedOutputChars<=proof.maxOutputCharsPerWriter||Math.ceil(proof.estimatedOutputChars/Math.max(1,peers.length))>proof.maxOutputCharsPerWriter||peers.some(item=>item.budgetProof.inputSha256!==proof.inputSha256||item.budgetProof.estimatorVersion!==proof.estimatorVersion)){process.stderr.write('INVALID_OUTPUT_BUDGET_PROOF: '+stem+'\\n');process.exit(2);}
+    }
+  }
+  const item={stem,markdownPath,pytestPath,businessResource:required?required.businessResource:resource,ownedOperations:required?required.ownedOperations:operations,ownedRuleKeys:String(row[3]||'').split(';').map(value=>value.trim()).filter(Boolean),caseIds:String(row[4]||'').split(';').map(value=>value.trim()).filter(Boolean),splitReason:required?required.splitReason:split,...(required&&required.budgetProof?{budgetProof:required.budgetProof}:{})};
+  if(canonicalSeen.has(item.stem)){process.stderr.write('duplicate-canonical-module-stem: '+item.stem+'; module identity must be unique\\n');process.exit(2);}
+  canonicalSeen.add(item.stem);
+  declaredModules.push(item);
+  for(const operation of item.ownedOperations){const owners=operationOwners.get(operation)||[];owners.push({stem,split:item.splitReason});operationOwners.set(operation,owners);}
+}
+if(strictLayout){
+  const missing=strictLayout.modules.filter(item=>!declaredModules.some(actual=>actual.stem===item.stem));
+  if(missing.length){process.stderr.write('MODULE_LAYOUT_CONFLICT: plan missing required modules '+missing.map(item=>item.stem).join(',')+'; deterministic Plan-only repair cannot invent Rule/Case ownership\\n');process.exit(2);}
+}
+if(planRepairApplied){
+  const table=['| '+expectedHeader.join(' | ')+' |','|'+expectedHeader.map(()=>'---').join('|')+'|',...declaredModules.map(item=>'| '+[item.stem,item.businessResource,item.ownedOperations.join('; '),item.ownedRuleKeys.join('; '),item.caseIds.join('; '),item.splitReason,'['+item.stem+'](./'+item.stem+'.md) '+item.markdownPath,item.pytestPath].join(' | ')+' |')].join('\\n');
+  readme=[...allLines.slice(0,headings[0]+1),table,...allLines.slice(end)].join('\\n');
+  fs.writeFileSync(planPath,readme,'utf8');
+} else if(headingRepair||partitionRepair){
+  fs.writeFileSync(planPath,readme,'utf8');
+}
+for(const [operation,owners] of operationOwners){if(owners.length>1&&!owners.every(owner=>owner.split==='explicit-user-layout'||owner.split==='output-budget')){process.stderr.write('overlapping-operation-modules: '+operation+' -> '+owners.map(owner=>owner.stem).join(',')+'; merge by business resource or use an authoritative explicit-user-layout\\n');process.exit(2);}}
+if(!strictLayout){
+  for(const line of lines){
+    const bare=stripBackticks(line);
+    for(const m of bare.matchAll(rxMdPath)){raw.push(m[1]);}
+  }
+  for(const m of section.matchAll(rxRelLink)){raw.push(m[1]);}
+}
+const invalid=[];for(const r of raw){const reason=invalidReason(r);if(reason)invalid.push({stem:norm(r),reason});}
+if(invalid.length){for(const item of invalid)process.stderr.write(item.reason+': '+item.stem+'; use a stable business resource/domain stem\\n');process.exit(2);}
+const modules=[];
+for(const item of declaredModules){if(valid(item.stem))modules.push(item);}
+if(modules.length===0){process.stderr.write('empty-module-index: require at least one stable business module\\n');process.exit(2);}
+if(modules.length>8){process.stderr.write('excessive-module-count: '+modules.length+' > 8; merge by the smallest stable business resource/domain set\\n');process.exit(2);}
+const planReadPath=path.relative(process.cwd(),planPath).split(path.sep).join('/');
+const planSha256=crypto.createHash('sha256').update(readme).digest('hex');
+const slotTok=v=>String(v).trim().toUpperCase().replace(/[^A-Z0-9]+/g,'-').replace(/^-+|-+$/g,'');
+const partHead=[];for(let i=0;i<allLines.length;i++){if(allLines[i].trim()==='## Scenario Partitions')partHead.push(i);}
+if(partHead.length>1){process.stderr.write('duplicate-scenario-partitions; require at most one exact ## Scenario Partitions section\\n');process.exit(2);}
+const slotByModule=new Map(modules.map(m=>[m.stem,[]]));const unassigned=[];
+if(partHead.length===1){
+  const pStart=partHead[0]+1;let pEnd=allLines.length;for(let i=pStart;i<allLines.length;i++){if(/^##\\s+\\S/.test(allLines[i].trim())){pEnd=i;break;}}
+  const pLines=allLines.slice(pStart,pEnd).filter(l=>l.includes('|'));
+  const pCells=line=>line.split('|').slice(1,-1).map(v=>stripBackticks(v).trim());
+  const pHeader=['Partition ID','Operation','Axis','Domain','Required Slots','Expected by Slot','Bind Rule'];
+  const pH=pLines.findIndex(line=>pHeader.every((v,i)=>pCells(line)[i]===v));
+  if(pH<0){process.stderr.write('MISSING_PARTITION_TABLE: Scenario Partitions section has no canonical header row\\n');process.exit(2);}
+  const pRows=pLines.slice(pH+2).map(pCells).filter(r=>r.length>=7&&r[0]&&r[0]!=='Partition ID');
+  for(const row of pRows){
+    const pid=String(row[0]||'').trim(),op=String(row[1]||'').trim(),domain=String(row[3]||'').split(/[;,，；]/).map(v=>v.trim()).filter(Boolean),optional=/omit/i.test(String(row[4]||'')),bind=String(row[6]||'').trim();
+    const prefix=/^SP-[A-Z0-9][A-Z0-9._-]*$/i.test(pid)?('TP-'+pid.toUpperCase()):('TP-SP-'+slotTok(op)+'-'+slotTok(String(row[2]||'')));
+    const slotIds=[...domain.map(v=>prefix+'-'+slotTok(v)),...(optional?[prefix+'-OMITTED']:[]),prefix+'-NOT-IN-SET'];
+    const owners=modules.filter(m=>(m.ownedRuleKeys||[]).includes(bind)||(m.ownedOperations||[]).some(o=>String(o).replace(/\\s+/g,' ').toUpperCase()===op.replace(/\\s+/g,' ').toUpperCase()));
+    const uniqueOwners=[...new Set(owners.map(o=>o.stem))];
+    if(uniqueOwners.length===1){for(const id of slotIds)slotByModule.get(uniqueOwners[0]).push(id);}
+    else if(modules.length===1){for(const id of slotIds)slotByModule.get(modules[0].stem).push(id);}
+    else unassigned.push(...slotIds);
+  }
+}
+if(unassigned.length){process.stderr.write('unassigned-partition-slots: '+unassigned.join(',')+'\\n');process.exit(2);}
+const slotInventory={schemaId:'backend-test-scenario-partition-slots-v1',planSha256,modules:modules.map(m=>({stem:m.stem,requiredVariantSlots:[...new Set(slotByModule.get(m.stem)||[])]})),unassignedSlotIds:[]};
+fs.mkdirSync(path.join(runDir,'contracts'),{recursive:true});
+fs.writeFileSync(path.join(runDir,'contracts','backend-test-scenario-partition-slots.json'),JSON.stringify(slotInventory,null,2));
+process.stdout.write(JSON.stringify({modules:modules.map(item=>({...item,planReadPath,requiredVariantSlots:(slotInventory.modules.find(m=>m.stem===item.stem)||{requiredVariantSlots:[]}).requiredVariantSlots})),planReadPath,planSha256,moduleLayout:{schemaId:'backend-test-module-layout-facts-v1',source:strictLayout?'task-contract':'plan-derived',contractSha256:strictLayoutSha256,mode:strictLayout&&strictLayout.mode||'business-resource-layout',planRepairAttemptCount:planRepairApplied?1:0,planRepairOutcome:planRepairApplied?'changed':'not-required'},partitionSlots:slotInventory}));
+`;
+    const encoded = deflateRawSync(Buffer.from(script, "utf8")).toString("base64");
+    return `node -e "eval(require('zlib').inflateRawSync(Buffer.from('${encoded}','base64')).toString('utf8'))"`;
+}
+export function buildBackendTestAnalysisHybridDag(sources) {
+    const analysis = buildAnalyzeInputsNode(sources);
+    const contract = buildBackendTestAnalysisContractGateNode(sources);
+    const review = {
+        id: "review-backend-test-analysis-pi",
+        depends_on: [contract.id],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Concise Markdown review of the validated Backend Test Analysis v2 contract, covering source binding, explicit requirement coverage, evidence gaps, risks, and downstream readiness. No file writes.",
+        subtask_prompt: [
+            "Review the validated run-owned `contracts/backend-test-analysis.json` artifact.",
+            "Treat that structured artifact as the authoritative analysis contract; do not substitute the producer's assistant prose.",
+            "Check that every explicit AC/REQ/BR is represented by acceptanceCriteria or an evidenceGap, source references are precise, and unknown behavior remains an evidence gap rather than an invented requirement.",
+            "Summarize source-binding integrity, coverage, risks, evidence gaps, and whether the contract is ready for a later backend-test generation workflow.",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+        ].join("\n\n"),
+    };
+    const closeout = {
+        id: "backend-test-analysis-closeout-static",
+        depends_on: [review.id],
+        role: "closeout",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic handoff pointing to the validated analysis contract and its independent read-only review.",
+        subtask_prompt: "Close the read-only analysis workflow after the structured contract and review both succeed.",
+        static: {
+            resultMarkdown: [
+                "# Backend-test analysis closeout",
+                "",
+                "Validated contract: `contracts/backend-test-analysis.json`.",
+                "Independent review: `review-backend-test-analysis-pi`.",
+            ].join("\n"),
+        },
+    };
+    const spec = {
+        version: 3,
+        title: `Backend test analysis DAG: ${sources.taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, sources.taskConfig.title),
+        successCriteria: [
+            "A strict Backend Test Analysis v2 contract is materialized with immutable source binding",
+            "Every explicit requirement is covered or preserved as an evidence gap",
+            "An independent read-only review consumes the validated structured artifact",
+        ],
+        globalConstraints: [
+            ...sources.taskConfig.hardConstraints,
+            "This workflow is analysis-only: no repository writer, dynamic expansion, test generation, or test execution is allowed.",
+        ],
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: sources.taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        verifyStrategy: resolveDagVerifyStrategy(sources.taskConfig),
+        tasks: [analysis, contract, review, closeout],
+    };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+export async function buildBackendTestGapFillDag(sources) {
+    const { taskConfig } = sources;
+    const ro = commonReadOnlyPaths(sources);
+    const forbidden = commonForbiddenPaths(sources);
+    const intake = await buildBackendTestIntakeContext(sources);
+    const layout = resolveBackendTestLayout(taskConfig.backendTest);
+    const sharedSetup = intake.sharedSetup;
+    const gapDocPath = taskConfig.backendTest?.gapDoc?.trim();
+    if (!gapDocPath) {
+        throw new Error("backendTest.mode=gap-fill requires backendTest.gapDoc pointing at the user missing-scenario document");
+    }
+    const envAllowlist = collectBackendTestShellEnvAllowlist(sources);
+    // N1: reuse the full-chain environment validation unchanged.
+    const environment = {
+        id: "validate-backend-test-environment-shell",
+        depends_on: [],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned reports/backend-test-environment.md with PASS/FAIL runtime, bounded project discovery, fixture and HTML-renderer facts; no secret values.",
+        subtask_prompt: "Fail fast before model work when Python/pytest cannot run in the clean shell. Inspect only bounded common config, conftest, test-root and server-entry candidates; never read .env values or credentials.",
+        shell: {
+            commands: ["python --version", "python -m pytest --version", "python -m pytest --help"],
+            backendTestPipeline: "markdown-environment",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    // N2': deterministic gap ingest (shell pipeline owns parsing + planning).
+    const ingestGap = {
+        id: "ingest-backend-test-gap-shell",
+        depends_on: [environment.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned contracts/backend-test-gap-plan-v1.json with targetModules, newTestPoints, reuseSetupRefs, conflicts, alreadyPresent and exact targetPaths; identity mismatch (taskId/requirement hash) fails closed before any writer runs.",
+        subtask_prompt: "Parse the bound gap document (backend-test-gap-v1) and union it with previous coverage facts missingSlots; emit the deterministic gap plan. No file writes to testcase assets.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "ingest-backend-test-gap",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    // N3': patch README Matrix/Partitions for planned slots only.
+    const patchReadme = {
+        id: "patch-backend-readme-matrix-pi",
+        depends_on: [ingestGap.id],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        writeSet: [layout.readmePath],
+        allowedPaths: [layout.readmePath],
+        forbiddenPaths: forbidden,
+        writerOutcomePolicy: {
+            type: "implementation-outcome-v1",
+            requireChangedFiles: false,
+        },
+        retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+        outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|already-satisfied|blocked. Patch ONLY the Coverage Matrix rows and Scenario Partitions table entries named by contracts/backend-test-gap-plan-v1.json newTestPoints; never rewrite unrelated README sections, never renumber Cases, never add Module Index modules.",
+        subtask_prompt: [
+            "Read contracts/backend-test-gap-plan-v1.json. For each planned slot in newTestPoints, patch the owning Coverage Matrix row (Required Test Points/Case IDs) and, for TP-SP slots, the Scenario Partitions table so the slot is declared. already-satisfied is valid when every planned slot is already present; changed requires a bounded diff limited to the slot rows.",
+            "When every planned slot is already declared, return already-satisfied without editing. Never expand scope beyond newTestPoints; never touch module Markdown or pytest files here.",
+            intake.boundedSourceContext,
+        ].join("\n\n"),
+    };
+    // N4': patch only the planned module Markdown files (map over targetModules).
+    const patchMdCases = {
+        id: "patch-backend-md-cases-map",
+        depends_on: [patchReadme.id],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Serial aggregate of per-module Markdown patch writers; each child writes exactly one planned testcase module file with a bounded append/patch diff.",
+        subtask_prompt: "Expand the gap plan targetModules into one sharded Markdown patch writer child per module and run them serially. Child failures fail-close the map barrier.",
+        static: {
+            resultMarkdown: "Backend-test gap-fill Markdown patch map expansion barrier.",
+        },
+        dynamicExpansion: {
+            type: "map_agent",
+            workflowNodeId: "patch-backend-md-cases-map",
+            itemsFrom: "$.nodes['ingest-backend-test-gap-shell'].json.plan.targetModules",
+            itemName: "item",
+            maxItems: 8,
+            maxExpandedNodes: 8,
+            childIdPrefix: "patch-backend-md-case",
+            tokenBudget: { maxTotalTokens: 1000000 },
+            failOnTokenBudgetExhaustion: true,
+            childTask: {
+                executor: "pi",
+                role: "implementer",
+                skills: BACKEND_TEST_SKILLS_BY_ROLE.implementer,
+                toolProfile: "write",
+                complexity: "LOW",
+                writePolicy: "exclusive",
+                allowedPaths: [`${layout.markdownDir}/{{item.stem}}.md`],
+                forbiddenPaths: forbidden,
+                writeSet: [`${layout.markdownDir}/{{item.stem}}.md`],
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                    requireChangedFiles: false,
+                },
+                retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+                outputContract: "Patch exactly one planned module Markdown file: add missing slot Test Points (existing Case variant lists first; new BE-<MODULE>-<max+1> Case only when no Case can own the slot). Case IDs are never renumbered; sections follow the full-chain contract.",
+                subtaskPromptTemplate: [
+                    "Read contracts/backend-test-gap-plan-v1.json and patch exactly testcase/md/{{item.stem}}.md. For every planned slot owned by this module: prefer appending the variant to the Case named by the plan (or the most related existing Case); create a new Case only when no existing Case can own it, numbering BE-<MODULE>-<NNN> from the module's current maximum +1. Keep every required h3 section; cite Matrix Rule Keys exactly; TP-SP slots use the exact deterministic slot IDs from the plan.",
+                    sharedSetup
+                        ? `When the slot needs shared pre-steps defined by the bound user document, reference them with 引用前置: ${sharedSetup.path}#<SS-ID|SS-DEFAULT> instead of duplicating steps.`
+                        : "Prepare any needed state locally inside this Case (本地准备); no shared setup document is bound.",
+                    "already-satisfied is valid when every planned slot of this module is already covered. Never modify other modules, README, or pytest files.",
+                    intake.boundedSourceContext,
+                ].join("\n\n"),
+            },
+        },
+    };
+    // N5': validate patched Markdown with the same N6 pipeline (partition slots fail-closed).
+    const validateMd = {
+        id: "validate-backend-md-cases-shell",
+        depends_on: [patchMdCases.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned reports/backend-md-case-validation.md, coverage analysis and facts v4 with scenarioPartitions; planned slots must be covered (missingSlots for planned entries fail closed).",
+        subtask_prompt: "Record advisory findings for Markdown structure and deterministically analyze the final README Coverage Scope, Coverage Matrix and Scenario Partitions against final Case rule/test-point bindings. Planned gap slots that remain uncovered fail this node closed.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-cases",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    // N6': patch only the planned pytest modules (append params/functions).
+    const patchPytest = {
+        id: "patch-backend-pytest-cases-map",
+        depends_on: [validateMd.id],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Serial aggregate of per-module pytest patch writers; each child appends to exactly one planned testcase/test_<stem>.py without rewriting the file.",
+        subtask_prompt: "Expand the gap plan targetModules into one sharded pytest patch writer child per module and run them serially. Child failures fail-close the map barrier.",
+        static: {
+            resultMarkdown: "Backend-test gap-fill pytest patch map expansion barrier.",
+        },
+        dynamicExpansion: {
+            type: "map_agent",
+            workflowNodeId: "patch-backend-pytest-cases-map",
+            itemsFrom: "$.nodes['ingest-backend-test-gap-shell'].json.plan.targetModules",
+            itemName: "item",
+            maxItems: 8,
+            maxExpandedNodes: 8,
+            childIdPrefix: "patch-backend-pytest-case",
+            tokenBudget: { maxTotalTokens: 1000000 },
+            failOnTokenBudgetExhaustion: true,
+            childTask: {
+                executor: "pi",
+                role: "implementer",
+                skills: BACKEND_TEST_SKILLS_BY_ROLE.implementer,
+                toolProfile: "write",
+                complexity: "LOW",
+                writePolicy: "exclusive",
+                allowedPaths: [`${layout.scriptDir}/test_{{item.stem}}.py`],
+                forbiddenPaths: Array.from(new Set([
+                    ...forbidden,
+                    `${layout.markdownDir}/**`,
+                    "conftest.py",
+                    "pytest.ini",
+                    "pyproject.toml",
+                    "setup.cfg",
+                ])),
+                writeSet: [`${layout.scriptDir}/test_{{item.stem}}.py`],
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                    requireChangedFiles: false,
+                },
+                retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+                outputContract: "Append-only patch of exactly one planned pytest module: add pytest.param rows / test functions for planned slots with exact TP ids; never rewrite or delete existing functions.",
+                subtaskPromptTemplate: [
+                    "Read contracts/backend-test-gap-plan-v1.json and the patched module Markdown, then patch only testcase/test_{{item.stem}}.py. For each planned slot owned by this module: append an exact literal pytest.param(..., id=\"<slot-id>\") row to the owning Case's primary symbol, or append a new test function test_BE_<MODULE>_<NNN>_<desc> when a new Case was created. Existing functions, params and assertions must remain byte-stable; append-only edits.",
+                    sharedSetup
+                        ? "Reuse the module-top user_shared_setup fixture for shared pre-steps; never re-create documented setup steps inside test bodies, and never create or modify conftest.py."
+                        : "Keep any needed setup local to the new function; never create or modify conftest.py.",
+                    "already-satisfied is valid when every planned slot already has its exact pytest.param id collected. Do not modify Markdown or other modules.",
+                ].join("\n\n"),
+            },
+        },
+    };
+    // N7'-N13': reuse the deterministic collection/repair/gate/trace/manifest chain.
+    const collectionAssess = {
+        id: "assess-backend-pytest-collection-shell",
+        depends_on: [patchPytest.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned collection-v3 facts with repairPaths limited to the gap plan target pytest files.",
+        subtask_prompt: "Resolve final Markdown-mapped scripts; scenario-param assess, pytest --collect-only and no-business-body fixture preflight. Repair eligibility is limited to planned pytest files.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-collection-assess",
+            cwd: ".",
+            timeoutMs: 120000,
+            envAllowlist,
+        },
+    };
+    const repairPytest = {
+        id: "repair-backend-pytest-collection-pi",
+        depends_on: [collectionAssess.id],
+        runIf: "$.nodes['assess-backend-pytest-collection-shell'].json.repairEligible == true",
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: [`${layout.scriptDir}/test_*.py`],
+        allowedPaths: Array.from(new Set([...ro, layout.scriptDir])),
+        forbiddenPaths: Array.from(new Set([
+            ...forbidden,
+            `${layout.markdownDir}/**`,
+            "conftest.py",
+            "pytest.ini",
+            "pyproject.toml",
+            "setup.cfg",
+        ])),
+        writerOutcomePolicy: { type: "implementation-outcome-v1", requireChangedFiles: true },
+        outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|blocked. Repair only generated pytest defects on initial facts repairPaths; preserve every Markdown Case, Test Point, primary symbol and assertion meaning.",
+        subtask_prompt: [
+            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. Treat any upstream `Repair paths:` line as complete authoritative repairPaths evidence. Only planned testcase test_*.py files may change.",
+            "Do not modify Markdown, conftest, pytest config, production code or dependencies. Do not add skip/xfail, remove tests, loosen assertions or replace the real API with mocks.",
+        ].join("\n\n"),
+    };
+    const collectionEffective = {
+        id: "effective-backend-pytest-collection-gate-shell",
+        depends_on: [collectionAssess.id, repairPytest.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Canonical backend-test-execution-readiness.json v2 bound to final asset hashes.",
+        subtask_prompt: "Materialize effective collection facts; eligibility excludes non-exact mappings and unsafe payloads as in the full chain.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-collection-effective",
+            cwd: ".",
+            timeoutMs: 120000,
+            envAllowlist,
+        },
+    };
+    collectionEffective.dependsPolicy = "all-or-condition-skip";
+    const traceability = {
+        id: "backend-test-traceability-gate-shell",
+        depends_on: [collectionEffective.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned traceability and correspondence facts bound after effective collection.",
+        subtask_prompt: "Deterministically scan final readiness-authorized Markdown-mapped pytest scripts; correspondence findings stay advisory.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-traceability",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    const manifest = {
+        id: "backend-test-case-manifest-shell",
+        depends_on: [traceability.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned contracts/backend-test-case-manifest.json materialized only from facts; the single machine input for L-5 and closeout.",
+        subtask_prompt: "Materialize the canonical Backend Test Case Manifest only from coverage and correspondence facts; never re-analyze sources.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-manifest",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    const execute = {
+        id: "execute-backend-pytest-and-html-report-shell",
+        depends_on: [manifest.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "One scoped pytest execution over readiness-authorized eligible items producing pytest-html plus the Chinese HTML report and L-5 dashboard; exit 0/1 with valid evidence continues.",
+        subtask_prompt: `Execute readiness-authorized eligible pytest items once${taskConfig.backendTest?.executeScope === "all"
+            ? " (executeScope=all: every eligible item)"
+            : " (executeScope=affected: prefer newly added planned items when readiness marks them; otherwise every eligible item)"}, render the report, and keep evidence run-owned.`,
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-execute-html",
+            cwd: ".",
+            timeoutMs: taskConfig.backendTest?.executeTimeoutMs ?? 300000,
+            envAllowlist,
+        },
+    };
+    const report = {
+        id: "backend-test-report-shell",
+        depends_on: [execute.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Run-owned backend test Result v1 with pytestExitCode, junit and evidence hashes; failure categories keep product/automation semantics.",
+        subtask_prompt: "Materialize the backend-test Result v1 from the execution evidence; never fabricate metrics.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "markdown-report",
+            cwd: ".",
+            timeoutMs: 60000,
+            envAllowlist,
+        },
+    };
+    const spec = {
+        version: 3,
+        title: `Backend test gap-fill: ${sources.taskId}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: `Incrementally fill backend-test gap scenarios for task ${sources.taskId} from the bound gap document without renumbering existing Cases.`,
+        successCriteria: [
+            "Every planned gap slot is declared in README (Matrix/Scenario Partitions), covered by a Case test point, and collected as an exact pytest.param id",
+            "Existing Case IDs and unrelated modules remain byte-stable; no conftest.py is created or modified",
+            "A second run over a satisfied plan returns already-satisfied with no asset diff",
+        ],
+        globalConstraints: [
+            ...sources.taskConfig.hardConstraints.filter(Boolean),
+            `backendTestGapDoc=${gapDocPath}`,
+            `backendTestExecuteScope=${taskConfig.backendTest?.executeScope ?? "affected"}`,
+        ],
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        verifyStrategy: resolveDagVerifyStrategy(taskConfig),
+        tasks: [
+            environment,
+            ingestGap,
+            patchReadme,
+            patchMdCases,
+            validateMd,
+            patchPytest,
+            collectionAssess,
+            repairPytest,
+            collectionEffective,
+            traceability,
+            manifest,
+            execute,
+            report,
+        ],
+    };
+    spec.backendTestLayout = layout;
+    applyBackendTestWorkspaceControl(spec, taskConfig.backendTest?.workspaceControl ?? "git");
+    if (sharedSetup) {
+        spec.backendTestSharedSetup = { ...sharedSetup };
+    }
+    applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+export async function buildBackendTestHybridDag(sources) {
+    const { taskConfig } = sources;
+    if (taskConfig.backendTest?.mode === "gap-fill") {
+        return buildBackendTestGapFillDag(sources);
+    }
+    const ro = commonReadOnlyPaths(sources);
+    const forbidden = commonForbiddenPaths(sources);
+    const intake = await buildBackendTestIntakeContext(sources);
+    // Plan A: resolve the frozen artifact layout once; every generated path
+    // (README, module Markdown, pytest script, pytest target) derives from it.
+    // Default config resolves to the historical testcase/ layout.
+    const layout = resolveBackendTestLayout(taskConfig.backendTest);
+    const applyLayout = (text) => applyBackendTestLayoutToText(text, layout);
+    // Plan B: when the user binds exactly one shared-setup document, generated
+    // Markdown references it (引用前置/SS-*) and each pytest module hoists the
+    // documented steps into a module-top `user_shared_setup` fixture. Absent the
+    // binding, every prompt below stays byte-identical to the pre-B baseline.
+    const sharedSetup = intake.sharedSetup;
+    const sharedSetupPrompt = sharedSetup
+        ? [
+            "## User shared setup document (bound, read-only)",
+            `A user-provided shared pre-step document is bound at \`${sharedSetup.path}\` (readPath \`${sharedSetup.readPath}\`, sha256 ${sharedSetup.sha256}). Treat it as an authoritative read-only source: never rewrite, split or renumber it, and never invent steps absent from it.`,
+            "When a Case needs a pre-step that this document already defines, the Case MUST reference it instead of duplicating the steps: in `### 前置条件` write `引用前置: <bound-path>#<SS-ID or heading>` lines (plus a `Shared Setup Refs` list of the referenced SS IDs). Extract stable step IDs only from explicit machine IDs (e.g. `SS-1`, `SS-REGISTER-01`); when the document is prose without stable IDs, reference the whole document as `引用前置: <bound-path>#SS-DEFAULT` and do not guess splits. Preparation unique to a Case stays inline but must be labeled `本地准备:`.",
+            "Payload Contract still describes ONLY the target request; setup POST/PUT steps defined by the shared document never redefine the target Case payload contract.",
+        ].join("\n\n")
+        : null;
+    const sharedSetupPytestPrompt = sharedSetup
+        ? [
+            "## User shared setup hoisting (module top)",
+            `The user shared setup document \`${sharedSetup.path}\` (readPath \`${sharedSetup.readPath}\`) defines the common pre-steps. At the TOP of this module file (before any test function), generate exactly one module-scoped fixture named \`user_shared_setup\` implemented by a private helper \`_user_shared_setup()\` that performs the documented shared steps in document order, using the exact resource names/fields from the document. Cases reference these steps via their \`引用前置\` lines; each \`test_BE_*\` body then performs ONLY its target operation and must not repeat documented shared create/setup steps. Generate teardown code only when the user document explicitly documents a cleanup step; never invent a DELETE.`,
+            "Duplication of this prefix across module files is accepted by design: do not extract it into conftest.py, a shared helper module, pytest_plugins, or a `_shared_setup.py`; the module file stays self-contained. NEVER create or modify conftest.py.",
+        ].join("\n\n")
+        : null;
+    const shellNode = (id, depends_on, pipeline, prompt, outputContract, commands = [], timeoutMs = 60000) => ({
+        id,
+        depends_on,
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract,
+        subtask_prompt: prompt,
+        shell: {
+            commands,
+            backendTestPipeline: pipeline,
+            cwd: ".",
+            timeoutMs,
+            ...(commands.length
+                ? { envAllowlist: collectBackendTestShellEnvAllowlist(sources) }
+                : {}),
+        },
+    });
+    const environment = shellNode("validate-backend-test-environment-shell", [], "markdown-environment", "Fail fast before model work when Python/pytest cannot run in the clean shell. Inspect only bounded common config, conftest, test-root and server-entry candidates; never read .env values or credentials.", "Run-owned reports/backend-test-environment.md with PASS/FAIL runtime, bounded project discovery, fixture and HTML-renderer facts; no secret values.", [
+        "python --version",
+        "python -m pytest --version",
+        "python -m pytest --help",
+    ]);
+    // N2 line (sharded): README plan → manifest shell → map_agent barrier.
+    // Each module Markdown card is written by an independent Pi child session
+    // with its own 16K token budget, isolating single-large-file truncation risk.
+    const generateMdPlan = {
+        id: "generate-backend-md-plan-pi",
+        depends_on: [environment.id],
+        role: "planner",
+        executor: "pi",
+        toolProfile: "read-only",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: [],
+        readSet: [
+            toDagSourcePath(sources, sources.requirementPath),
+            ...(sources.constraintMarkdown
+                ? [toDagSourcePath(sources, sources.constraintPath)]
+                : []),
+            ...intake.referenceIndex.map((entry) => entry.readPath),
+            ".harness/dag-runs/**/reports/backend-test-environment.md",
+        ],
+        forbiddenPaths: forbidden,
+        retryPolicy: BACKEND_TEST_MD_PLAN_RETRY_POLICY,
+        outputContract: "Return a Chinese, human-readable Markdown-first plan with Coverage Scope, Coverage Matrix, Scenario Partitions when applicable, and a machine-parseable Module Index. The runtime persists it as a run-owned Harness artifact; do not write testcase/md/README.md, execute pytest, or modify project files.",
+        subtask_prompt: [
+            "This is a required plan-generation node. Read only the strict read set and return the complete Markdown plan in the assistant response. Start the response with the final Markdown artifact immediately; never narrate analysis, reasoning, source summaries, or plans for producing the plan. The runtime persists the response as a run-owned Harness artifact named generate-backend-md-plan-pi/plan.md. Do not write testcase/md/README.md or any project file; module case cards are written by downstream sharded nodes.",
+            "Output budget protocol (hard, max output <=16K per turn): Emit the complete required section skeleton before filling long table rows, including exactly one Module Index table with at least one module row. Never paste full Matrix, case bodies, source text, analysis or reasoning into assistant chat. README holds only Scope+Matrix+module index; never inline full case bodies. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.",
+            "Return the complete plan as plain Markdown. Do not emit JSON or code fences. The plan must contain the exact English protocol headings ## Coverage Scope, ## Coverage Matrix, ## Scenario Partitions when applicable, and ## Module Index. Never translate those headings into 覆盖范围/覆盖矩阵/场景分区/模块索引.",
+            "Read the upstream environment report only through the strict read set. Generate the Markdown-first backend test plan; it will be persisted under the current DAG run's Harness artifacts, not under testcase/md/.",
+            "Write human-readable content in Simplified Chinese by default. Keep English protocol literals exact: section headings, table headers, Partition IDs, TP IDs, Case IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and source citations. Never translate ## Module Index into ## 模块索引.",
+            "Create the concise plan entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in the plan artifact.",
+            "Before the Coverage Matrix, write a mandatory machine-readable `## Coverage Scope` section in the plan artifact using exactly `| Field | Value |`, immediately followed by the separator row `|---|---|`, and these six unique rows: `Change Classification`, `Coverage Policy`, `Affected Operations`, `Affected Rule Keys`, `Regression Floor`, `Scope Evidence`. Always set `Change Classification` to `new-operation` and `Coverage Policy` to `full-contract`; do NOT reason about whether operations are new or existing. Cover all in-scope rules from the requirement document at full depth; treat the product requirement as the coverage baseline and use API contract evidence (fields/status/enum/boundary/format) to supplement scenario dimensions. Scope is limited to operations/rules the requirement document (or its referenced API contract) explicitly describes; do not expand to unrelated operations that the requirement does not mention. List affected operations exactly as `METHOD /path`, stable rule keys separated by semicolons, and precise source pointers as Scope Evidence.",
+            "Coverage depth is full over the in-scope rules: fully cover every documented status, request/response field rule, requiredness, enum, boundary, format, auth and business state of each affected operation the requirement describes, but do not re-test unrelated operations the requirement does not mention. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT.",
+            "Before writing cases, build the mandatory machine-readable Coverage Matrix inside the plan artifact itself. Its section heading line must be exactly `## Coverage Matrix` with no numeric prefix/suffix; never place the canonical Matrix only in a module file. Use this exact header: `| Rule Key | Priority | Source | Endpoint/Field | Dimension | Rule | Required Test Points | Case IDs | Status |`. Every data row must contain exactly 9 pipe-delimited cells and must never omit `Dimension`; use concise dimensions such as requirement, operation, response-status, requiredness, enum, boundary, format, business-state or error. Use only P0/P1/P2 and COVERED/PARTIAL/GAP/CONFLICT. Use stable `TP-<UPPERCASE-HYPHENATED-ID>` test points separated by semicolons.",
+            "Each Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.",
+            "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
+            "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
+            "Mandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden. The Module Stem cell must contain only the plain filename stem; never put Markdown link syntax or a path in that cell.",
+            ...(taskConfig.backendTest?.moduleLayout
+                ? [
+                    "A strict task-contract `backendTest.moduleLayout` is bound and is authoritative over model-derived layout. Reproduce every stem, businessResource, ownedOperations, splitReason, markdownPath and pytestPath exactly; do not add, omit, rename or reorder physical modules. The downstream preflight compares exact path sets and may perform at most one deterministic Plan-only pruning/path normalization; it cannot invent missing Rule/Case ownership.",
+                    `STRICT_BACKEND_TEST_MODULE_LAYOUT=${JSON.stringify(taskConfig.backendTest.moduleLayout)}`,
+                ]
+                : []),
+            `Include exactly one \`## Module Index\` table with this exact header: \`| Module Stem | Business Resource | Owned Operations | Owned Rule Keys | Case IDs | Split Reason | Markdown Path | Pytest Path |\`. The Markdown Path cell must contain exactly one resolved repository-relative path such as \`${layout.markdownDir}/health.md\`; do not emit a Markdown link or repeat the path. Split Reason is exactly one of \`explicit-user-layout\`, \`primary-business-resource\`, \`independent-business-resource\`, \`output-budget\`. Group by stable business resource/domain, not by CRUD operation, AC, parameter/field axis, scenario type or regression purpose: one resource's list/detail/create/update/delete and its filters/response assertions/regression floor belong in one module. Multiple modules owning the same exact \`METHOD /path\` are forbidden unless every such row is \`explicit-user-layout\` from primary-requirement path pairs or has a documented \`output-budget\` proof. Keep the total module count at the smallest safe value and never exceed 8 modules. Name model-derived modules with stable lowercase business stems such as \`health\` or \`resource_notes\`; explicit-user-layout preserves the primary requirement filename stem even when it is more specific. Do not use priority-only stems \`p0\`, \`p1\` or \`p2\`; Priority belongs only in the Coverage Matrix. Pure hexadecimal/hash-like opaque stems and test-purpose-only stems are forbidden. Do not use Case-ID-like module filenames. Markdown Path, Pytest Path and downstream automation mapping must be one-to-one and exact; for model-derived modules the default pair remains \`${layout.markdownDir}/<module>.md\` and \`${layout.scriptDir}/test_<module>.py\`, while explicit-user-layout preserves the primary requirement paths. Do not hand-write a conflicting module count in prose; the Module Index row count is the only count truth.`,
+            "Scenario Partitions (query/filter axes): inspect every affected GET/list operation for query/path parameters whose bound source documents a finite enum or classification domain. If at least one such axis exists, add exactly one machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row and one row per eligible axis. If no affected axis has a source-backed finite domain, omit the entire `## Scenario Partitions` heading and section; do not emit an explanatory prose-only section. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional. Before returning, expand every declared partition into its complete deterministic exact slot ID set: one `TP-<Partition ID>-<VALUE-TOKEN>` per Domain value, `TP-<Partition ID>-OMITTED` only for an optional axis, and exactly one `TP-<Partition ID>-NOT-IN-SET`. Every expanded slot ID must appear verbatim in the binding Rule's `Required Test Points` cell and be assigned to concrete Case IDs in that same Coverage Matrix row; ordinary alias/family Test Points do not replace this inventory. Scheme A: Case count may be smaller than the enum count, but every exact slot still needs an independent variant Test Point and pytest.param id; never use SINGLE/MULTIPLE aliases as coverage. Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
+            "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
+            ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
+            intake.boundedSourceContext,
+            "## Authoritative reference index",
+            JSON.stringify(intake.referenceIndex, null, 2),
+            "For each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
+            "Read only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
+        ].join("\n\n"),
+    };
+    const materializeMdManifest = {
+        id: "materialize-backend-md-module-manifest-shell",
+        depends_on: [generateMdPlan.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the run-owned generate-backend-md-plan-pi/plan.md artifact after strict-layout validation and at most one deterministic Plan-only repair.",
+        subtask_prompt: "Parse only $HARNESS_DAG_RUN_DIR/generate-backend-md-plan-pi/plan.md, validate the optional strict module layout and output-budget proof, apply at most one deterministic Plan-only Module Index repair without project writes, then emit one JSON line. No testcase/md/README.md fallback.",
+        shell: {
+            commands: [buildBackendTestModuleManifestShellCommand(layout, taskConfig.backendTest?.moduleLayout)],
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+    const generateMdCasesMap = {
+        id: "generate-backend-md-cases-map",
+        depends_on: [materializeMdManifest.id],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Serial aggregate of sharded Markdown module case-card writers. Each child writes exactly one testcase/md/<stem>.md with its own 16K Pi budget.",
+        subtask_prompt: "Expand the README module manifest into one sharded Markdown writer child per module and run them serially. Child failures fail-close the map barrier.",
+        static: {
+            resultMarkdown: "Backend-test Markdown case-card map expansion barrier.",
+        },
+        dynamicExpansion: {
+            type: "map_agent",
+            workflowNodeId: "generate-backend-md-cases-map",
+            itemsFrom: "$.nodes['materialize-backend-md-module-manifest-shell'].output.modules",
+            itemName: "item",
+            maxItems: 8,
+            maxExpandedNodes: 8,
+            childIdPrefix: "generate-backend-md-case",
+            tokenBudget: { maxTotalTokens: 3000000 },
+            failOnTokenBudgetExhaustion: true,
+            childTask: {
+                executor: "pi",
+                role: "implementer",
+                skills: BACKEND_TEST_SKILLS_BY_ROLE.implementer,
+                toolProfile: "write",
+                complexity: "MED",
+                writePolicy: "exclusive",
+                allowedPaths: ["{{item.markdownPath}}"],
+                forbiddenPaths: forbidden,
+                writeSet: ["{{item.markdownPath}}"],
+                readSet: [
+                    "{{item.planReadPath}}",
+                    toDagSourcePath(sources, sources.requirementPath),
+                    ...(sources.constraintMarkdown
+                        ? [toDagSourcePath(sources, sources.constraintPath)]
+                        : []),
+                    ...intake.referenceIndex.map((entry) => entry.readPath),
+                    "{{item.markdownPath}}",
+                ],
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                    requireChangedFiles: true,
+                },
+                retryPolicy: BACKEND_TEST_MARKDOWN_BINDING_RETRY_POLICY,
+                outputContract: "Write exactly the frozen `{{item.markdownPath}}` Chinese module Markdown case-card file with BE-<MODULE>-<NNN> cases and the seven required h3 sections; keep machine IDs/literals exact and do not execute pytest or modify production code/config or the README.",
+                subtaskPromptTemplate: [
+                    "This is a required file-generation node for exactly one Markdown module. Read the upstream run-owned Markdown plan artifact at `{{item.planReadPath}}` (Coverage Scope + Coverage Matrix + Module Index) and the bounded references, then immediately use write tools to create the single frozen file `{{item.markdownPath}}`. Do not read or recreate testcase/md/README.md. Do not end after analysis or planning, and do not return before a non-empty bounded diff exists. Do not modify any other module file.",
+                    "Output budget protocol (hard, max output <=16K per turn): Never paste full Matrix, other modules' case bodies, or source text into assistant chat. Each write/edit tool call touches at most one file (this module). Compact tables/lists are required; omitting required sections or in-scope variants is forbidden. If a Completeness Gate / OUTPUT_LIMIT_RECOVERY retry is injected, continue only listed target paths.",
+                    "The first non-empty response line must be exactly IMPLEMENTATION_OUTCOME: changed after the module file has been written, or IMPLEMENTATION_OUTCOME: blocked when precise missing evidence prevents safe generation. already-satisfied is not valid for this node.",
+                    "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
+                    'Write the module {{item.stem}} as readable case cards covering every in-scope rule/Test Point the README Coverage Matrix assigns to this module. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. `<NNN>` is exactly three zero-padded digits (`001`, `002`, ...), never two digits (`01`), a bare number, or an alphabetic suffix such as `011A`. Every case must include `### 覆盖规则`, `### 测试点`, `### 场景类型`, `### 前置条件`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射` Do not group cases under "## 测试类 ..." (or any h2 grouping) headings that force Cases down to h3; each Case must be a direct h2 (`##`), and its seven sections must be h3 (`###`) children of that Case. If you need to convey a pytest class, state it inside the Case\'s `### 自动化映射` instead. Forbidden: `## 测试类 X` then `### BE-PD-001` and `### 覆盖规则` at the same h3 level. Required: `## BE-PD-001` then `### 覆盖规则`.; `覆盖规则` and `测试点` must reference exact Matrix Rule Keys/Test Points. Add `测试目的`, `验收标准`, `需求依据`, and `测试数据` for readable evidence. The `验收标准` section must list the exact applicable `AC-...` IDs, and every explicit task AC must appear in at least one Case. Every automatable case explicitly names its target pytest script and exactly one primary symbol so traceability scans only that script/symbol. Evidence-only meta cases that exist solely for non-executable assertion/cross-cutting process evidence may declare `脚本：无` and `primary symbol：无` with empty `变体测试点`, and must not invent a business pytest item.',
+                    "Name this module file with the exact frozen Module Index stem `{{item.stem}}` (filename `{{item.markdownPath}}`). Never reinterpret or rename an explicit-user-layout stem. Priority-only stems `p0`, `p1` and `p2` are forbidden and must never produce `p0.md` or `test_p0.py`. Pure hexadecimal/hash-like opaque stems such as `a401606` and `deadbeef` are also forbidden. Do not use Case-ID-like module filenames. For every automatable case, `自动化映射` must name exactly `{{item.pytestPath}}`, where the module stem is this Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `health` → `testcase/test_health.py`; `resource_notes` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
+                    "AUTOMATION_BINDING_FORMAT_V1 is a literal machine contract. Under every Case's `### 自动化映射`, write these independent lines exactly: `- 脚本：<path|无>`, `- primary symbol：<symbol|无>`, `- 变体测试点：<semicolon-separated TP IDs|无>`, `- 场景断言测试点：<semicolon-separated TP IDs|无>`, `- 横切证据测试点：<semicolon-separated TP IDs|无>`. TP IDs must be on the same line after the colon. Forbidden classification forms include `TP-X（变体测试点）`, `[变体测试点] TP-X`, `【变体测试点】：TP-X`, pipe-delimited annotations, tables, or nested TP lists. Before returning, verify that the Case `### 测试点` exact set equals the pairwise-disjoint union of the three canonical binding lines; do not add, remove, rename or duplicate a TP to make the format pass.",
+                    "Scenario Partition slots: requiredVariantSlots for this module are `{{item.requiredVariantSlots}}`. Every listed ID MUST appear in this module's Cases as exactly one variant Test Point in both `### 测试点` and `变体测试点`. Slot IDs copy the declared Partition ID exactly; never drop the HTTP method, invent, merge, renumber or split slot IDs. Ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Scheme A: one Case may carry many slots; do not create one Case per enum value just to match Case count. Prefer ONE Case per partition with a parameter table over duplicated Cases per value. The not-in-set slot value must be a concrete literal absent from the Domain (e.g. `UNKNOWN_TYPE`) and its expected result must come from the bound source — when Expected by Slot is GAP, the Case states the expectation as GAP evidence, never a guessed 空列表/400. Never create cross-axis combination variants beyond the single documented nominal.",
+                    "For every variant Test Point, write its machine-checkable `场景意图: <TP-ID>; operation=...; target=...; intent=...` line inside that same Case body/自动化映射. Never collect Scenario Intent lines in a file-level appendix, implementation-details block, or another Case; local TP ownership is mandatory.",
+                    "Every Case must keep at least one numbered executable line under `### 操作步骤`; a compact variant/result table may follow but must not replace the numbered action anchor. Keep numbered/bulleted independently assertable results under `### 预期结果`. The exact `### 操作步骤` and `### 预期结果` headings must remain present for every Case, including compact/table-based Cases; never compress later Cases by dropping required headings. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
+                    "In every `自动化映射`, use exactly these machine-readable list labels: `脚本`, `primary symbol`, `变体测试点`, `场景断言测试点`, `横切证据测试点`, plus a deterministic payload contract. For operations without a request body write `Payload Contract: none`. Otherwise write `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum` (write `none` when there is no enum); nested fields use dot paths such as `approver.name`. Each Case describes exactly one target request payload contract: put every payload label on its own list line, never concatenate multiple operations or setup POST/PUT contracts into one label line, and never repeat a `Payload Contract:` token inside explanatory prose/details after the machine-readable line. Values must come only from bound API/DTO evidence, never guesses. Each Test Point from `### 测试点` must appear in exactly one binding list, and every Test Point named in any binding list must also be declared in that Case's `### 测试点`; write `无` for an empty list. A variant Test Point is atomic: one exact endpoint/input/precondition/outcome row equals one exact pytest item and one exact TP ID. If a parameter table has five rows, declare five distinct variant TP IDs in Markdown; never declare one family TP and append row suffixes only in pytest. Classify as `variant` only when endpoint, request input, precondition business state, or expected outcome genuinely changes and therefore needs an independent pytest parameter item. Classify CRUD checkpoints, status/body/header/schema assertions and multiple checks over the same response/journey as `assertion`; classify shared HTTP logging/redaction/truncation evidence as `cross-cutting`. Never create a Test Point merely to parameterize a checkpoint. Every non-cross-cutting TP ID is owned by exactly one Case; when the same response/schema/error assertion is needed in different Cases, use distinct Case-specific TP IDs instead of reusing one assertion TP across Cases. Keep the script path identical to the module one-to-one path and declare exactly one primary symbol named with the canonical Case prefix, for example `BE-RN-003` → `test_BE_RN_003_<description>`; non-Case-prefixed primary symbols are forbidden because parameterized item association must remain deterministic. For evidence-only meta Cases with no executable business journey, write `脚本：无` and `primary symbol：无`, keep `变体测试点：无`, and place process evidence only in assertion/cross-cutting lists. If the bound contract only says an identifier is returned/present, do not declare a concrete identifier type. If a 404 Case needs a nonexistent path identifier but its syntax/type is unspecified, define a create-delete-derived valid identifier journey instead of an arbitrary UUID/text placeholder. For redaction scenarios, list sensitive header/field key names only. Never write any header-name-and-value pair, credential placeholder, fake token, anti-example, or other secret-shaped literal in Markdown; state only that a test-only value is supplied at runtime and omitted. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
+                    ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
+                    intake.boundedSourceContext,
+                    "## Authoritative reference index",
+                    JSON.stringify(intake.referenceIndex, null, 2),
+                    "For each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
+                    "Read only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
+                ].join("\n\n"),
+            },
+        },
+    };
+    const reviewCases = {
+        id: "review-and-revise-backend-md-cases-pi",
+        depends_on: [generateMdCasesMap.id, materializeMdManifest.id],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: [`${layout.markdownDir}/**`],
+        readSet: [
+            ".harness/dag-runs/**/generate-backend-md-plan-pi/plan.md",
+            toDagSourcePath(sources, sources.requirementPath),
+            ...(sources.constraintMarkdown
+                ? [toDagSourcePath(sources, sources.constraintPath)]
+                : []),
+            ...intake.referenceIndex.map((entry) => entry.readPath),
+            `${layout.markdownDir}/*.md`,
+        ],
+        allowedPaths: Array.from(new Set([...ro, `${layout.markdownDir}/**`])),
+        forbiddenPaths: Array.from(new Set([...forbidden, layout.readmePath])),
+        writerOutcomePolicy: { type: "implementation-outcome-v1" },
+        outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|already-satisfied|blocked. Perform exactly one bounded incremental synchronization of testcase/md/** against all bound source references; preserve valid Cases and report a concise summary.",
+        subtask_prompt: [
+            "Perform one gap-targeted synchronization, not a full-suite rewrite or stylistic review. Read the immutable run-owned Markdown plan from the direct upstream manifest's planReadPath. Start from explicit bound source IDs/error codes/DTO fields/normative quoted rules and the plan Coverage Matrix; open and edit only modules that own a missing or conflicting rule. Never create or edit testcase/md/README.md and never modify the run-owned plan artifact. Preserve unrelated valid modules byte-for-byte and avoid optional wording cleanup.",
+            "Output budget protocol: never dump full Matrix/case bodies into assistant chat. Inspect the immutable run-owned plan first, build a concise target list from its Matrix and Module Index, then read/write only target modules one file per tool call. Do not traverse every module when the Matrix and source token inventory show no gap; return `already-satisfied`. When adding omitted in-scope cases, keep every required section. Do not bulk-delete in-scope cases to save tokens.",
+            "For every variant Test Point, ensure the Markdown scenario intent is machine-checkable and located inside that same Case body/自动化映射, never in a file-level appendix, implementation-details block, or another Case. Use an exact transport target: `场景意图: <TP-ID>; operation=<METHOD /path>; target=<body.field|query.field|path.field|header.field|request>; intent=<empty|missing|null|min-1|min|max|max+1|pattern-invalid|enum-invalid|wrong-type|nominal-operation|custom-literal:V>; bound=<n optional>; example=<optional>; expectedCode=<optional>`. Never use vague targets such as field=resource/health. Keep pytest params aligned to the exact target. For intent=missing/empty/default-omit, pytest may use `_OMIT` or delete the key; for intent=enum-invalid use a concrete invalid enum literal (for example `UNKNOWN_STATUS`), never `_OMIT`/missing-key; for trim/padded samples use `custom-literal:trim` or a real padded string, not a bare token like `filter-active` when the intent is `custom-literal:ACTIVE`.",
+            "Treat the requirement document as the coverage baseline; scope is limited to operations/rules it (or its referenced API contract) describes, and API contract evidence supplements scenario dimensions. For every in-scope operation, check applicable lifecycle/uniqueness states (including deleted-existing when in scope), valid enum values, bounded invalid classes, min-1/min/nominal/max/max+1, allowed/forbidden format classes, required/null/missing/wrong-type semantics, status/error codes, auth and state transitions. Inspect shared validator/helper/DTO/query builder evidence and expand Affected Operations when the same affected path can affect them; unresolved impact stays visible as GAP/CONFLICT. Directly add in-scope omissions; reject scope expansion to operations absent from the requirement document; undefined impact remains GAP/CONFLICT rather than invented behavior.",
+            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Require the exact `## Coverage Scope` Field/Value table with the `|---|---|` separator row, a valid classification-policy pair, non-empty Affected Operations/Rule Keys/Scope Evidence, and the classification-specific Regression Floor. Require the exact unnumbered `## Coverage Matrix` heading in the immutable run-owned plan artifact, exact headers, exactly 9 cells in every data row (including a non-empty Dimension), deterministic OpenAPI Rule Keys for every in-scope affected operation, exactly one Matrix row per Rule Key (merge multi-dimension product rows), and bidirectional Matrix Rule/Test Point ↔ Case bindings. Never describe affected-scope coverage as whole-API completeness. Every explicit AC ID must appear in at least one Case `验收标准`; every explicit in-scope AC/REQ/BR Rule Key cited by a Case must have exactly one Coverage Matrix row, and no Case may cite a source Rule Key omitted from the Matrix. Every Matrix Case ID must share at least one of that row's Required Test Points and the Case must cite that Rule Key. Perform an explicit execution-redundancy review: merge checkpoint-only parameter rows, repeated default/read-back assertions, DELETE status/body/follow-up-read checks, response schema/Content-Type checks, PUT full-update/timestamp checks, repeated list setup and identical null/empty inputs when endpoint, input partition, precondition state and expected outcome are the same. Preserve separate POST/PUT, boundary, enum, wrong-type, role/tenant and distinct business-state variants. Directly repair malformed headings/rows/keys and binding modes rather than merely commenting on them. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, a `### 操作步骤` section that contains only a table without any numbered executable line, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), dropped exact `### 操作步骤`/`### 预期结果` headings, and missing or drifted script/function mapping where it can be derived.",
+            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, preserve every frozen Module Index filename exactly (never rename an explicit-user-layout module; model-derived invalid stems must have been rejected before map expansion), normalize every Case ID to hyphen-separated module segments plus exactly three zero-padded digits (`BE-RESOURCE_NOTES-01` → `BE-RESOURCE-NOTES-001`; `BE-RN-011A` must be renumbered or merged) consistently across headings/index/mappings, fix automation mappings so each automatable case points at `testcase/test_<module>.py` derived from that module filename and declares exactly one primary symbol (evidence-only meta cases may keep `脚本/primary symbol=无` with empty variants), assign every Test Point exactly one of `变体测试点`/`场景断言测试点`/`横切证据测试点`, then perform an exact-set check: each Case's `### 测试点` set must equal (not merely contain) the union of those three binding lists; delete stale/legacy aliases and ensure every binding-list Test Point is present, expand every variant parameter row into its own atomic TP ID, make every non-cross-cutting TP Case-specific and owned by exactly one Case, require every primary symbol to start with the canonical Case prefix, ensure every explicit AC ID appears in an applicable Case `验收标准`, merge execution duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Remove every credential/header value, placeholder, fake token and anti-example from Markdown. Sensitive key names may remain only as a plain list; values must be described as runtime-only and omitted, with no colon/value pair or literal example anywhere, including details blocks and explanatory text. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations as exact machine-readable identifiers; only normalize Case ID separator/sequence formatting as specified above. Recalculate predicted collected items as `sum(max(1, variant count per Case))`; when the task declares a budget, directly merge redundant journeys/reclassify same-request checkpoints until the prediction is within budget, while preserving all required coverage. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
+            "This is the single Markdown incremental synchronization round. Read every authoritative reference index entry whose role hints include acceptance-criteria, api-contract, data-contract or business-rule; do not rely on the derived PRD as a complete inventory. Preserve every explicit AC/REQ/BR ID, every documented HTTP/business error code, every DTO/JSON field, enum value, boundary, format, nested shape, transaction/state/idempotency/uniqueness/auth/tenant/cross-field rule. For each natural-language normative business rule preserved as required scope, include its exact source sentence without paraphrase together with source path and line/heading anchor so the deterministic ledger can verify quote/hash provenance. Ensure every Case declares exactly `Payload Contract: none` or the three labels `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; every label must occupy its own machine-readable list line, and a Case must never concatenate target/setup operations or multiple `Payload Contract` tokens onto one line, and explanatory prose/details must not repeat any `Payload Contract:` token; never infer missing keys or enum values. A target GET/DELETE operation with no request body must remain `Payload Contract: none` even when its setup journey performs POST/PUT with a DTO; setup payloads never redefine the target Case payload contract. Add only missing Matrix rows/Test Points/Cases/assertions or repair exact drift; do not rewrite already-valid unrelated modules. Work gap-targeted: inspect source anchors and affected modules first, leave unrelated valid modules byte-stable, and return `already-satisfied` without restating the full suite when no gap exists.",
+            "For affected API fields, use one valid nominal payload plus atomic required/missing/null/empty/wrong-type, every documented enum value plus bounded invalid classes, documented min-1/min/nominal/max/max+1, formats and nested object/array constraints. Do not generate a Cartesian product or invent undocumented constraints. Do not invent a concrete identifier type when the source only requires presence; for a missing-resource 404 path with unspecified identifier syntax/type, synchronize the Case to a create-delete-derived valid identifier journey rather than an arbitrary UUID/text placeholder.",
+            "Scenario Partitions synchronization: when the run-owned plan declares `## Scenario Partitions`, verify each declared partition's slots are fully materialized as variant Test Points with exact `TP-<Partition ID>-...` IDs (each-value per Domain value, OMITTED only for optional axes, exactly one NOT-IN-SET with intent=enum-invalid). Before returning, derive the complete exact slot set from every legal Scenario Partitions row and compare it with both the binding Coverage Matrix Rule's Required Test Points and the final Case `### 测试点`/`变体测试点` sets; directly add every missing exact slot to the already-assigned Case IDs; ordinary alias Test Points do not satisfy a partition slot, and aggregate aliases such as `SINGLE`/`MULTIPLE` are forbidden. Scheme A: keep existing Case structure and add missing exact variant Test Points to already-assigned Cases instead of creating one Case per enum value. Directly add missing slot rows/Cases. Record an illegal plan Partition row that has no source-backed finite domain as GAP/CONFLICT and remove only its derived `TP-SP-*` slots/Cases from target modules; never modify the immutable plan artifact. Never delete a legal source-backed partition or drop its complement slot to force coverage green. When the bound source does not document the complement expectation, keep the slot with GAP expected instead of guessing. Body-field validation enums (`TP-<FIELD>-ENUM-*`) are NOT partitions — do not add partition rows for them.",
+            "Before returning, verify that every explicit source AC/REQ/BR, error code and strong DTO field token appears in the run-owned plan or an applicable module Case. If a fact cannot be safely automated, retain it as GAP/CONFLICT with its exact source pointer instead of dropping it. Return already-satisfied only when no target file needs an incremental edit.",
+            "Read only indexed source paths. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
+            ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
+            intake.boundedSourceContext,
+            "## Authoritative reference index",
+            JSON.stringify(intake.referenceIndex, null, 2),
+            "For each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
+        ].join("\n\n"),
+    };
+    const validateCases = shellNode("validate-backend-md-cases-shell", [reviewCases.id], "markdown-cases", "Record advisory findings for Markdown structure and deterministically analyze the final README Coverage Scope and Coverage Matrix against final Case rule/test-point bindings. Validate the classification-policy pair, affected operations/rules, scope evidence and regression floor; require documented OpenAPI completeness only for declared affected operations, while all explicit AC/REQ/BR remain in scope. Detect missing in-scope product/API rules, enum values, invalid equivalence classes, boundaries, format classes, business lifecycle states, GAP/CONFLICT, bidirectional Matrix/Case drift, non-canonical Case IDs, unclassified Test Points, duplicate binding modes and non-cross-cutting Test Points bound by multiple Cases. Do not validate source-reference existence. Write human and machine evidence from the same facts. Keep quality findings advisory, but fail closed after writing the report when secret-shaped values are detected. Coverage FAIL stays advisory.", "Run-owned reports/backend-md-case-validation.md, reports/backend-test-case-coverage-analysis.md and contracts/backend-test-case-coverage-facts.json v4 with Coverage Scope plus PASS/FAIL/UNAVAILABLE advisory facts; downstream execution continues.");
+    if (sharedSetup) {
+        validateCases.subtask_prompt += ` Deterministically verify shared setup references: every 引用前置 line must cite exactly the bound path ${sharedSetup.path} with a stable SS anchor (or SS-DEFAULT); any other citation, unbound path, invented step ID or 引用前置 line without a bound document is a FAIL finding. Never rewrite the user document.`;
+    }
+    // N5 line (sharded): pytest shared-asset plan → manifest shell → map_agent barrier.
+    // Shared helpers/factories are written once by the plan node; each module's
+    // test_<stem>.py is written by an independent Pi child (own 16K budget).
+    const generatePytestPlan = {
+        id: "generate-backend-pytest-plan-pi",
+        depends_on: [validateCases.id],
+        role: "implementer",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Deterministic pytest generation handoff. Per-module map children write self-contained test_<module>.py files with bounded local fixtures, HTTP logging/redaction and payload builders; no model invocation, JSON, shared-asset writes or pytest execution.",
+        subtask_prompt: [
+            "Convert testcase/md/** into pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. This node is a deterministic handoff: NO shared helper/factory/fixture files are generated anywhere in the pipeline; each module's self-contained test_<module>.py (module-local fixtures, HTTP logging/redaction, payload builders) is written by a downstream sharded node. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.",
+            "Output budget protocol (hard, max output <=16K per turn): downstream module writers write exactly one test_<module>.py per write/edit tool call. Never paste full Python modules into assistant chat. Do not reduce params/assertions/skips semantics to fit.",
+            "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict. Path/query/header identifiers and scenario-control metadata (including `id`, expected codes, and selector labels) must stay in separate pytest parameters and helper arguments; never merge them into a DTO patch or JSON body unless that exact path is allowed by the Markdown payload contract. Normalize the configured API base URL with `rstrip(\"/\")` (or equivalently join exactly one slash) before appending endpoint paths; generated requests must never contain a `//api/...` path. When the bound source documents a concrete non-secret local API URL, generated clients must use it as the fallback in `os.environ.get(\"API_BASE_URL\", \"<documented-url>\")`; do not require an otherwise-uninjected environment variable or fail setup solely because it is absent. Missing-field helpers must remove keys idempotently with `payload.pop(field, None)`, never `del payload[field]`, because optional fields may already be absent.",
+            "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. If shared pytest fixtures are generated, keep their dependency graph in one provider module and require each downstream test module to register that provider with an exact pytest_plugins tuple; importing only the outer fixture is insufficient and will be rejected by fixture-resolution preflight.",
+            "HTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.",
+            "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
+            "Before logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.",
+            "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
+        ].join("\n\n"),
+        static: {
+            resultMarkdown: "Shared pytest plan is deterministic: each downstream module writer owns one self-contained test_<module>.py and must not depend on generated shared helper/factory files.",
+        },
+    };
+    const materializePytestManifest = {
+        id: "materialize-backend-pytest-module-manifest-shell",
+        depends_on: [generatePytestPlan.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ro,
+        forbiddenPaths: forbidden,
+        outputContract: "Stdout JSON {modules:[{stem,planReadPath}],planReadPath,planSha256,moduleLayout} parsed from the final strict-layout-validated run-owned Markdown plan artifact, matching the Markdown map manifest.",
+        subtask_prompt: "Parse only the final run-owned generate-backend-md-plan-pi/plan.md artifact with the same strict module-layout and output-budget contract; do not search for or fall back to testcase/**/README.md. No project file writes.",
+        shell: {
+            commands: [buildBackendTestModuleManifestShellCommand(layout, taskConfig.backendTest?.moduleLayout)],
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+    const generatePytestCasesMap = {
+        id: "generate-backend-pytest-cases-map",
+        depends_on: [materializePytestManifest.id],
+        role: "verifier",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Serial aggregate of sharded pytest module writers. Each child writes exactly one self-contained testcase/test_<stem>.py with its own 16K Pi budget and no generated shared-asset dependency.",
+        subtask_prompt: "Expand the README module manifest into one sharded pytest writer child per module and run them serially. Child failures fail-close the map barrier.",
+        static: {
+            resultMarkdown: "Backend-test pytest module map expansion barrier.",
+        },
+        dynamicExpansion: {
+            type: "map_agent",
+            workflowNodeId: "generate-backend-pytest-cases-map",
+            itemsFrom: "$.nodes['materialize-backend-pytest-module-manifest-shell'].output.modules",
+            itemName: "item",
+            maxItems: 8,
+            maxExpandedNodes: 8,
+            childIdPrefix: "generate-backend-pytest-case",
+            tokenBudget: { maxTotalTokens: 3000000 },
+            failOnTokenBudgetExhaustion: true,
+            childTask: {
+                executor: "pi",
+                role: "implementer",
+                skills: BACKEND_TEST_SKILLS_BY_ROLE.implementer,
+                toolProfile: "write",
+                complexity: "MED",
+                writePolicy: "exclusive",
+                allowedPaths: ["{{item.pytestPath}}"],
+                forbiddenPaths: Array.from(new Set([
+                    ...forbidden,
+                    "testcase/md/**",
+                    "conftest.py",
+                    "pytest.ini",
+                    "pyproject.toml",
+                    "setup.cfg",
+                ])),
+                writeSet: ["{{item.pytestPath}}"],
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                    requireChangedFiles: true,
+                },
+                retryPolicy: BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY,
+                outputContract: "Write exactly the frozen pytest module file `{{item.pytestPath}}` whose actual test function region contains the exact Case ID, preferably in the function name or docstring. the frozen `{{item.markdownPath}}` maps one-to-one to `{{item.pytestPath}}`; never merge or split modules. No JSON and no pytest execution.",
+                subtaskPromptTemplate: [
+                    "Convert the single frozen Markdown module `{{item.markdownPath}}` into one self-contained pytest module. Before writing, also read the run-owned Markdown plan artifact at `{{item.planReadPath}}` and use its explicit API target/environment table as the authoritative fallback base URL for every module. A task/Markdown `API_BASE_URL` target takes precedence over project README dev-server URLs; never infer a backend API fallback from a frontend/Vite port such as localhost:3000. After reading the module Markdown, the run-owned plan artifact, and the bounded pytest config/conftest, immediately use write tools to create the single frozen file `{{item.pytestPath}}`. Define any bounded HTTP client fixture, request logging/redaction/truncation helper and payload builders needed by this module inside that same file; do not import generated testcase/**/helpers/** or testcase/**/factories/** assets. Do not end after analysis or planning. Do not modify Markdown, conftest, helpers/factories, or any other module's pytest script.",
+                    "Output budget protocol (hard, max output <=16K per turn): Write exactly the frozen `{{item.pytestPath}}`. Never paste full Python modules into assistant chat. Do not merge or split modules. Do not reduce params/assertions/skips to fit. If OUTPUT_LIMIT_RECOVERY is injected, continue only listed missing/broken scripts.",
+                    "Align every variant pytest.param payload with the Markdown scenario intent (empty/missing/null/length/pattern/enum/wrong-type/nominal). Prefer literal payloads over Faker for intent-critical fields so pre-execution scenario-param checks can verify them. Hard contract: intent=enum-invalid MUST pass a concrete invalid value literal (string/number/boolean), never `_OMIT`/None/missing key; intent=missing/empty may use `_OMIT` or delete the key; intent=custom-literal:trim|whitespace-padded requires a leading/trailing whitespace string with non-empty trimmed content (all-whitespace belongs to empty/whitespace-only, not trim); intent=custom-literal:ACTIVE|ARCHIVED requires the exact enum string, never descriptive tokens like filter-active; intent=max/min/max+1 should pass a repeated-string length expression, a bare length number N, or a helper named _*_LEN{N} / _*_MAX_LENGTH / _*_OVER_LENGTH — never a bare 1 for oversize. Hard contract: request payload dicts may only contain DTO field keys from Payload Allowed Paths; never put expect/expected/echo_* helper keys inside the JSON body dict. Path/query/header identifiers and scenario-control metadata (including `id`, expected codes, and selector labels) must stay in separate pytest parameters and helper arguments; never merge them into a DTO patch or JSON body unless that exact path is allowed by the Markdown payload contract. Normalize the configured API base URL with `rstrip(\"/\")` (or equivalently join exactly one slash) before appending endpoint paths; generated requests must never contain a `//api/...` path. When the bound source documents a concrete non-secret local API URL, generated clients must use it as the fallback in `os.environ.get(\"API_BASE_URL\", \"<documented-url>\")`; do not require an otherwise-uninjected environment variable or fail setup solely because it is absent. Missing-field helpers must remove keys idempotently with `payload.pop(field, None)`, never `del payload[field]`, because optional fields may already be absent.",
+                    "For every response contract that requires an object or pagination envelope, first assert that each envelope/data value is a dict and that required keys exist, then index fields and assert values. Never let an incidental KeyError or list/string TypeError stand in for the explicit response-shape contract failure.",
+                    'Ensure every automatable final Markdown Case ID in this module appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. Skip evidence-only meta Cases that declare `脚本/primary symbol=无` with empty variants; do not invent a business pytest symbol for them. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id="TP-...")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. A Case with exactly one variant Test Point still needs one literal `pytest.param(..., id="TP-...")` row; never leave a single-variant Case as a bare function with the TP only in the docstring. Use a literal direct `pytest.param(..., id=...)` expression for every row; never hide or wrap it behind `_post_case`, `_put_case`, row-factory functions, comprehensions, generators, or dynamically returned parameter lists; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. Governance-only cross-cutting bindings such as writeSet compliance, execution count, report existence, or orchestration state are metadata-only in business pytest: preserve their IDs in `Cross-Cutting-Test-Points`, but never assert `__file__`, filesystem placement, pytest invocation count, Harness state, or report artifacts inside the business test. Harness-owned evidence verifies those bindings. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). Implement request dictionaries so their direct and nested key paths and enum literals exactly satisfy the Case `Payload Required Paths`, `Payload Allowed Paths`, and `Payload Enum`; for `Payload Contract: none`, do not invent a JSON/body DTO. GET/list filters still declare query fields in those payload labels when the Case varies `params=`/`query=` keys. Python `True`/`False` may implement JSON/OpenAPI `true`/`false` query or body booleans. GET/DELETE setup journeys may create resources, but their setup DTO must not change the target operation\'s no-body payload contract. No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task\'s explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.',
+                    "Name the generated pytest file so it corresponds one-to-one with its source Markdown module file: this module stem `{{item.stem}}` maps to exactly the frozen `{{item.pytestPath}}`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `resource_notes` → `testcase/test_resource_notes.py`, `health` → `testcase/test_health.py`. If Markdown automation mapping names a different path than this module stem path, still write the frozen manifest pytest path and do not invent prefixes. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.",
+                    "Scenario Partition slots: every `TP-<Partition ID>-...` variant Test Point declared by this module's Markdown MUST become exactly one literal direct `pytest.param(..., id=\"TP-<Partition ID>-...\")` row with the exact slot ID; the not-in-set slot passes a concrete literal absent from the documented Domain (e.g. `UNKNOWN_TYPE`) — never `_OMIT`, never a descriptive token. Never split one slot into multiple params or merge several slots under a family TP id. Slot filtering requests hit the documented list endpoint with the slot value as the query/path filter.",
+                    "Keep this module self-contained: define module-local fixtures and helpers directly in `{{item.pytestPath}}`, so pytest discovers every fixture dependency without external plugin registration. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions. Recursively redact sensitive values and apply bounded truncation before logging.",
+                    "Materialize every automatable Markdown Case exactly once as one canonical primary pytest symbol. Preserve every explicit variant Test Point as a stable pytest.param id and every assertion/cross-cutting binding as declared. Build request payloads from the effective Markdown test data literally: keep all declared DTO keys, nested shapes, enum values, missing/null/boundary variants and business-state preconditions; never substitute guessed convenience fields or rename contract fields. Never assert an identifier's concrete Python/JSON type unless the Markdown or bound contract explicitly declares that type; when only presence is required, accept any non-null scalar identifier and serialize it safely into the path. For a nonexistent-resource 404 Case whose identifier syntax/type is not declared, obtain a syntactically valid identifier from a live create response and delete it before the 404 request; never invent an arbitrary UUID/text identifier that may fail path conversion with 400. Respect every local helper's actual return signature: never tuple-unpack a scalar status/id/helper result, and never treat a tuple response as a scalar.",
+                    "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
+                    ...(sharedSetupPytestPrompt ? [sharedSetupPytestPrompt] : []),
+                ].join("\n\n"),
+            },
+        },
+    };
+    const collectionAssess = shellNode("assess-backend-pytest-collection-shell", [generatePytestCasesMap.id], "markdown-collection-assess", "Resolve final Markdown-mapped scripts before any business test body execution. Run scenario-param assess/at-most-one deterministic repair first, then pytest --collect-only and a no-business-body pytest --setup-plan fixture-resolution preflight. A safe missing mapped script, generated-local syntax/import defect, or generated fixture dependency/plugin-registration defect is REPAIRABLE; dependency, third-party plugin, production-module, environment, safety and unknown failures remain blocked. Materialize hash-bound collection-v3 facts with repairPaths and fixtureResolutionStatus.", "Run-owned reports/backend-test-pytest-collection-initial.md and contracts/backend-test-pytest-collection-initial.json (collection-v3) with bounded collection/fixture diagnostics, repairPaths, asset hashes, collected item IDs and deterministic repair eligibility.", [], 120000);
+    // N10 owns the deterministic scenario-param rewrite that may update mapped
+    // generated test modules before collection. Declare that bounded shell write
+    // authority so filesystem-only workspace control does not misclassify the
+    // intentional repair as an out-of-bounds mutation.
+    collectionAssess.writePolicy = "exclusive";
+    collectionAssess.writeSet = [applyLayout("testcase/**/test_*.py")];
+    collectionAssess.allowedPaths = Array.from(new Set([...ro, ...collectionAssess.writeSet]));
+    const repairPytest = {
+        id: "repair-backend-pytest-collection-pi",
+        depends_on: [collectionAssess.id],
+        runIf: "$.nodes['assess-backend-pytest-collection-shell'].json.repairEligible == true",
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: Array.from(new Set([
+            applyLayout("testcase/**/test_*.py"),
+            `${layout.testRoot}/helpers/**/*.py`,
+            `${layout.testRoot}/factories/**/*.py`,
+            `${layout.testRoot}/__*_helpers.py`,
+            `${layout.scriptDir}/helpers/**/*.py`,
+            `${layout.scriptDir}/factories/**/*.py`,
+            `${layout.scriptDir}/__*_helpers.py`,
+        ])),
+        readSet: [
+            ".harness/dag-runs/**/reports/backend-test-pytest-collection-initial.md",
+            ".harness/dag-runs/**/reports/backend-test-markdown-pytest-correspondence-initial.md",
+            ".harness/dag-runs/**/generate-backend-md-plan-pi/plan.md",
+            `${layout.markdownDir}/**`,
+            `${layout.testRoot}/**/*.py`,
+        ],
+        contextBudget: { maxTurns: 24, maxTokens: 80_000 },
+        allowedPaths: Array.from(new Set([...ro, `${layout.testRoot}/**`])),
+        forbiddenPaths: Array.from(new Set([
+            ...forbidden,
+            "testcase/md/**",
+            "conftest.py",
+            "pytest.ini",
+            "pyproject.toml",
+            "setup.cfg",
+        ])),
+        writerOutcomePolicy: { type: "implementation-outcome-v1", requireChangedFiles: true },
+        outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|blocked, followed by a concise repair summary. This node runs only for REPAIRABLE initial facts, so already-satisfied is invalid and a successful outcome requires a non-empty bounded diff. Modify only generated pytest scripts/helpers/factories and preserve every Markdown Case, Test Point, primary symbol and assertion meaning.",
+        subtask_prompt: [
+            "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution. The direct upstream JSON includes authoritative `repairPaths` and bounded `repairFindings`; treat both as the complete mandatory checklist without searching for a run directory or report file. Treat any upstream line such as `Repair paths: testcase/test_x.py` as equivalent authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
+            "Initial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.",
+            "This is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.",
+            "Preserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.",
+            "Use local edit only on assessment-listed paths; keep summaries short; never rewrite unrelated modules.",
+            "Do not reinterpret requirements beyond the effective Markdown and bounded assessment diagnostics. Do not modify Markdown, conftest, pytest config, production code or dependencies.",
+            "Do not add skip/skipif/xfail, remove tests, reduce collected items, loosen assertions, swallow exceptions, use try/except ImportError fallback, mutate sys.path/PYTHONPATH, or replace the real API with mocks.",
+            "Do not execute pytest; the deterministic effective collection gate owns the final collection attempt.",
+        ].join("\n\n"),
+    };
+    const collectionEffective = shellNode("effective-backend-pytest-collection-gate-shell", [collectionAssess.id, repairPytest.id], "markdown-collection-effective", "If initial collection+fixture readiness passed, verify unchanged asset hashes and reuse it. If the single repair ran, rerun scenario-param preflight, final collection and no-business-body fixture resolution once. Recompute effective correspondence/payload shape and materialize Case/symbol/item `ELIGIBLE|NOT_ELIGIBLE` facts; Payload-contract-bound field-target MISMATCH/UNDETERMINED scenario items, non-exact mappings and payload UNSAFE/UNAVAILABLE items are excluded. Generic request-level nominal/health observations remain advisory when payload shape is SAFE and correspondence exact. BLOCKED facts, repair failure, residual fixture failure, zero eligible items or hash drift prevent business pytest execution. Materialize canonical backend-test-execution-readiness.json v2.", "Run-owned effective collection-v3 facts, reports/backend-test-execution-eligibility.md, contracts/backend-test-execution-eligibility.json and contracts/backend-test-execution-readiness.json v2 proving exact final assets are collectable, fixture-resolvable, payload-safe at item level and hash-bound; initial PASS is reused, repair path records attempt=1.", [], 120000);
+    collectionEffective.dependsPolicy = "all-or-condition-skip";
+    const traceability = shellNode("backend-test-traceability-gate-shell", [collectionEffective.id], "markdown-traceability", "Deterministically scan only final readiness-authorized Markdown-mapped pytest scripts. Produce bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol correspondence, payload-shape safety, per-item execution eligibility and logging findings. scenario-param assessment/repair already ran before collection; consume and display its final PASS/PARTIAL/FAIL/UNAVAILABLE facts without modifying pytest assets after readiness was frozen. Correspondence findings remain advisory; Never block pytest solely on correspondence FAIL.", "Run-owned reports/backend-test-traceability.md, reports/backend-test-markdown-pytest-correspondence.md, contracts/backend-test-markdown-pytest-correspondence-facts.json, reports/backend-test-scenario-param-consistency.md and contracts/backend-test-scenario-param-consistency-facts.json (initial+final) with optional repair audit; PASS/FAIL/UNAVAILABLE correspondence facts bound after effective collection.");
+    const manifest = shellNode("backend-test-case-manifest-shell", [traceability.id], "markdown-manifest", "Materialize the canonical Backend Test Case Manifest only from contracts/backend-test-case-coverage-facts.json and contracts/backend-test-markdown-pytest-correspondence-facts.json. Validate schema, task binding, input hashes and freshness; never re-read source semantics, re-analyze Coverage Matrix, rescan pytest symbols or recompute a second set of metrics. Missing/stale/conflicting facts produce partial/unavailable diagnostics rather than fabricated zeros.", "Run-owned contracts/backend-test-case-manifest.json with materializationStatus, sourceFactsIssues, validated coverageScope, coverageSummary, ruleCoverageSummary and correspondenceSummary; this is the single machine input for L-5 and closeout.");
+    const pytestCommand = [
+        'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
+        'echo "pytest targets are resolved at runtime from execution-readiness v2 eligibleItemIds"',
+    ].join("; ");
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [manifest.id], "markdown-execute-html", "Read canonical contracts/backend-test-execution-readiness.json v2, verify final asset and eligibility-input hashes, then execute exactly its `eligibleItemIds` pytest node IDs once. Never execute `excludedItems`; retain each exclusion reason as residual TestBug/automation evidence rather than ProductBug. Prefer the deterministic module one-to-one path when a mapped script is missing but the module stem file exists. Generate a native pytest-html self-contained report, then render the primary self-contained Chinese HTML report from the same pytest-html plus final Markdown case metadata without rerun. Keep 测试结论 and quality status; make node 6 Markdown validation + case coverage and node 13 traceability + Markdown-to-pytest correspondence expandable to their full escaped details; show each failure overview item with its original pytest message plus deterministic evidence-based reason analysis; list failure/error case cards before the remaining cases while preserving stable order. Each polished per-case result card includes concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over readiness-authorized eligible pytest items producing a valid pytest-html report with per-case captured output, self-contained reports/backend-test.html, reports/backend-test.md, reports/backend-test-facts.md, a deterministic self-contained reports/backend-test-l5-dashboard.html (machine-computed L-5 metrics, no JSON), and an optional contracts/code-coverage-v1.json when jacocoCoverage is configured (JaCoCo TCP dump → jacoco.xml → parsed; failure-safe); exit 0/1 with valid evidence continues.", [pytestCommand], taskConfig.backendTest?.executeTimeoutMs ?? 300000);
+    if (execute.shell) {
+        execute.shell.envAllowlist = collectBackendTestShellEnvAllowlist(sources);
+    }
+    const report = {
+        id: "backend-test-report-and-l5-pi",
+        depends_on: [execute.id],
+        role: "closeout",
+        executor: "static",
+        complexity: "LOW",
+        writePolicy: "none",
+        allowedPaths: [],
+        forbiddenPaths: forbidden,
+        outputContract: "Deterministic evidence handoff linking the node 15 Markdown facts, HTML report, failure analysis and L-5 dashboard; no model invocation, JSON or writes.",
+        subtask_prompt: [
+            "Generate the final Markdown report only from authoritative run-owned artifacts. Read node 1 reports/backend-test-environment.md; node 6 backend-md-case-validation.md and backend-test-case-coverage-analysis.md; nodes 10/12 backend-test-pytest-collection initial/effective reports and facts; node 13 backend-test-traceability.md, backend-test-markdown-pytest-correspondence.md and backend-test-scenario-param-consistency.md; node 14 contracts/backend-test-case-manifest.json; and node 15 backend-test-result.json, backend-test-facts.md, backend-test-failure-analysis.md, pytest-html/HTML and L-5 dashboard. Do not use node 2/3/4/7/8/9 assistant prose as facts. Do not emit JSON.",
+            "Use this exact human-facing section order: 测试结论 → 执行概览 → 质量校验 → 失败分析 → 风险与建议 → 证据与 L-5. Put the decision and key numbers first, use compact tables/bullets, and keep headings concise. Do not paste entire upstream reports, duplicate per-case tables already present in facts, or repeat the same evidence in multiple sections; link to paths/hashes and quote only the findings needed for the conclusion. Prefer linking reports/backend-test-failure-analysis.md for structured failure analysis rather than inventing classifications.",
+            "Output budget: list evidence paths first, then write a short fixed six-section report; never paste upstream full text into chat.",
+            "The L-5 metrics and visualization are produced deterministically by node 15 at reports/backend-test-l5-dashboard.html. Link to that dashboard as the authoritative L-5 view. Pytest execution facts come from node 15; coverage/correspondence numbers and materializationStatus come from node 14; collection authorization comes from nodes 10/12; detailed coverage findings come from node 6; detailed mapping findings come from node 13. Never recompute these values. If machine manifest and human reports disagree, report evidence inconsistency rather than silently choosing.",
+            "Always state the exact Coverage Scope classification, policy, affected operations, regression floor, completeness claim, PASS/FAIL/UNAVAILABLE status and findings from node 6 case validation + coverage, plus node 13 traceability + correspondence. Affected-scope or affected-operations-full coverage must never be described as whole-API completeness unless every operation is explicitly listed. Their FAIL status does not block pytest, but it must remain visible and must never be rewritten as PASS.",
+            "Include environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage availability, and L-5 READY/NOT READY. Distinguish Markdown Case count, primary pytest symbol count, collected pytest item count, variant/assertion/cross-cutting Test Point counts and execution amplification; never describe pytest item count as the number of business scenarios.",
+            "Never override Shell/pytest-html facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.",
+            "Node 15 already rendered the authoritative Markdown and HTML outputs; this node only hands off their stable paths without recomputation.",
+        ].join("\n\n"),
+        static: {
+            resultMarkdown: [
+                "# Backend-test deterministic closeout",
+                "",
+                "Authoritative execution facts: `reports/backend-test.md` and `contracts/backend-test-result.json`.",
+                "Failure analysis: `reports/backend-test-failure-analysis.md`.",
+                "HTML report: `reports/backend-test.html`.",
+                "L-5 dashboard: `reports/backend-test-l5-dashboard.html`.",
+            ].join("\n"),
+        },
+    };
+    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: [
+            ...taskConfig.hardConstraints,
+            ...STANDARD_GLOBAL_CONSTRAINTS,
+            "backend-test-dag uses exactly 16 real top-level tasks: Markdown cases are sharded via a README plan + manifest shell + map_agent barrier (one child per module, each with its own 16K Pi budget), and pytest is likewise sharded via a shared-asset plan + manifest shell + map_agent barrier. Pytest collection runs once on the green path and at most twice only when one bounded pre-execution repair is eligible; business pytest test bodies execute exactly once over safe scripts explicitly mapped by final Markdown cases.",
+            "Model nodes produce Markdown and pytest assets, never backend-test business JSON envelopes.",
+            "Environment, advisory Markdown validation/coverage, collection initial/effective facts, advisory traceability/correspondence, pre-execution scenario-param consistency (with at most one deterministic param repair), canonical manifest, pytest-html, HTML, failure-analysis and execution facts are deterministic evidence. Node 6 quality findings stay advisory; nodes 10/12 form the fail-closed collection authorization; node 13 traceability/scenario-param findings stay advisory by default; node 14 partial/unavailable manifest does not block node 15 when effective collection remains fresh.",
+            "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
+            "Functional case IDs use canonical BE-<MODULE>-<NNN> with exactly three digits and no alphabetic suffix. Every Test Point has exactly one variant/assertion/cross-cutting binding; only variant bindings create pytest parameter items. Production code/config, skip/xfail, execution-result repair and business pytest rerun are forbidden; pre-execution repairs are limited to one collection-proven generated-test asset repair and one scenario-param payload repair (deterministic preferred).",
+            "Writer nodes must obey multi-file output-budget protocol under 16K max tokens: one file per write/edit, no chat dumps; Completeness Gate may trigger bounded incomplete-write-set recovery without lowering coverage quality.",
+        ],
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        verifyStrategy: resolveDagVerifyStrategy(taskConfig),
+        tasks: [
+            environment,
+            generateMdPlan,
+            materializeMdManifest,
+            generateMdCasesMap,
+            reviewCases,
+            validateCases,
+            generatePytestPlan,
+            materializePytestManifest,
+            generatePytestCasesMap,
+            collectionAssess,
+            repairPytest,
+            collectionEffective,
+            traceability,
+            manifest,
+            execute,
+            report,
+        ],
+    };
+    // Plan A: rewrite every backend-test node's layout-dependent strings
+    // (prompts, output contracts, writeSet/allowedPaths, shell commands)
+    // against the resolved layout. The default layout is identity, so the
+    // packaged template stays byte-identical with the historical contract.
+    applyBackendTestLayoutToDagSpec(spec, layout);
+    applyBackendTestWorkspaceControl(spec, taskConfig.backendTest?.workspaceControl ?? "git");
+    // Plan B: carry the bound shared-setup document on the spec so runtime
+    // validators (N6 markdown case validation) see the same binding as prompts.
+    if (intake.sharedSetup) {
+        spec.backendTestSharedSetup = { ...intake.sharedSetup };
+    }
+    applyDefaultReadOnlyRetryPolicy(spec);
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+export function applyBackendTestLayoutToDagSpec(spec, layout) {
+    if (layout.isDefault) {
+        spec.backendTestLayout = layout;
+        return;
+    }
+    const rewrite = (value) => applyBackendTestLayoutToText(value, layout);
+    for (const task of spec.tasks) {
+        task.subtask_prompt = rewrite(task.subtask_prompt);
+        if (task.outputContract)
+            task.outputContract = rewrite(task.outputContract);
+        task.writeSet = task.writeSet?.map(rewrite);
+        task.allowedPaths = task.allowedPaths?.map(rewrite);
+        task.forbiddenPaths = task.forbiddenPaths?.map(rewrite);
+        if (task.dynamicExpansion?.childTask) {
+            const child = task.dynamicExpansion.childTask;
+            if (typeof child.subtaskPromptTemplate === "string") {
+                child.subtaskPromptTemplate = rewrite(child.subtaskPromptTemplate);
+            }
+            if (typeof child.outputContract === "string") {
+                child.outputContract = rewrite(child.outputContract);
+            }
+            if (Array.isArray(child.allowedPaths)) {
+                child.allowedPaths = child.allowedPaths.map(rewrite);
+            }
+            if (Array.isArray(child.writeSet)) {
+                child.writeSet = child.writeSet.map(rewrite);
+            }
+            if (Array.isArray(child.forbiddenPaths)) {
+                child.forbiddenPaths = child.forbiddenPaths.map(rewrite);
+            }
+        }
+        if (task.shell?.commands) {
+            task.shell.commands = task.shell.commands.map(rewrite);
+        }
+    }
+    // Rewrite remaining prose-level constraints and success criteria that
+    // reference the generated asset tree.
+    spec.globalConstraints = spec.globalConstraints?.map(rewrite);
+    spec.successCriteria = spec.successCriteria?.map(rewrite);
+    spec.backendTestLayout = layout;
+}
+export 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. 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.",
+    "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 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");
+export function collectBackendTestShellEnvAllowlist(sources) {
+    const names = new Set();
+    const collectAssignments = (text) => {
+        const assignmentPattern = /(?:^|[\s;&|])([A-Z_][A-Z0-9_]*)\s*=/g;
+        for (const match of text.matchAll(assignmentPattern)) {
+            if (match[1])
+                names.add(match[1]);
+        }
+    };
+    for (const constraint of sources.taskConfig.hardConstraints) {
+        collectAssignments(constraint);
+    }
+    for (const verify of sources.taskConfig.verifyCommands) {
+        collectAssignments(verify.command);
+    }
+    return [...names].sort();
+}
+export function taskAllowsBackendTestReportWrite(sources) {
+    return sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" ||
+        pattern === "docs/**" ||
+        pattern === "**");
+}
+export const BACKEND_TEST_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+export const BACKEND_TEST_SKILLS_BY_ROLE = {
+    planner: ["loop-agent"],
+    scout: [],
+    implementer: ["test-driven-development", "verification-before-completion"],
+    reviewer: ["requesting-code-review", "code-review-core"],
+    verifier: ["verification-before-completion", "systematic-debugging"],
+    closeout: ["loop-agent", "verification-before-completion"],
+};
+export function applyBackendTestWorkspaceControl(spec, control) {
+    if (control !== "filesystem-only") {
+        delete spec.backendTestWorkspaceControl;
+        return;
+    }
+    spec.backendTestWorkspaceControl = control;
+    for (const task of spec.tasks) {
+        if ((task.executor === "pi" && task.toolProfile === "write") ||
+            task.shell?.backendTestPipeline) {
+            task.writeGuardPolicy = "filesystem-only";
+        }
+        const child = task.dynamicExpansion?.childTask;
+        if (child?.executor === "pi" && child.toolProfile === "write") {
+            child.writeGuardPolicy = "filesystem-only";
+        }
+    }
+}