@tea-agent/loop-agent 0.38.1 → 0.38.3

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -1,14 +1,25 @@
 import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import YAML from "yaml";
+import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { applyOpenApiPartitionDomainPolicy, assessScenarioPartitionCoverage, parseScenarioPartitions, } from "./backend-test-scenario-partitions.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-\d{3})\b.*$/gm;
 const CASE_ID_IN_TEXT = /\bBE-[A-Z0-9_-]+-\d{3}\b/g;
 const NON_CANONICAL_CASE_HEADING = /^##\s+(BE-[A-Z0-9_-]+-(?:\d{2}|\d{2,3}[A-Z]+))\b.*$/gm;
 const AC_ID_IN_TEXT = /\bAC-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
-const RULE_KEY = /^(?:AC|REQ|BR|API|GET|POST|PUT|PATCH|DELETE)-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
+const SOURCE_RULE_ID_IN_TEXT = /\b(?:AC|REQ|BR)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g;
+const SOURCE_ERROR_CODE_IN_TEXT = /\b[A-Z][0-9]{5,}\b/g;
+const JSON_FIELD_IN_TEXT = /["']([A-Za-z][A-Za-z0-9_]*)["']\s*:/g;
+const DTO_FIELD_IN_TEXT = /\b(?:private|public|protected)\s+(?:static\s+)?(?:final\s+)?[A-Za-z_$][A-Za-z0-9_$<>,.?\[\] ]*\s+([a-z][A-Za-z0-9_]*)\s*[;=]/g;
+const NATURAL_BUSINESS_RULE_KEYWORDS = /(?:事务|原子性|回滚|幂等|唯一性|唯一|状态转换|状态流转|权限|角色|租户|跨字段|transaction|atomic|rollback|idempoten|unique|state transition|authorization|permission|tenant|cross-field)/i;
+const NATURAL_BUSINESS_RULE_NORMATIVE = /(?:必须|不得|禁止|仅当|应当|需要|不能|保证|must|shall|required|must not|only when|guarantee)/i;
+// Token form is used for section scanning; anchored form validates full cells.
+const RULE_KEY_TOKEN = /(?:AC|REQ|BR|API|GET|POST|PUT|PATCH|DELETE)-[A-Z0-9]+(?:-[A-Z0-9]+)*|[A-Z][0-9]{5,}/;
+const RULE_KEY = new RegExp(`^(?:${RULE_KEY_TOKEN.source})$`);
 const TEST_POINT = /^TP-[A-Z0-9]+(?:-[A-Z0-9]+)*$/;
 const COVERAGE_HEADERS = [
     "Rule Key",
@@ -87,6 +98,13 @@ const coverageCaseSchema = z.object({
     scenarioTypes: z.array(z.string()),
     declaredScripts: z.array(z.string()),
     declaredPrimarySymbols: z.array(z.string()),
+    payloadContract: z.object({
+        declared: z.boolean(),
+        noPayload: z.boolean(),
+        requiredPaths: z.array(z.string()),
+        allowedPaths: z.array(z.string()),
+        enumValues: z.record(z.string(), z.array(z.string())),
+    }).strict(),
 }).strict();
 const coverageRuleSchema = z.object({
     ruleKey: z.string().min(1),
@@ -102,6 +120,23 @@ const coverageRuleSchema = z.object({
     missingTestPoints: z.array(z.string()),
     status: z.enum(["COVERED", "PARTIAL", "GAP", "CONFLICT"]),
 }).strict();
+const sourceCoverageFactSchema = z.object({
+    kind: z.enum(["requirement-id", "error-code", "dto-field", "business-rule"]),
+    key: z.string().min(1),
+    sourcePath: z.string().min(1),
+    sourceSha256: sha256Schema,
+    lineStart: z.number().int().positive(),
+    lineEnd: z.number().int().positive(),
+    quote: z.string().min(1).max(1000),
+    covered: z.boolean(),
+}).strict();
+const sourceCoverageSchema = z.object({
+    sourceFactCount: z.number().int().min(0),
+    coveredSourceFactCount: z.number().int().min(0),
+    residualSourceFactCount: z.number().int().min(0),
+    facts: z.array(sourceCoverageFactSchema),
+    residual: z.array(sourceCoverageFactSchema),
+}).strict();
 const coverageScopeSchema = z.object({
     changeClassification: z.enum(CHANGE_CLASSIFICATIONS),
     coveragePolicy: z.enum(COVERAGE_POLICIES),
@@ -112,13 +147,14 @@ const coverageScopeSchema = z.object({
     completenessClaim: z.enum(["affected-operations-full", "affected-scope"]),
 }).strict();
 export const backendTestCaseCoverageFactsSchema = z.object({
-    schemaId: z.literal("backend-test-case-coverage-facts-v3"),
-    schemaVersion: z.literal(3),
+    schemaId: z.literal("backend-test-case-coverage-facts-v4"),
+    schemaVersion: z.literal(4),
     taskId: z.string().min(1),
     status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
     sourceBinding: sourceBindingSchema,
     inputFiles: z.array(inputFileSchema),
     coverageScope: coverageScopeSchema,
+    sourceCoverage: sourceCoverageSchema,
     summary: z.object({
         explicitAcCount: z.number().int().min(0),
         coveredAcCount: z.number().int().min(0),
@@ -146,6 +182,27 @@ export const backendTestCaseCoverageFactsSchema = z.object({
     }).strict(),
     cases: z.array(coverageCaseSchema),
     rules: z.array(coverageRuleSchema),
+    /** Plan C: declared query/filter axis partitions and their slot coverage. */
+    scenarioPartitions: z.object({
+        partitions: z.array(z.object({
+            partitionId: z.string(),
+            operation: z.string(),
+            axis: z.string(),
+            domain: z.array(z.string()),
+            optional: z.boolean(),
+            complementExpected: z.string(),
+            bindRule: z.string(),
+            slotIds: z.array(z.string()),
+        })),
+        slots: z.array(z.object({
+            slotId: z.string(),
+            partitionId: z.string(),
+            kind: z.string(),
+            intent: z.string(),
+            expected: z.string(),
+        })),
+        missingSlots: z.array(z.string()),
+    }),
     findings: z.array(z.string()),
     evidenceGaps: z.array(z.string()),
     conflicts: z.array(z.string()),
@@ -177,12 +234,24 @@ const correspondenceEntrySchema = z.object({
         "CROSS_CUTTING_EVIDENCE_MISSING",
         "TEST_POINT_BINDING_DUPLICATE",
         "TEST_POINT_BINDING_EXTRA",
+        "PAYLOAD_CONTRACT_UNAVAILABLE",
+        "PAYLOAD_SHAPE_MISMATCH",
     ]),
+    payloadAssessment: z.object({
+        status: z.enum(["SAFE", "UNSAFE", "UNAVAILABLE"]),
+        requiredPaths: z.array(z.string()),
+        allowedPaths: z.array(z.string()),
+        observedPaths: z.array(z.string()),
+        missingPaths: z.array(z.string()),
+        unexpectedPaths: z.array(z.string()),
+        enumMismatches: z.array(z.string()),
+    }).strict(),
+    executionSignature: z.string().min(1).optional(),
     findings: z.array(z.string()),
 }).strict();
 export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
-    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v2"),
-    schemaVersion: z.literal(2),
+    schemaId: z.literal("backend-test-markdown-pytest-correspondence-facts-v3"),
+    schemaVersion: z.literal(3),
     taskId: z.string().min(1),
     status: z.enum(["PASS", "FAIL", "UNAVAILABLE"]),
     inputFiles: z.array(inputFileSchema),
@@ -203,6 +272,10 @@ export const backendTestMarkdownPytestCorrespondenceFactsSchema = z.object({
         crossCuttingTestPointCount: z.number().int().min(0),
         unclassifiedTestPointCount: z.number().int().min(0),
         duplicateBindingTestPointCount: z.number().int().min(0),
+        payloadSafeCount: z.number().int().min(0),
+        payloadUnsafeCount: z.number().int().min(0),
+        payloadUnavailableCount: z.number().int().min(0),
+        duplicateExecutionSignatureCount: z.number().int().min(0),
     }).strict(),
     entries: z.array(correspondenceEntrySchema),
     findings: z.array(z.string()),
@@ -236,6 +309,64 @@ function openApiTestPoints(field, dimension, values = []) {
         return [`${prefix}-VALID-CLASS`, `${prefix}-VALID-MIXED`, `${prefix}-UPPERCASE`, `${prefix}-WHITESPACE`, `${prefix}-PUNCTUATION`, `${prefix}-SLASH`, `${prefix}-EMOJI`, `${prefix}-CONTROL`];
     return [`${prefix}-PRESENT`, `${prefix}-MISSING`, `${prefix}-NULL`, `${prefix}-WRONG-TYPE`];
 }
+async function collectSourceCoverageFacts(input) {
+    const paths = orderedUnique([
+        input.sourceBinding.requirementPath,
+        ...input.sourceBinding.referencePaths,
+    ]);
+    const facts = [];
+    const seen = new Set();
+    for (const sourcePath of paths) {
+        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, sourcePath);
+        let text;
+        try {
+            text = await readFile(physicalPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const sourceSha256 = createHash("sha256").update(await readFile(physicalPath)).digest("hex");
+        const lines = text.split(/\r?\n/);
+        const add = (kind, key, lineIndex, quote) => {
+            const normalizedQuote = quote.trim().slice(0, 1000);
+            if (!normalizedQuote)
+                return;
+            const identity = `${kind}:${key}:${sourcePath}:${lineIndex + 1}`;
+            if (seen.has(identity))
+                return;
+            seen.add(identity);
+            const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const covered = kind === "business-rule"
+                ? input.generatedMarkdown.includes(normalizedQuote)
+                : new RegExp(`\\b${escaped}\\b`).test(input.generatedMarkdown);
+            facts.push({
+                kind,
+                key,
+                sourcePath,
+                sourceSha256,
+                lineStart: lineIndex + 1,
+                lineEnd: lineIndex + 1,
+                quote: normalizedQuote,
+                covered,
+            });
+        };
+        lines.forEach((line, lineIndex) => {
+            for (const key of line.match(SOURCE_RULE_ID_IN_TEXT) ?? [])
+                add("requirement-id", key, lineIndex, line);
+            for (const key of line.match(SOURCE_ERROR_CODE_IN_TEXT) ?? [])
+                add("error-code", key, lineIndex, line);
+            for (const match of line.matchAll(JSON_FIELD_IN_TEXT))
+                add("dto-field", match[1], lineIndex, line);
+            for (const match of line.matchAll(DTO_FIELD_IN_TEXT))
+                add("dto-field", match[1], lineIndex, line);
+            const trimmed = line.trim();
+            if (trimmed.length >= 8 && trimmed.length <= 1000 && !/^\s*(?:#|\||[-:]{3,})/.test(trimmed) && NATURAL_BUSINESS_RULE_KEYWORDS.test(trimmed) && NATURAL_BUSINESS_RULE_NORMATIVE.test(trimmed)) {
+                add("business-rule", `BR-SOURCE-${sourceSha256.slice(0, 8).toUpperCase()}-L${lineIndex + 1}`, lineIndex, trimmed);
+            }
+        });
+    }
+    return facts.sort((left, right) => left.kind.localeCompare(right.kind) || left.key.localeCompare(right.key) || left.sourcePath.localeCompare(right.sourcePath) || left.lineStart - right.lineStart);
+}
 function resolveBoundSourcePath(workspaceRoot, taskId, sourcePath) {
     if (path.isAbsolute(sourcePath))
         return sourcePath;
@@ -355,6 +486,55 @@ export async function extractBackendTestOpenApiRules(input) {
     }
     return rules.sort((left, right) => left.ruleKey.localeCompare(right.ruleKey));
 }
+export async function extractBackendTestOpenApiPartitionAxes(input) {
+    const axes = [];
+    const seen = new Set();
+    for (const referencePath of input.sourceBinding.referencePaths) {
+        const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
+        let document;
+        try {
+            const parsed = YAML.parse(await readFile(physicalPath, "utf8"));
+            if (!isRecord(parsed) || !isRecord(parsed.paths))
+                continue;
+            document = parsed;
+        }
+        catch {
+            continue;
+        }
+        for (const [apiPath, pathItem] of Object.entries(document.paths)) {
+            if (!isRecord(pathItem))
+                continue;
+            const operation = pathItem.get;
+            if (!isRecord(operation))
+                continue;
+            const parameterValues = [
+                ...(Array.isArray(pathItem.parameters) ? pathItem.parameters : []),
+                ...(Array.isArray(operation.parameters) ? operation.parameters : []),
+            ];
+            for (const rawParameter of parameterValues) {
+                const parameter = resolveOpenApiSchema(document, rawParameter);
+                if (!parameter || typeof parameter.name !== "string")
+                    continue;
+                const location = parameter.in === "path" ? "path" : parameter.in === "query" ? "query" : undefined;
+                if (!location)
+                    continue;
+                const property = resolveOpenApiSchema(document, parameter.schema);
+                const enumValues = property && Array.isArray(property.enum) ? property.enum.map(String) : null;
+                const identity = `GET ${apiPath}|${location}|${parameter.name}`;
+                if (seen.has(identity))
+                    continue;
+                seen.add(identity);
+                axes.push({
+                    operation: `GET ${apiPath}`,
+                    name: parameter.name,
+                    in: location,
+                    enumValues,
+                });
+            }
+        }
+    }
+    return axes;
+}
 function orderedUnique(values) {
     const result = [];
     const seen = new Set();
@@ -385,8 +565,14 @@ function sectionBody(body, aliases) {
 }
 function listTokens(body, aliases, pattern) {
     const section = sectionBody(body, aliases).replaceAll("`", "");
-    const source = pattern.source.replace(/^\^/, "").replace(/\$$/, "");
-    return orderedUnique(section.match(new RegExp(source, "g")) ?? []);
+    // Prefer dedicated token patterns; never strip ^/$ from alternation-based anchors
+    // (that would turn `^A$|^B$` into `A$|^B` and break scanning).
+    const tokenSource = pattern === RULE_KEY
+        ? RULE_KEY_TOKEN.source
+        : pattern === TEST_POINT
+            ? TEST_POINT.source.replace(/^\^/, "").replace(/\$$/, "")
+            : pattern.source.replace(/^\^/, "").replace(/\$$/, "");
+    return orderedUnique(section.match(new RegExp(tokenSource, "g")) ?? []);
 }
 function scenarioTypes(body) {
     return orderedUnique(sectionBody(body, CASE_SECTION_ALIASES.scenarioTypes)
@@ -423,8 +609,40 @@ function testPointBindingFacts(body, testPoints) {
 }
 function declaredPrimarySymbols(body) {
     const value = automationLabelBody(body, ["primary symbol", "Primary Symbol", "主测试符号"]);
+    if (/^(?:none|无|n\/a|not-applicable)$/i.test(value.trim()))
+        return [];
     return orderedUnique(value.match(/\btest_[A-Za-z0-9_]+\b/g) ?? []);
 }
+function isEvidenceOnlyMarkdownCase(testCase) {
+    const hasVariant = testCase.testPointBindings.some((item) => item.mode === "variant");
+    const hasNonVariant = testCase.testPointBindings.some((item) => item.mode === "assertion" || item.mode === "cross-cutting");
+    return (testCase.declaredScripts.length === 0 &&
+        testCase.declaredPrimarySymbols.length === 0 &&
+        !hasVariant &&
+        hasNonVariant);
+}
+function payloadContract(body) {
+    const contractValue = automationLabelBody(body, ["Payload Contract", "载荷合同"]);
+    const requiredValue = automationLabelBody(body, ["Payload Required Paths", "载荷必需路径"]);
+    const allowedValue = automationLabelBody(body, ["Payload Allowed Paths", "载荷允许路径"]);
+    const enumValue = automationLabelBody(body, ["Payload Enum", "载荷枚举"]);
+    const tokens = (value) => orderedUnique(value.split(/[,;，；]/).map((item) => item.trim()).filter((item) => /^[A-Za-z_][A-Za-z0-9_.]*$/.test(item)));
+    const enumValues = {};
+    for (const assignment of enumValue.split(/[,;，；]/).map((item) => item.trim()).filter(Boolean)) {
+        const match = /^([A-Za-z_][A-Za-z0-9_.]*)\s*(?:=|:)\s*(.+)$/.exec(assignment);
+        if (!match)
+            continue;
+        enumValues[match[1]] = orderedUnique(match[2].split(/\||\//).map((item) => item.trim().replace(/[（(].*$/, "").trim().replace(/^['"]|['"]$/g, "")).filter(Boolean));
+    }
+    const noPayload = /^(?:none|无|not-applicable|n\/a)(?:\s|[（(]|$)/i.test(contractValue.trim());
+    return {
+        declared: noPayload || requiredValue.length > 0 || allowedValue.length > 0 || enumValue.length > 0,
+        noPayload,
+        requiredPaths: tokens(requiredValue),
+        allowedPaths: tokens(allowedValue),
+        enumValues,
+    };
+}
 function cleanTitle(heading, id) {
     return heading.replace(/^##\s+/, "").replace(/^BE-[A-Z0-9_-]+-\d{2,3}\s*(?:[｜|—–-]\s*)?/i, "").trim() || id;
 }
@@ -437,17 +655,18 @@ async function exists(filePath) {
         return false;
     }
 }
-async function markdownModuleFiles(workspaceRoot) {
-    const dir = path.join(workspaceRoot, "testcase", "md");
+async function markdownModuleFiles(workspaceRoot, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    const dir = path.join(workspaceRoot, ...resolved.markdownDir.split("/"));
     const entries = await readdir(dir, { withFileTypes: true });
     return entries
         .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md") && entry.name.toLowerCase() !== "readme.md")
         .map((entry) => path.join(dir, entry.name))
         .sort();
 }
-async function parseMarkdownCases(workspaceRoot) {
+async function parseMarkdownCases(workspaceRoot, layout) {
     const result = [];
-    for (const file of await markdownModuleFiles(workspaceRoot)) {
+    for (const file of await markdownModuleFiles(workspaceRoot, layout)) {
         const markdown = await readFile(file, "utf8");
         const headings = [...markdown.matchAll(CASE_HEADING)];
         for (let index = 0; index < headings.length; index += 1) {
@@ -466,6 +685,7 @@ async function parseMarkdownCases(workspaceRoot) {
                 scenarioTypes: scenarioTypes(body),
                 declaredScripts: declaredScripts(body),
                 declaredPrimarySymbols: declaredPrimarySymbols(body),
+                payloadContract: payloadContract(body),
                 body,
             });
         }
@@ -483,8 +703,17 @@ function parseTableRow(line) {
             index += 1;
         }
         else if (char === "|") {
-            cells.push(current.trim());
-            current = "";
+            const prev = trimmed[index - 1] ?? "";
+            const next = trimmed[index + 1] ?? "";
+            // In-cell enum/value pipes look like ACTIVE|ARCHIVED (alnum on both sides).
+            // Column separators use " | " or touch markdown separator dashes (---|---).
+            if (/[A-Za-z0-9_]/.test(prev) && /[A-Za-z0-9_]/.test(next)) {
+                current += "|";
+            }
+            else {
+                cells.push(current.trim());
+                current = "";
+            }
         }
         else {
             current += char;
@@ -637,15 +866,16 @@ function renderCoverageTable(rules) {
     ];
 }
 export async function analyzeBackendTestCaseCoverage(input) {
+    const layout = input.layout ?? resolveBackendTestLayout(undefined);
     const findings = [];
-    const readmePath = path.join(input.workspaceRoot, "testcase", "md", "README.md");
+    const readmePath = path.join(input.workspaceRoot, ...layout.readmePath.split("/"));
     const readme = (await exists(readmePath)) ? await readFile(readmePath, "utf8") : "";
     const coverageScope = parseCoverageScope(readme);
     findings.push(...coverageScope.findings);
     const matrix = parseCoverageMatrix(readme);
     findings.push(...matrix.findings);
-    const cases = await parseMarkdownCases(input.workspaceRoot);
-    for (const file of await markdownModuleFiles(input.workspaceRoot)) {
+    const cases = await parseMarkdownCases(input.workspaceRoot, layout);
+    for (const file of await markdownModuleFiles(input.workspaceRoot, layout)) {
         const markdown = await readFile(file, "utf8");
         for (const match of markdown.matchAll(NON_CANONICAL_CASE_HEADING)) {
             findings.push(`non-canonical Case ID heading must use BE-<MODULE>-<NNN>: ${match[1]}`);
@@ -687,7 +917,10 @@ export async function analyzeBackendTestCaseCoverage(input) {
             if (!rowCaseIds.includes(testCase.caseId))
                 findings.push(`${testCase.caseId} references ${ruleKey} but is absent from its Coverage Matrix Case IDs`);
         }
-        let status = declaredStatus;
+        const normalizedDeclaredStatus = /^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus)
+            ? declaredStatus
+            : "PARTIAL";
+        let status = normalizedDeclaredStatus;
         if (status === "COVERED" && missingTestPoints.length > 0)
             status = "PARTIAL";
         if (missingTestPoints.length > 0)
@@ -707,7 +940,7 @@ export async function analyzeBackendTestCaseCoverage(input) {
             rule: row.Rule || "unavailable",
             requiredTestPoints,
             caseIds: rowCaseIds,
-            declaredStatus: /^(?:COVERED|PARTIAL|GAP|CONFLICT)$/.test(declaredStatus) ? declaredStatus : "PARTIAL",
+            declaredStatus: normalizedDeclaredStatus,
             coveredTestPoints,
             missingTestPoints,
             status,
@@ -749,8 +982,12 @@ export async function analyzeBackendTestCaseCoverage(input) {
             findings.push(`${testCase.caseId} missing section or entries: 测试点`);
         if (testCase.scenarioTypes.length === 0)
             findings.push(`${testCase.caseId} missing section or entries: 场景类型`);
-        if (testCase.declaredPrimarySymbols.length !== 1)
+        if (isEvidenceOnlyMarkdownCase(testCase)) {
+            // Evidence-only meta cases intentionally declare 脚本/primary symbol as 无 and only keep assertion/cross-cutting TPs.
+        }
+        else if (testCase.declaredPrimarySymbols.length !== 1) {
             findings.push(`${testCase.caseId} must declare exactly one primary symbol`);
+        }
         if (testCase.unclassifiedTestPoints.length > 0)
             findings.push(`${testCase.caseId} has unclassified Test Points: ${testCase.unclassifiedTestPoints.join(", ")}`);
         if (testCase.duplicateBindingTestPoints.length > 0)
@@ -772,8 +1009,37 @@ export async function analyzeBackendTestCaseCoverage(input) {
         if (uniqueOwners.length > 1)
             findings.push(`${testPoint} is bound as a non-cross-cutting Test Point by multiple Cases: ${uniqueOwners.join(", ")}`);
     }
-    const explicitAc = input.sourceBinding.requirementIds.filter((id) => id.startsWith("AC-"));
+    const generatedMarkdown = [readme, ...cases.map((item) => item.body)].join("\n\n");
+    const sourceCoverageFacts = await collectSourceCoverageFacts({
+        workspaceRoot: input.workspaceRoot,
+        sourceBinding: input.sourceBinding,
+        generatedMarkdown,
+    });
+    const residualSourceFacts = sourceCoverageFacts.filter((fact) => !fact.covered);
+    for (const fact of residualSourceFacts) {
+        findings.push(`source coverage is missing ${fact.kind} ${fact.key} from ${fact.sourcePath}`);
+    }
+    const sourceRequirementIds = sourceCoverageFacts
+        .filter((fact) => fact.kind === "requirement-id")
+        .map((fact) => fact.key);
+    const explicitAc = orderedUnique([
+        ...input.sourceBinding.requirementIds.filter((id) => id.startsWith("AC-")),
+        ...sourceRequirementIds.filter((id) => id.startsWith("AC-")),
+    ]);
     const coveredAc = new Set(cases.flatMap((item) => item.acIds));
+    for (const acId of explicitAc) {
+        if (!coveredAc.has(acId))
+            findings.push(`explicit source AC is missing from Markdown Cases: ${acId}`);
+    }
+    // Plan C: deterministic query/filter axis partitions (fail-closed on missing slots).
+    const parsedPartitions = parseScenarioPartitions(readme);
+    findings.push(...parsedPartitions.issues);
+    const openApiPartitionAxes = await extractBackendTestOpenApiPartitionAxes(input);
+    const partitionedBySource = applyOpenApiPartitionDomainPolicy(parsedPartitions.partitions, openApiPartitionAxes);
+    findings.push(...partitionedBySource.issues);
+    const declaredPointUniverse = new Set(cases.flatMap((item) => item.testPoints));
+    const partitionAssessment = assessScenarioPartitionCoverage(partitionedBySource.partitions, declaredPointUniverse);
+    findings.push(...partitionAssessment.findings);
     const [enumValueCount, coveredEnumValueCount] = dimensionCounts(rules, /enum/);
     const [boundaryPointCount, coveredBoundaryPointCount] = dimensionCounts(rules, /boundary|length|numeric/);
     const [formatClassCount, coveredFormatClassCount] = dimensionCounts(rules, /format|pattern|charset/);
@@ -782,20 +1048,27 @@ export async function analyzeBackendTestCaseCoverage(input) {
     const invalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.requiredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const coveredInvalidEquivalenceClassCount = rules.reduce((sum, rule) => sum + rule.coveredTestPoints.filter((point) => invalidPointPattern.test(point)).length, 0);
     const facts = backendTestCaseCoverageFactsSchema.parse({
-        schemaId: "backend-test-case-coverage-facts-v3",
-        schemaVersion: 3,
+        schemaId: "backend-test-case-coverage-facts-v4",
+        schemaVersion: 4,
         taskId: input.sourceBinding.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         sourceBinding: input.sourceBinding,
         inputFiles: await inputFileFacts(input.workspaceRoot, [
             ...((await exists(readmePath)) ? [readmePath] : []),
-            ...(await markdownModuleFiles(input.workspaceRoot)),
+            ...(await markdownModuleFiles(input.workspaceRoot, layout)),
             ...(await Promise.all(input.sourceBinding.referencePaths.map(async (referencePath) => {
                 const physicalPath = resolveBoundSourcePath(input.workspaceRoot, input.sourceBinding.taskId, referencePath);
                 return (await exists(physicalPath)) ? physicalPath : "";
             }))).filter(Boolean),
         ]),
         coverageScope: coverageScope.scope,
+        sourceCoverage: {
+            sourceFactCount: sourceCoverageFacts.length,
+            coveredSourceFactCount: sourceCoverageFacts.length - residualSourceFacts.length,
+            residualSourceFactCount: residualSourceFacts.length,
+            facts: sourceCoverageFacts,
+            residual: residualSourceFacts,
+        },
         summary: {
             explicitAcCount: explicitAc.length,
             coveredAcCount: explicitAc.filter((id) => coveredAc.has(id)).length,
@@ -823,6 +1096,7 @@ export async function analyzeBackendTestCaseCoverage(input) {
         },
         cases: cases.map(({ body: _body, ...item }) => item),
         rules,
+        scenarioPartitions: partitionAssessment.facts,
         findings: orderedUnique(findings),
         evidenceGaps,
         conflicts,
@@ -846,6 +1120,22 @@ export async function analyzeBackendTestCaseCoverage(input) {
         `- Scope Evidence: ${facts.coverageScope.scopeEvidence.join(", ") || "Unavailable"}`,
         ...(facts.coverageScope.completenessClaim === "affected-scope" ? ["- Coverage is scoped to affected operations; it is not whole-API completeness."] : ["- Coverage fully evaluates the declared affected operations; it is not whole-API completeness unless every operation is explicitly listed."]),
         "",
+        "## Source Coverage Inventory",
+        "",
+        `- Source facts: ${facts.sourceCoverage.sourceFactCount}`,
+        `- Covered source facts: ${facts.sourceCoverage.coveredSourceFactCount}`,
+        `- Residual source facts: ${facts.sourceCoverage.residualSourceFactCount}`,
+        "",
+        "| Kind | Key | Source Anchor | Source SHA-256 | Exact Quote | Status |",
+        "|---|---|---|---|---|---|",
+        ...facts.sourceCoverage.facts.map((fact) => `| ${fact.kind} | ${fact.key} | ${fact.sourcePath}:L${fact.lineStart} | ${fact.sourceSha256} | ${fact.quote.replaceAll("|", "\\|")} | ${fact.covered ? "COVERED" : "MISSING_AFTER_SYNC"} |`),
+        "",
+        "## Residual Missing Source Scenarios",
+        "",
+        ...(facts.sourceCoverage.residual.length > 0
+            ? facts.sourceCoverage.residual.map((fact) => `- ${fact.kind} \`${fact.key}\` from \`${fact.sourcePath}:L${fact.lineStart}\` (sha256 \`${fact.sourceSha256}\`), quote: “${fact.quote}”: missing after the bounded Markdown synchronization round; no full-coverage claim is allowed.`)
+            : ["- None"]),
+        "",
         "## Coverage Summary",
         "",
         "| Dimension | Total | Covered |",
@@ -902,13 +1192,329 @@ export async function analyzeBackendTestCaseCoverage(input) {
 function normalizeModuleStem(markdownPath) {
     return path.posix.basename(markdownPath).replace(/\.md$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
-function expectedScript(markdownPath) {
-    return `testcase/test_${normalizeModuleStem(markdownPath)}.py`;
+function expectedScript(markdownPath, layout) {
+    const resolved = layout ?? resolveBackendTestLayout(undefined);
+    return `${resolved.scriptDir}/test_${normalizeModuleStem(markdownPath)}.py`;
 }
 function symbolCaseId(symbol) {
     const match = symbol.match(/^test_(BE(?:_[A-Z0-9]+)+?_\d{2,3})(?:_|$)/i);
     return match ? canonicalCaseId(match[1].replaceAll("_", "-")) : undefined;
 }
+function pythonPayloadShapes(source) {
+    const program = String.raw `
+import ast,json,sys
+source=sys.stdin.buffer.read().decode('utf-8')
+tree=ast.parse(source)
+GLOBAL_PAYLOADS={}
+GLOBAL_VALUES={}
+for top in tree.body:
+    if isinstance(top,(ast.Assign,ast.AnnAssign)):
+        names=([target.id for target in top.targets if isinstance(target,ast.Name)] if isinstance(top,ast.Assign) else ([top.target.id] if isinstance(top.target,ast.Name) else []))
+        if top.value is None: continue
+        candidates=[]
+        for node in ast.walk(top.value):
+            if isinstance(node,ast.Call) and isinstance(node.func,ast.Attribute) and node.func.attr == 'param' and node.args and isinstance(node.args[0],ast.Dict): candidates.append(node.args[0])
+        if isinstance(top.value,ast.Dict) and any(name.lower() in {'payload','body','request_body','request_json','dto'} for name in names): candidates.append(top.value)
+        for name in names:
+            GLOBAL_PAYLOADS[name]=candidates
+            GLOBAL_VALUES[name]=top.value
+FUNCTION_PAYLOADS={}
+FUNCTION_TRANSPORT_SHAPES={}
+TRANSPORT_PAYLOAD_PARAMS={}
+for top in ast.walk(tree):
+    if isinstance(top,(ast.FunctionDef,ast.AsyncFunctionDef)) and not top.name.startswith('test_'):
+        candidates=[]
+        assigned={}
+        mutated={}
+        returned_names=set()
+        positional=[arg.arg for arg in [*top.args.posonlyargs,*top.args.args]]
+        call_offset=1 if positional and positional[0] in {'self','cls'} else 0
+        transport=[]
+        for node in ast.walk(top):
+            if isinstance(node,(ast.Assign,ast.AnnAssign)):
+                targets=node.targets if isinstance(node,ast.Assign) else [node.target]
+                if node.value is None: continue
+                for target in targets:
+                    if isinstance(target,ast.Name): assigned[target.id]=node.value
+                for target in targets:
+                    if isinstance(target,ast.Subscript) and isinstance(target.value,ast.Name) and isinstance(target.slice,ast.Constant) and isinstance(target.slice.value,str):
+                        mutated.setdefault(target.value.id,[]).append((target.slice.value,node.value))
+            if isinstance(node,ast.Return):
+                if isinstance(node.value,ast.Dict): candidates.append(node.value)
+                elif isinstance(node.value,ast.Name) and node.value.id in assigned:
+                    returned=assigned[node.value.id]
+                    if isinstance(returned,ast.Dict): candidates.append(returned)
+                    elif isinstance(returned,ast.Call) and isinstance(returned.func,ast.Name) and returned.func.id in FUNCTION_PAYLOADS:
+                        candidates.extend(FUNCTION_PAYLOADS[returned.func.id])
+                    returned_names.add(node.value.id)
+            if isinstance(node,ast.Call):
+                for keyword in node.keywords:
+                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
+                        transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
+                if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
+                    candidate=node.args[1]
+                    if isinstance(candidate,ast.Name) and candidate.id in positional:
+                        transport.append((candidate.id,positional.index(candidate.id)-call_offset))
+                callee=None
+                if isinstance(node.func,ast.Name): callee=node.func.id
+                elif isinstance(node.func,ast.Attribute): callee=node.func.attr
+                for _nested_name,nested_position in TRANSPORT_PAYLOAD_PARAMS.get(callee,[]):
+                    matched=node.args[nested_position] if nested_position >= 0 and nested_position < len(node.args) else None
+                    if isinstance(matched,ast.Name) and matched.id in positional:
+                        transport.append((matched.id,positional.index(matched.id)-call_offset))
+        for returned_name in returned_names:
+            entries=mutated.get(returned_name,[])
+            if entries:
+                candidates.append(ast.Dict(keys=[ast.Constant(key) for key,_value in entries],values=[value for _key,value in entries]))
+        transport_shapes=[]
+        for node in ast.walk(top):
+            if not isinstance(node,ast.Call): continue
+            for keyword in node.keywords:
+                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
+                    transport_shapes.append(assigned[keyword.value.id])
+        if candidates: FUNCTION_PAYLOADS[top.name]=candidates
+        if transport_shapes: FUNCTION_TRANSPORT_SHAPES[top.name]=transport_shapes
+        if transport: TRANSPORT_PAYLOAD_PARAMS[top.name]=list(dict.fromkeys(transport))
+# Propagate transport payload positions through local wrapper chains after all
+# direct transport methods/functions are known. ast.walk may visit module-level
+# wrappers before class methods, so one-pass discovery is order-sensitive.
+for _round in range(6):
+    changed=False
+    for top in ast.walk(tree):
+        if not isinstance(top,(ast.FunctionDef,ast.AsyncFunctionDef)) or top.name.startswith('test_'): continue
+        positional=[arg.arg for arg in [*top.args.posonlyargs,*top.args.args]]
+        call_offset=1 if positional and positional[0] in {'self','cls'} else 0
+        current=list(TRANSPORT_PAYLOAD_PARAMS.get(top.name,[]))
+        for node in ast.walk(top):
+            if not isinstance(node,ast.Call): continue
+            callee=node.func.id if isinstance(node.func,ast.Name) else (node.func.attr if isinstance(node.func,ast.Attribute) else None)
+            for _nested_name,nested_position in TRANSPORT_PAYLOAD_PARAMS.get(callee,[]):
+                matched=node.args[nested_position] if nested_position >= 0 and nested_position < len(node.args) else None
+                if isinstance(matched,ast.Name) and matched.id in positional:
+                    item=(matched.id,positional.index(matched.id)-call_offset)
+                    if item not in current:
+                        current.append(item); changed=True
+        if current: TRANSPORT_PAYLOAD_PARAMS[top.name]=current
+    if not changed: break
+
+# A local row factory may return pytest.param(_payload_builder(...), ..., id=tp).
+# Treat its first positional payload builder as shape evidence while keeping the
+# writer contract free to require direct pytest.param rows for scenario checks.
+for top in ast.walk(tree):
+    if not isinstance(top,(ast.FunctionDef,ast.AsyncFunctionDef)) or top.name.startswith('test_'): continue
+    for node in ast.walk(top):
+        if not isinstance(node,ast.Return) or not isinstance(node.value,ast.Call): continue
+        returned=node.value
+        if not isinstance(returned.func,ast.Attribute) or returned.func.attr != 'param' or not returned.args: continue
+        payload=returned.args[0]
+        if isinstance(payload,ast.Call) and isinstance(payload.func,ast.Name) and payload.func.id in FUNCTION_PAYLOADS:
+            FUNCTION_PAYLOADS[top.name]=list(FUNCTION_PAYLOADS[payload.func.id])
+# Resolve module-level parameter collections after local payload/row factories
+# are known (for example CASE_ROWS = [_post_case(...) , ...]).
+for top in tree.body:
+    if not isinstance(top,ast.Assign): continue
+    names=[target.id for target in top.targets if isinstance(target,ast.Name)]
+    resolved=[]
+    for node in ast.walk(top.value):
+        if isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id in FUNCTION_PAYLOADS:
+            resolved.extend(FUNCTION_PAYLOADS[node.func.id])
+    for name in names:
+        if resolved: GLOBAL_PAYLOADS[name]=list(GLOBAL_PAYLOADS.get(name,[]))+resolved
+
+def literal(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, (str,int,float,bool,type(None))):
+        return repr(node.value)
+    return None
+
+def collect_dict(node, prefix, paths, values):
+    if not isinstance(node, ast.Dict): return
+    for key,value in zip(node.keys,node.values):
+        if not isinstance(key, ast.Constant) or not isinstance(key.value,str): continue
+        # Ignore writer helper/meta keys that are not DTO request fields.
+        if key.value in {'expect','expected','expected_status','expected_code','echo_title','echo_content','echo_status'} or key.value.startswith('echo_') or key.value.startswith('expected_'):
+            continue
+        current = key.value if not prefix else prefix + '.' + key.value
+        paths.add(current)
+        lv=literal(value)
+        if lv is not None: values.setdefault(current,set()).add(lv)
+        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values)
+        elif isinstance(value,(ast.List,ast.Tuple)):
+            for item in value.elts:
+                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values)
+
+PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body'}
+
+def shape_only(node):
+    if isinstance(node,ast.Dict):
+        values=[]
+        for value in node.values:
+            if isinstance(value,(ast.Dict,ast.List,ast.Tuple)): values.append(shape_only(value))
+            else: values.append(ast.Name(id='_PAYLOAD_VALUE_',ctx=ast.Load()))
+        return ast.Dict(keys=node.keys,values=values)
+    if isinstance(node,(ast.List,ast.Tuple)):
+        items=[shape_only(item) if isinstance(item,(ast.Dict,ast.List,ast.Tuple)) else ast.Name(id='_PAYLOAD_VALUE_',ctx=ast.Load()) for item in node.elts]
+        return ast.List(elts=items,ctx=ast.Load()) if isinstance(node,ast.List) else ast.Tuple(elts=items,ctx=ast.Load())
+    return node
+
+def payload_expr_nodes(expr, assigned, parameters, seen=None):
+    seen=set() if seen is None else seen
+    if isinstance(expr,ast.Dict): return [expr]
+    if isinstance(expr,ast.Name):
+        if expr.id in seen: return []
+        seen.add(expr.id)
+        if expr.id in assigned: return payload_expr_nodes(assigned[expr.id],assigned,parameters,seen)
+        if expr.id in parameters:
+            result=[]
+            for value in parameters[expr.id]: result.extend(payload_expr_nodes(value,assigned,parameters,set(seen)))
+            return result
+        return list(GLOBAL_PAYLOADS.get(expr.id,[]))
+    if isinstance(expr,ast.Subscript) and isinstance(expr.value,ast.Name) and isinstance(expr.slice,ast.Constant) and isinstance(expr.slice.value,str):
+        result=[]
+        for candidate in parameters.get(expr.value.id,[]):
+            if not isinstance(candidate,ast.Dict): continue
+            for key,value in zip(candidate.keys,candidate.values):
+                if isinstance(key,ast.Constant) and key.value == expr.slice.value:
+                    result.extend(shape_only(item) for item in payload_expr_nodes(value,assigned,parameters,set(seen)))
+        return result
+    if isinstance(expr,ast.Call):
+        result=[]
+        if isinstance(expr.func,ast.Name) and expr.func.id in FUNCTION_PAYLOADS:
+            result.extend(FUNCTION_PAYLOADS[expr.func.id])
+            override_keys=[]; override_values=[]
+            for keyword in expr.keywords:
+                if keyword.arg:
+                    override_keys.append(ast.Constant(keyword.arg)); override_values.append(keyword.value)
+            if override_keys: result.append(ast.Dict(keys=override_keys,values=override_values))
+        # A transport body may be assembled by a local combinator such as
+        # _apply_patch(_base_body(...), patch). Because this traversal starts
+        # only from an identified transport-body position, recursively merging
+        # argument shapes is narrower than scanning arbitrary helper calls.
+        for argument in expr.args:
+            result.extend(payload_expr_nodes(argument,assigned,parameters,set(seen)))
+        for keyword in expr.keywords:
+            result.extend(payload_expr_nodes(keyword.value,assigned,parameters,set(seen)))
+        return result
+    return []
+
+def decorator_parameter_values(dec):
+    result={}
+    if not isinstance(dec,ast.Call) or not isinstance(dec.func,ast.Attribute) or dec.func.attr != 'parametrize' or len(dec.args) < 2: return result
+    if not isinstance(dec.args[0],ast.Constant) or not isinstance(dec.args[0].value,str): return result
+    names=[item.strip() for item in dec.args[0].value.split(',')]
+    rows=dec.args[1]
+    if isinstance(rows,ast.Name) and rows.id in GLOBAL_VALUES: rows=GLOBAL_VALUES[rows.id]
+    for node in ast.walk(rows):
+        if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute) or node.func.attr != 'param': continue
+        for index,name in enumerate(names):
+            if index < len(node.args): result.setdefault(name,[]).append(node.args[index])
+    return result
+
+def decorator_payload_nodes(parameters,assigned):
+    result=[]
+    for name,values in parameters.items():
+        if name.lower() not in PAYLOAD_NAMES: continue
+        for value in values: result.extend(payload_expr_nodes(value,assigned,parameters))
+    return result
+
+def fallback_payload_nodes(fn):
+    result=[]
+    assigned={}
+    for node in ast.walk(fn):
+        if isinstance(node,(ast.Assign,ast.AnnAssign)):
+            if node.value is None: continue
+            targets=node.targets if isinstance(node,ast.Assign) else [node.target]
+            for target in targets:
+                if isinstance(target,ast.Name): assigned[target.id]=node.value
+    parameters={}
+    for dec in fn.decorator_list:
+        for name,values in decorator_parameter_values(dec).items(): parameters.setdefault(name,[]).extend(values)
+    for node in ast.walk(fn):
+        if not isinstance(node,ast.Call): continue
+        callee=None
+        if isinstance(node.func,ast.Name): callee=node.func.id
+        elif isinstance(node.func,ast.Attribute): callee=node.func.attr
+        result.extend(FUNCTION_TRANSPORT_SHAPES.get(callee,[]))
+        # Wrapper payloads are fallback evidence: they are useful when the Case
+        # contract requires a body, but must not contaminate GET/DELETE targets
+        # merely because setup creates a resource first.
+        for parameter_name,position in TRANSPORT_PAYLOAD_PARAMS.get(callee,[]):
+            matched=next((keyword.value for keyword in node.keywords if keyword.arg == parameter_name),None)
+            if matched is None and position >= 0 and position < len(node.args): matched=node.args[position]
+            if matched is not None: result.extend(payload_expr_nodes(matched,assigned,parameters))
+    return result
+
+def is_direct_transport_call(node):
+    if not isinstance(node,ast.Call) or not isinstance(node.func,ast.Attribute): return False
+    if node.func.attr.lower() not in {'get','post','put','patch','delete','request'}: return False
+    receiver_tokens=[]
+    current=node.func.value
+    while isinstance(current,ast.Attribute):
+        receiver_tokens.append(current.attr.lower())
+        current=current.value
+    if isinstance(current,ast.Name): receiver_tokens.append(current.id.lower())
+    return any(token in {'requests','httpx','client','session','api_client','http_client'} or token.endswith('_client') for token in receiver_tokens)
+
+def payload_nodes(fn):
+    result=[]
+    assigned={}
+    for node in ast.walk(fn):
+        if isinstance(node,(ast.Assign,ast.AnnAssign)):
+            if node.value is None: continue
+            targets=node.targets if isinstance(node,ast.Assign) else [node.target]
+            for target in targets:
+                if isinstance(target,ast.Name): assigned[target.id]=node.value
+    parameters={}
+    for dec in fn.decorator_list:
+        for name,values in decorator_parameter_values(dec).items(): parameters.setdefault(name,[]).extend(values)
+    result.extend(decorator_payload_nodes(parameters,assigned))
+    for dec in fn.decorator_list:
+        for node in ast.walk(dec):
+            if isinstance(node,ast.Call) and isinstance(node.func,ast.Name) and node.func.id in FUNCTION_PAYLOADS:
+                result.extend(payload_expr_nodes(node,assigned,parameters))
+            elif isinstance(node,ast.Name) and node.id in GLOBAL_PAYLOADS:
+                result.extend(GLOBAL_PAYLOADS[node.id])
+    # Observe local payload/body variables only when they flow into a direct
+    # HTTP transport call. Arbitrary setup variables are not target requests.
+    for node in ast.walk(fn):
+        if not is_direct_transport_call(node): continue
+        for keyword in node.keywords:
+            if keyword.arg in PAYLOAD_NAMES: result.extend(payload_expr_nodes(keyword.value,assigned,parameters))
+    return result
+
+out={}
+for fn in ast.walk(tree):
+    if isinstance(fn,(ast.FunctionDef,ast.AsyncFunctionDef)) and fn.name.startswith('test_'):
+        paths=set(); values={}
+        fallback_paths=set(); fallback_values={}
+        for node in payload_nodes(fn): collect_dict(node,'',paths,values)
+        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values)
+        out[fn.name]={
+            'paths':sorted(paths),
+            'values':{key:sorted(items) for key,items in sorted(values.items())},
+            'fallbackPaths':sorted(fallback_paths),
+            'fallbackValues':{key:sorted(items) for key,items in sorted(fallback_values.items())},
+        }
+print(json.dumps(out,ensure_ascii=True))
+`;
+    // Pass bytes and decode stdin explicitly as UTF-8 in Python. Clean-env
+    // Windows Python may expose stdin as GBK; decoding generated Chinese/emoji
+    // source through that locale can create surrogateescape code points and make
+    // ast.parse fail with "surrogates not allowed".
+    const result = spawnSync("python", ["-c", program], { input: Buffer.from(source, "utf8"), encoding: "utf8", maxBuffer: 4 * 1024 * 1024, windowsHide: true });
+    if (result.status !== 0 || !result.stdout.trim())
+        return new Map();
+    try {
+        const parsed = JSON.parse(result.stdout);
+        return new Map(Object.entries(parsed));
+    }
+    catch {
+        return new Map();
+    }
+}
+function metadataCaseIds(region) {
+    return orderedUnique([...region.matchAll(/^\s*Case-ID\s*:\s*(BE-[A-Z0-9]+(?:-[A-Z0-9]+)*)\s*$/gmi)]
+        .map((match) => canonicalCaseId(match[1])));
+}
 function metadataTestPoints(region, label) {
     const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
@@ -928,10 +1534,35 @@ function pytestFunctionRegionStart(source, functionIndex) {
     }
     return regionStart;
 }
+function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
+    let cursor = source.indexOf("\n", signatureEnd);
+    if (cursor < 0)
+        return source.length;
+    cursor += 1;
+    const baseIndent = functionIndent.replaceAll("\t", "    ").length;
+    while (cursor < source.length) {
+        const nextLine = source.indexOf("\n", cursor);
+        const lineEnd = nextLine < 0 ? source.length : nextLine;
+        const line = source.slice(cursor, lineEnd).replace(/\r$/, "");
+        if (line.trim()) {
+            const indentation = line.match(/^[ \t]*/)?.[0]?.replaceAll("\t", "    ").length ?? 0;
+            if (indentation <= baseIndent)
+                return cursor;
+        }
+        if (nextLine < 0)
+            return source.length;
+        cursor = nextLine + 1;
+    }
+    return source.length;
+}
 function pytestParameterCollections(source) {
     const collections = new Map();
-    for (const match of source.matchAll(/^([A-Z][A-Z0-9_]*)\s*=\s*\[([\s\S]*?)^\]/gm)) {
-        collections.set(match[1], orderedUnique([...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])));
+    for (const match of source.matchAll(/^(_?[A-Z][A-Z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
+        const explicitIds = [...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]);
+        const factoryIds = explicitIds.length === 0
+            ? [...match[2].matchAll(/["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])
+            : [];
+        collections.set(match[1], orderedUnique([...explicitIds, ...factoryIds]));
     }
     return collections;
 }
@@ -939,21 +1570,29 @@ function pytestSymbols(script, source) {
     const matches = [...source.matchAll(/^([ \t]*)(?:async\s+)?def\s+(test_[A-Za-z0-9_]+)\s*\([^)]*\)\s*(?:->\s*[^:\r\n]+)?\s*:/gm)];
     const regionStarts = matches.map((match) => pytestFunctionRegionStart(source, match.index));
     const parameterCollections = pytestParameterCollections(source);
+    const payloadShapes = pythonPayloadShapes(source);
     return matches.map((match, index) => {
         const regionStart = regionStarts[index];
-        const regionEnd = regionStarts[index + 1] ?? source.length;
+        const regionEnd = pytestFunctionBodyEnd(source, match.index + match[0].length, match[1]);
         const region = source.slice(match.index, regionEnd);
         const decorators = source.slice(regionStart, match.index);
-        const ids = caseIds(region);
+        const ids = metadataCaseIds(region);
         const fromSymbol = symbolCaseId(match[2]);
         if (fromSymbol)
             ids.unshift(fromSymbol);
+        const explicitParameterIds = [...decorators.matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]);
+        const collectionParameterIds = [...parameterCollections.entries()].flatMap(([name, values]) => new RegExp(`\\b${name}\\b`).test(decorators) ? values : []);
+        const factoryParameterIds = explicitParameterIds.length === 0 && collectionParameterIds.length === 0
+            ? [...decorators.matchAll(/["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])
+            : [];
         const parameterIds = orderedUnique([
-            ...[...decorators.matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]),
-            ...[...parameterCollections.entries()].flatMap(([name, values]) => new RegExp(`\\b${name}\\b`).test(decorators) ? values : []),
+            ...explicitParameterIds,
+            ...collectionParameterIds,
+            ...factoryParameterIds,
         ]);
         const assertionTestPoints = metadataTestPoints(region, "Assertion-Test-Points");
         const crossCuttingTestPoints = metadataTestPoints(region, "Cross-Cutting-Test-Points");
+        const payloadShape = payloadShapes.get(match[2]) ?? { paths: [], values: {} };
         return {
             script,
             symbol: match[2],
@@ -962,13 +1601,69 @@ function pytestSymbols(script, source) {
             parameterIds,
             assertionTestPoints,
             crossCuttingTestPoints,
+            payloadPaths: payloadShape.paths,
+            payloadValues: payloadShape.values,
+            fallbackPayloadPaths: payloadShape.fallbackPaths ?? [],
+            fallbackPayloadValues: payloadShape.fallbackValues ?? {},
         };
     });
 }
+function executionSignature(testCase) {
+    const operation = (testCase.body.match(/\b(?:GET|POST|PUT|PATCH|DELETE)\s+\/[^\s`|)]+/i)?.[0] ?? "operation-unavailable").toUpperCase();
+    const inputPartition = [sectionBody(testCase.body, ["测试数据", "Test Data"]), testCase.scenarioTypes.join(" "), testCase.testPoints.join(" ")].join(" ");
+    const precondition = sectionBody(testCase.body, ["前置条件", "Preconditions", "Precondition"]);
+    const expectedOutcome = sectionBody(testCase.body, ["预期结果", "Expected Results", "Expected Result"]);
+    const normalized = [operation, inputPartition, precondition, expectedOutcome]
+        .map((value) => value.replaceAll(/\s+/g, " ").trim().toLowerCase())
+        .join("\n");
+    return createHash("sha256").update(normalized).digest("hex");
+}
+function assessPayloadContract(testCase, refs) {
+    const requiredPaths = testCase.payloadContract.requiredPaths;
+    const directObservedPaths = orderedUnique(refs.flatMap((item) => item.payloadPaths));
+    const useFallback = requiredPaths.length > 0 && directObservedPaths.length === 0;
+    const analyzedObservedPaths = useFallback
+        ? orderedUnique(refs.flatMap((item) => item.fallbackPayloadPaths))
+        : directObservedPaths;
+    // A no-body target contract describes the target GET/DELETE request, not
+    // setup POST/PUT calls in the same lifecycle test function.
+    const observedPaths = testCase.payloadContract.noPayload ? [] : analyzedObservedPaths;
+    const allowedPaths = testCase.payloadContract.allowedPaths;
+    if (!testCase.payloadContract.declared) {
+        return { status: "UNAVAILABLE", requiredPaths, allowedPaths, observedPaths, missingPaths: [], unexpectedPaths: [], enumMismatches: [] };
+    }
+    const missingPaths = requiredPaths.filter((item) => !observedPaths.includes(item));
+    const unexpectedPaths = testCase.payloadContract.noPayload
+        ? observedPaths
+        : allowedPaths.length > 0
+            ? observedPaths.filter((item) => !allowedPaths.includes(item) && !allowedPaths.some((allowed) => item.startsWith(`${allowed}.`)))
+            : [];
+    const enumMismatches = [];
+    const delegatesInvalidEnumToScenarioGate = testCase.testPointBindings
+        .filter((binding) => binding.mode === "variant")
+        .some((binding) => /(?:ENUM|CATEGORY).*(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE)|(?:INVALID|UNKNOWN|CASE|WHITESPACE|EMPTY|WRONG-TYPE).*(?:ENUM|CATEGORY)/.test(binding.testPoint));
+    for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
+        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []).map((value) => value.replace(/^['"]|['"]$/g, "")));
+        for (const value of observed) {
+            if (!allowed.includes(value) && !delegatesInvalidEnumToScenarioGate)
+                enumMismatches.push(`${field}=${value}; allowed=${allowed.join("|")}`);
+        }
+    }
+    return {
+        status: missingPaths.length > 0 || unexpectedPaths.length > 0 || enumMismatches.length > 0 ? "UNSAFE" : "SAFE",
+        requiredPaths,
+        allowedPaths,
+        observedPaths,
+        missingPaths,
+        unexpectedPaths,
+        enumMismatches,
+    };
+}
 export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
-    const cases = await parseMarkdownCases(input.workspaceRoot);
+    const layout = input.layout ?? resolveBackendTestLayout(undefined);
+    const cases = await parseMarkdownCases(input.workspaceRoot, layout);
     const modulePaths = orderedUnique(cases.map((item) => item.markdownPath));
-    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath)]));
+    const scripts = orderedUnique(cases.flatMap((item) => [...item.declaredScripts, expectedScript(item.markdownPath, layout)]));
     const allSymbols = [];
     const scriptFiles = [];
     for (const script of scripts) {
@@ -981,7 +1676,7 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
     const findings = [];
     const entries = [];
     for (const testCase of cases) {
-        const expected = expectedScript(testCase.markdownPath);
+        const expected = expectedScript(testCase.markdownPath, layout);
         const declared = testCase.declaredScripts[0];
         const refs = allSymbols.filter((item) => item.caseIds.includes(testCase.caseId));
         const actualScripts = orderedUnique(refs.map((item) => item.script));
@@ -998,21 +1693,44 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             ...crossCuttingTestPoints.filter((point) => crossCuttingBindings.includes(point)),
         ]);
         const declaredPrimarySymbol = testCase.declaredPrimarySymbols[0];
+        const evidenceOnly = isEvidenceOnlyMarkdownCase(testCase);
         const cardinality = refs.length === 0 ? "1:0" : refs.length === 1 ? "1:1" : "1:N";
-        let status = refs.length === 0 ? "MISSING_PYTEST" : refs.length > 1 ? "MULTIPLE_PYTEST" : "EXACT_1_TO_1";
+        let status = evidenceOnly && refs.length === 0
+            ? "EXACT_1_TO_1"
+            : refs.length === 0
+                ? "MISSING_PYTEST"
+                : refs.length > 1
+                    ? "MULTIPLE_PYTEST"
+                    : "EXACT_1_TO_1";
         const entryFindings = [];
-        if (refs.length === 0)
-            entryFindings.push(`${testCase.caseId} has no pytest symbol`);
-        if (refs.length > 1)
-            entryFindings.push(`${testCase.caseId} maps to multiple pytest symbols: ${symbols.join(", ")}`);
-        if (!declared || declared !== expected || actualScripts.some((script) => script !== expected) || !declaredPrimarySymbol || symbols.some((symbol) => symbol !== declaredPrimarySymbol)) {
-            if (refs.length > 0 && status === "EXACT_1_TO_1")
+        const payloadAssessment = assessPayloadContract(testCase, refs);
+        const signature = executionSignature(testCase);
+        if (evidenceOnly) {
+            if (refs.length > 0) {
                 status = "SCRIPT_MISMATCH";
-            entryFindings.push(`${testCase.caseId} script/primary-symbol mapping mismatch: declaredScript=${declared ?? "none"}, expectedScript=${expected}, actual=${actualScripts.join(", ") || "none"}, declaredPrimarySymbol=${declaredPrimarySymbol ?? "none"}, actualSymbols=${symbols.join(", ") || "none"}`);
+                entryFindings.push(`${testCase.caseId} evidence-only Markdown Case must not materialize a business pytest symbol; actualSymbols=${symbols.join(", ") || "none"}`);
+            }
+        }
+        else {
+            if (refs.length === 0)
+                entryFindings.push(`${testCase.caseId} has no pytest symbol`);
+            if (refs.length > 1)
+                entryFindings.push(`${testCase.caseId} maps to multiple pytest symbols: ${symbols.join(", ")}`);
+            if (!declared || declared !== expected || actualScripts.some((script) => script !== expected) || !declaredPrimarySymbol || symbols.some((symbol) => symbol !== declaredPrimarySymbol)) {
+                if (refs.length > 0 && status === "EXACT_1_TO_1")
+                    status = "SCRIPT_MISMATCH";
+                entryFindings.push(`${testCase.caseId} script/primary-symbol mapping mismatch: declaredScript=${declared ?? "none"}, expectedScript=${expected}, actual=${actualScripts.join(", ") || "none"}, declaredPrimarySymbol=${declaredPrimarySymbol ?? "none"}, actualSymbols=${symbols.join(", ") || "none"}`);
+            }
         }
-        const missingVariant = variantTestPoints.filter((point) => !parameterIds.includes(point));
-        const missingAssertion = assertionTestPoints.filter((point) => !assertionBindings.includes(point));
-        const missingCrossCutting = crossCuttingTestPoints.filter((point) => !crossCuttingBindings.includes(point));
+        const missingVariant = evidenceOnly
+            ? []
+            : variantTestPoints.filter((point) => !parameterIds.includes(point));
+        const missingAssertion = evidenceOnly
+            ? []
+            : assertionTestPoints.filter((point) => !assertionBindings.includes(point));
+        const missingCrossCutting = evidenceOnly
+            ? []
+            : crossCuttingTestPoints.filter((point) => !crossCuttingBindings.includes(point));
         const extraPoints = orderedUnique([...parameterIds, ...assertionBindings, ...crossCuttingBindings]).filter((point) => !testCase.testPoints.includes(point));
         if (testCase.unclassifiedTestPoints.length > 0 || testCase.duplicateBindingTestPoints.length > 0) {
             if (refs.length > 0 && status === "EXACT_1_TO_1")
@@ -1039,6 +1757,16 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
                 status = "TEST_POINT_BINDING_EXTRA";
             entryFindings.push(`${testCase.caseId} has extra pytest Test Point bindings: ${extraPoints.join(", ")}`);
         }
+        if (payloadAssessment.status === "UNAVAILABLE") {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "PAYLOAD_CONTRACT_UNAVAILABLE";
+            entryFindings.push(`${testCase.caseId} has no deterministic Payload Contract declaration`);
+        }
+        else if (payloadAssessment.status === "UNSAFE") {
+            if (refs.length > 0 && status === "EXACT_1_TO_1")
+                status = "PAYLOAD_SHAPE_MISMATCH";
+            entryFindings.push(`${testCase.caseId} payload contract mismatch: missing=${payloadAssessment.missingPaths.join(", ") || "none"}; unexpected=${payloadAssessment.unexpectedPaths.join(", ") || "none"}; enum=${payloadAssessment.enumMismatches.join(", ") || "none"}`);
+        }
         findings.push(...entryFindings);
         entries.push({
             markdownModule: testCase.markdownPath,
@@ -1056,6 +1784,8 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             parameterIds,
             cardinality,
             status,
+            payloadAssessment,
+            executionSignature: signature,
             findings: entryFindings,
         });
     }
@@ -1082,23 +1812,41 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             parameterIds: symbol.parameterIds,
             cardinality: "0:1",
             status: unknownId ? "EXTRA_PYTEST" : "SYMBOL_MISSING_CASE_ID",
+            payloadAssessment: {
+                status: "UNAVAILABLE",
+                requiredPaths: [],
+                allowedPaths: [],
+                observedPaths: symbol.payloadPaths,
+                missingPaths: [],
+                unexpectedPaths: [],
+                enumMismatches: [],
+            },
             findings: [message],
         });
     }
+    const duplicateSignatures = new Map();
+    for (const entry of entries.filter((item) => item.caseId && item.executionSignature)) {
+        const owners = duplicateSignatures.get(entry.executionSignature) ?? [];
+        owners.push(entry.caseId);
+        duplicateSignatures.set(entry.executionSignature, owners);
+    }
+    const duplicateSignatureGroups = [...duplicateSignatures.entries()].filter(([, owners]) => orderedUnique(owners).length > 1);
+    for (const [signature, owners] of duplicateSignatureGroups)
+        findings.push(`duplicate execution signature ${signature}: ${orderedUnique(owners).join(", ")}`);
     const exactModuleCount = modulePaths.filter((modulePath) => {
-        const expected = expectedScript(modulePath);
+        const expected = expectedScript(modulePath, layout);
         const moduleCases = cases.filter((item) => item.markdownPath === modulePath);
         return moduleCases.every((item) => item.declaredScripts.length === 1 && item.declaredScripts[0] === expected) && scriptFiles.some((file) => path.relative(input.workspaceRoot, file).replaceAll(path.sep, "/") === expected);
     }).length;
     const caseEntries = entries.filter((entry) => entry.cardinality !== "0:1");
     const facts = backendTestMarkdownPytestCorrespondenceFactsSchema.parse({
-        schemaId: "backend-test-markdown-pytest-correspondence-facts-v2",
-        schemaVersion: 2,
+        schemaId: "backend-test-markdown-pytest-correspondence-facts-v3",
+        schemaVersion: 3,
         taskId: input.taskId,
         status: findings.length === 0 ? "PASS" : "FAIL",
         inputFiles: await inputFileFacts(input.workspaceRoot, [
-            path.join(input.workspaceRoot, "testcase", "md", "README.md"),
-            ...(await markdownModuleFiles(input.workspaceRoot)),
+            path.join(input.workspaceRoot, ...layout.readmePath.split("/")),
+            ...(await markdownModuleFiles(input.workspaceRoot, layout)),
             ...scriptFiles,
         ].filter((file) => file && path.isAbsolute(file))),
         summary: {
@@ -1118,6 +1866,10 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
             crossCuttingTestPointCount: cases.reduce((sum, item) => sum + item.testPointBindings.filter((binding) => binding.mode === "cross-cutting").length, 0),
             unclassifiedTestPointCount: cases.reduce((sum, item) => sum + item.unclassifiedTestPoints.length, 0),
             duplicateBindingTestPointCount: cases.reduce((sum, item) => sum + item.duplicateBindingTestPoints.length, 0),
+            payloadSafeCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "SAFE").length,
+            payloadUnsafeCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "UNSAFE").length,
+            payloadUnavailableCount: caseEntries.filter((entry) => entry.payloadAssessment.status === "UNAVAILABLE").length,
+            duplicateExecutionSignatureCount: duplicateSignatureGroups.length,
         },
         entries,
         findings: orderedUnique(findings),
@@ -1145,12 +1897,16 @@ export async function analyzeBackendTestMarkdownPytestCorrespondence(input) {
         `- Cross-Cutting Test Points: ${facts.summary.crossCuttingTestPointCount}`,
         `- Unclassified Test Points: ${facts.summary.unclassifiedTestPointCount}`,
         `- Duplicate Test Point Bindings: ${facts.summary.duplicateBindingTestPointCount}`,
+        `- Payload SAFE: ${facts.summary.payloadSafeCount}`,
+        `- Payload UNSAFE: ${facts.summary.payloadUnsafeCount}`,
+        `- Payload UNAVAILABLE: ${facts.summary.payloadUnavailableCount}`,
+        `- Duplicate Execution Signatures: ${facts.summary.duplicateExecutionSignatureCount}`,
         "",
         "## Correspondence Matrix",
         "",
-        "| Markdown Module | Case ID | Variant | Assertion | Cross-Cutting | Mapped | Declared Script | Primary Symbol | Actual Script | Pytest Symbol | Parameter IDs | Cardinality | Status |",
-        "|---|---|---|---|---|---|---|---|---|---|---|---|---|",
-        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.variantTestPoints.join(", ") || "—"} | ${entry.assertionTestPoints.join(", ") || "—"} | ${entry.crossCuttingTestPoints.join(", ") || "—"} | ${entry.mappedTestPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.declaredPrimarySymbol ?? "—"} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.join(", ") || "—"} | ${entry.cardinality} | ${entry.status} |`),
+        "| Markdown Module | Case ID | Variant | Assertion | Cross-Cutting | Mapped | Declared Script | Primary Symbol | Actual Script | Pytest Symbol | Parameter IDs | Payload | Missing Paths | Unexpected Paths | Enum Mismatch | Cardinality | Status |",
+        "|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|",
+        ...facts.entries.map((entry) => `| ${entry.markdownModule} | ${entry.caseId ?? "—"} | ${entry.variantTestPoints.join(", ") || "—"} | ${entry.assertionTestPoints.join(", ") || "—"} | ${entry.crossCuttingTestPoints.join(", ") || "—"} | ${entry.mappedTestPoints.join(", ") || "—"} | ${entry.declaredScript ?? "—"} | ${entry.declaredPrimarySymbol ?? "—"} | ${entry.actualScripts.join(", ") || "—"} | ${entry.pytestSymbols.join(", ") || "—"} | ${entry.parameterIds.join(", ") || "—"} | ${entry.payloadAssessment.status} | ${entry.payloadAssessment.missingPaths.join(", ") || "—"} | ${entry.payloadAssessment.unexpectedPaths.join(", ") || "—"} | ${entry.payloadAssessment.enumMismatches.join(", ") || "—"} | ${entry.cardinality} | ${entry.status} |`),
         "",
         "## Findings",
         "",